This commit is contained in:
eric sciple 2020-01-24 12:20:47 -05:00
parent a004f0ae58
commit fc725ba36b
7280 changed files with 19 additions and 1796407 deletions

5
node_modules/make-error/LICENSE generated vendored
View file

@ -1,5 +0,0 @@
Copyright 2014 Julien Fontanet
Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

111
node_modules/make-error/README.md generated vendored
View file

@ -1,111 +0,0 @@
# make-error [![Build Status](https://img.shields.io/travis/JsCommunity/make-error/master.svg)](http://travis-ci.org/JsCommunity/make-error)
> Make your own error types!
## Features
- Compatible Node & browsers
- `instanceof` support
- `error.name` & `error.stack` support
- compatible with [CSP](https://en.wikipedia.org/wiki/Content_Security_Policy) (i.e. no `eval()`)
## Installation
### Node & [Browserify](http://browserify.org/)/[Webpack](https://webpack.js.org/)
Installation of the [npm package](https://npmjs.org/package/make-error):
```
> npm install --save make-error
```
Then require the package:
```javascript
var makeError = require('make-error');
```
### Browser
You can directly use the build provided at [unpkg.com](https://unpkg.com):
```html
<script src="https://unpkg.com/make-error@1/dist/make-error.js"></script>
```
## Usage
### Basic named error
```javascript
var CustomError = makeError('CustomError')
// Parameters are forwarded to the super class (here Error).
throw new CustomError('a message')
```
### Advanced error class
```javascript
function CustomError (customValue) {
CustomError.super.call(this, 'custom error message')
this.customValue = customValue
}
makeError(CustomError)
// Feel free to extend the prototype.
CustomError.prototype.myMethod = function CustomError$myMethod () {
console.log('CustomError.myMethod (%s, %s)', this.code, this.message)
}
//-----
try {
throw new CustomError(42)
} catch (error) {
error.myMethod()
}
```
### Specialized error
```javascript
var SpecializedError = makeError('SpecializedError', CustomError);
throw new SpecializedError(42);
```
### Inheritance
> Best for ES2015+.
```javascript
import {BaseError} from 'make-error'
class CustomError extends BaseError {
constructor () {
super('custom error message')
}
}
```
## Related
- [make-error-cause](https://www.npmjs.com/package/make-error-cause): Make your own error types, with a cause!
## Contributions
Contributions are *very* welcomed, either on the documentation or on
the code.
You may:
- report any [issue](https://github.com/JsCommunity/make-error/issues)
you've encountered;
- fork and create a pull request.
## License
ISC © [Julien Fontanet](http://julien.isonoe.net)

View file

@ -1 +0,0 @@
!function(f){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=f();else if("function"==typeof define&&define.amd)define([],f);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).makeError=f()}}(function(){return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a="function"==typeof require&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n||e)},l,l.exports,e,t,n,r)}return n[o].exports}for(var i="function"==typeof require&&require,o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){"use strict";var construct="undefined"!=typeof Reflect?Reflect.construct:void 0,defineProperty=Object.defineProperty,captureStackTrace=Error.captureStackTrace;void 0===captureStackTrace&&(captureStackTrace=function(error){var container=new Error;defineProperty(error,"stack",{configurable:!0,get:function(){var stack=container.stack;return defineProperty(this,"stack",{configurable:!0,value:stack,writable:!0}),stack},set:function(stack){defineProperty(error,"stack",{configurable:!0,value:stack,writable:!0})}})});function BaseError(message){void 0!==message&&defineProperty(this,"message",{configurable:!0,value:message,writable:!0});var cname=this.constructor.name;void 0!==cname&&cname!==this.name&&defineProperty(this,"name",{configurable:!0,value:cname,writable:!0}),captureStackTrace(this,this.constructor)}BaseError.prototype=Object.create(Error.prototype,{constructor:{configurable:!0,value:BaseError,writable:!0}});var setFunctionName=function(){function setFunctionName(fn,name){return defineProperty(fn,"name",{configurable:!0,value:name})}try{var f=function(){};if(setFunctionName(f,"foo"),"foo"===f.name)return setFunctionName}catch(_){}}();(module.exports=function(constructor,super_){if(null==super_||super_===Error)super_=BaseError;else if("function"!=typeof super_)throw new TypeError("super_ should be a function");var name;if("string"==typeof constructor)name=constructor,constructor=void 0!==construct?function(){return construct(super_,arguments,this.constructor)}:function(){super_.apply(this,arguments)},void 0!==setFunctionName&&(setFunctionName(constructor,name),name=void 0);else if("function"!=typeof constructor)throw new TypeError("constructor should be either a string or a function");constructor.super_=constructor.super=super_;var properties={constructor:{configurable:!0,value:constructor,writable:!0}};return void 0!==name&&(properties.name={configurable:!0,value:name,writable:!0}),constructor.prototype=Object.create(super_.prototype,properties),constructor}).BaseError=BaseError},{}]},{},[1])(1)});

40
node_modules/make-error/index.d.ts generated vendored
View file

@ -1,40 +0,0 @@
/**
* Create a new error constructor instance.
*/
declare function makeError(name: string): makeError.Constructor<makeError.BaseError>;
/**
* Set the constructor prototype to `BaseError`.
*/
declare function makeError<T extends Error>(super_: { new (...args: any[]): T }): makeError.Constructor<T & makeError.BaseError>;
/**
* Create a specialized error instance.
*/
declare function makeError<T extends Error, K>(name: string | Function, super_: K): K & makeError.SpecializedConstructor<T>;
declare module makeError {
/**
* Use with ES2015+ inheritance.
*/
export class BaseError implements Error {
message: string;
name: string;
stack: string;
constructor(message?: string);
}
export interface Constructor <T> {
new (message?: string): T;
super_: any
prototype: T
}
export interface SpecializedConstructor <T> {
super_: any
prototype: T
}
}
export = makeError;

147
node_modules/make-error/index.js generated vendored
View file

@ -1,147 +0,0 @@
// ISC @ Julien Fontanet
'use strict'
// ===================================================================
var construct = typeof Reflect !== 'undefined' ? Reflect.construct : undefined
var defineProperty = Object.defineProperty
// -------------------------------------------------------------------
var captureStackTrace = Error.captureStackTrace
if (captureStackTrace === undefined) {
captureStackTrace = function captureStackTrace (error) {
var container = new Error()
defineProperty(error, 'stack', {
configurable: true,
get: function getStack () {
var stack = container.stack
// Replace property with value for faster future accesses.
defineProperty(this, 'stack', {
configurable: true,
value: stack,
writable: true
})
return stack
},
set: function setStack (stack) {
defineProperty(error, 'stack', {
configurable: true,
value: stack,
writable: true
})
}
})
}
}
// -------------------------------------------------------------------
function BaseError (message) {
if (message !== undefined) {
defineProperty(this, 'message', {
configurable: true,
value: message,
writable: true
})
}
var cname = this.constructor.name
if (
cname !== undefined &&
cname !== this.name
) {
defineProperty(this, 'name', {
configurable: true,
value: cname,
writable: true
})
}
captureStackTrace(this, this.constructor)
}
BaseError.prototype = Object.create(Error.prototype, {
// See: https://github.com/JsCommunity/make-error/issues/4
constructor: {
configurable: true,
value: BaseError,
writable: true
}
})
// -------------------------------------------------------------------
// Sets the name of a function if possible (depends of the JS engine).
var setFunctionName = (function () {
function setFunctionName (fn, name) {
return defineProperty(fn, 'name', {
configurable: true,
value: name
})
}
try {
var f = function () {}
setFunctionName(f, 'foo')
if (f.name === 'foo') {
return setFunctionName
}
} catch (_) {}
})()
// -------------------------------------------------------------------
function makeError (constructor, super_) {
if (super_ == null || super_ === Error) {
super_ = BaseError
} else if (typeof super_ !== 'function') {
throw new TypeError('super_ should be a function')
}
var name
if (typeof constructor === 'string') {
name = constructor
constructor = construct !== undefined
? function () { return construct(super_, arguments, this.constructor) }
: function () { super_.apply(this, arguments) }
// If the name can be set, do it once and for all.
if (setFunctionName !== undefined) {
setFunctionName(constructor, name)
name = undefined
}
} else if (typeof constructor !== 'function') {
throw new TypeError('constructor should be either a string or a function')
}
// Also register the super constructor also as `constructor.super_` just
// like Node's `util.inherits()`.
constructor.super_ = constructor['super'] = super_
var properties = {
constructor: {
configurable: true,
value: constructor,
writable: true
}
}
// If the name could not be set on the constructor, set it on the
// prototype.
if (name !== undefined) {
properties.name = {
configurable: true,
value: name,
writable: true
}
}
constructor.prototype = Object.create(super_.prototype, properties)
return constructor
}
exports = module.exports = makeError
exports.BaseError = BaseError

84
node_modules/make-error/package.json generated vendored
View file

@ -1,84 +0,0 @@
{
"_args": [
[
"make-error@1.3.5",
"/Users/eric/repos/actions/setup-node"
]
],
"_development": true,
"_from": "make-error@1.3.5",
"_id": "make-error@1.3.5",
"_inBundle": false,
"_integrity": "sha512-c3sIjNUow0+8swNwVpqoH4YCShKNFkMaw6oH1mNS2haDZQqkeZFlHS3dhoeEbKKmJB4vXpJucU6oH75aDYeE9g==",
"_location": "/make-error",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "make-error@1.3.5",
"name": "make-error",
"escapedName": "make-error",
"rawSpec": "1.3.5",
"saveSpec": null,
"fetchSpec": "1.3.5"
},
"_requiredBy": [
"/ts-jest"
],
"_resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.5.tgz",
"_spec": "1.3.5",
"_where": "/Users/eric/repos/actions/setup-node",
"author": {
"name": "Julien Fontanet",
"email": "julien.fontanet@isonoe.net"
},
"bugs": {
"url": "https://github.com/JsCommunity/make-error/issues"
},
"description": "Make your own error types!",
"devDependencies": {
"browserify": "^14.5.0",
"husky": "^0.14.3",
"jest": "^20",
"standard": "^10.0.3",
"uglify-js": "^3.3.2"
},
"files": [
"dist/",
"index.js",
"index.d.ts"
],
"homepage": "https://github.com/JsCommunity/make-error",
"jest": {
"testEnvironment": "node"
},
"keywords": [
"create",
"custom",
"derive",
"error",
"errors",
"extend",
"extending",
"extension",
"factory",
"inherit",
"make",
"subclass"
],
"license": "ISC",
"main": "index.js",
"name": "make-error",
"repository": {
"type": "git",
"url": "git://github.com/JsCommunity/make-error.git"
},
"scripts": {
"commitmsg": "yarn test",
"dev-test": "jest --watch",
"prepublishOnly": "mkdir -p dist && browserify -s makeError index.js | uglifyjs -c > dist/make-error.js",
"pretest": "standard",
"test": "jest"
},
"version": "1.3.5"
}