.-.-.-.-.-

PK�^�\�j�WWpackage.jsonnu�[���{
  "_id": "err-code@2.0.3",
  "_inBundle": true,
  "_location": "/npm/err-code",
  "_phantomChildren": {},
  "_requiredBy": [
    "/npm/promise-retry"
  ],
  "author": {
    "name": "IndigoUnited",
    "email": "hello@indigounited.com",
    "url": "http://indigounited.com"
  },
  "bugs": {
    "url": "https://github.com/IndigoUnited/js-err-code/issues/"
  },
  "description": "Create an error with a code",
  "devDependencies": {
    "@satazor/eslint-config": "^3.0.0",
    "browserify": "^16.5.1",
    "eslint": "^7.2.0",
    "expect.js": "^0.3.1",
    "mocha": "^8.0.1"
  },
  "homepage": "https://github.com/IndigoUnited/js-err-code#readme",
  "keywords": [
    "error",
    "err",
    "code",
    "properties",
    "property"
  ],
  "license": "MIT",
  "main": "index.js",
  "name": "err-code",
  "repository": {
    "type": "git",
    "url": "git://github.com/IndigoUnited/js-err-code.git"
  },
  "scripts": {
    "browserify": "browserify -s err-code index.js > index.umd.js",
    "lint": "eslint '{*.js,test/**/*.js}' --ignore-pattern *.umd.js",
    "test": "mocha --bail"
  },
  "version": "2.0.3"
}
PK�^�\��U�bbtest/test.jsnu�[���'use strict';

const errcode = require('../index');
const expect = require('expect.js');

describe('errcode', () => {
    describe('string as first argument', () => {
        it('should throw an error', () => {
            expect(() => { errcode('my message'); }).to.throwError((err) => {
                expect(err).to.be.a(TypeError);
            });
        });
    });

describe('error as first argument', () => {
        it('should accept an error and do nothing', () => {
            const myErr = new Error('my message');
            const err = errcode(myErr);

expect(err).to.be(myErr);
            expect(err.hasOwnProperty(err.code)).to.be(false);
        });

it('should accept an error and add a code', () => {
            const myErr = new Error('my message');
            const err = errcode(myErr, 'ESOME');

expect(err).to.be(myErr);
            expect(err.code).to.be('ESOME');
        });

it('should accept an error object and add code & properties', () => {
            const myErr = new Error('my message');
            const err = errcode(myErr, 'ESOME', { foo: 'bar', bar: 'foo' });

expect(err).to.be.an(Error);
            expect(err.code).to.be('ESOME');
            expect(err.foo).to.be('bar');
            expect(err.bar).to.be('foo');
        });

it('should create an error object without code but with properties', () => {
            const myErr = new Error('my message');
            const err = errcode(myErr, { foo: 'bar', bar: 'foo' });

expect(err).to.be.an(Error);
            expect(err.code).to.be(undefined);
            expect(err.foo).to.be('bar');
            expect(err.bar).to.be('foo');
        });

it('should set a non-writable field', () => {
            const myErr = new Error('my message');

Object.defineProperty(myErr, 'code', {
                value: 'derp',
                writable: false,
            });
            const err = errcode(myErr, 'ERR_WAT');

expect(err).to.be.an(Error);
            expect(err.stack).to.equal(myErr.stack);
            expect(err.code).to.be('ERR_WAT');
        });

it('should add a code to frozen object', () => {
            const myErr = new Error('my message');
            const err = errcode(Object.freeze(myErr), 'ERR_WAT');

expect(err).to.be.an(Error);
            expect(err.stack).to.equal(myErr.stack);
            expect(err.code).to.be('ERR_WAT');
        });

it('should to set a field that throws at assignment time', () => {
            const myErr = new Error('my message');

Object.defineProperty(myErr, 'code', {
                enumerable: true,
                set() {
                    throw new Error('Nope!');
                },
                get() {
                    return 'derp';
                },
            });
            const err = errcode(myErr, 'ERR_WAT');

expect(err).to.be.an(Error);
            expect(err.stack).to.equal(myErr.stack);
            expect(err.code).to.be('ERR_WAT');
        });

it('should retain error type', () => {
            const myErr = new TypeError('my message');

Object.defineProperty(myErr, 'code', {
                value: 'derp',
                writable: false,
            });
            const err = errcode(myErr, 'ERR_WAT');

expect(err).to.be.a(TypeError);
            expect(err.stack).to.equal(myErr.stack);
            expect(err.code).to.be('ERR_WAT');
        });

it('should add a code to a class that extends Error', () => {
            class CustomError extends Error {
                set code(val) {
                    throw new Error('Nope!');
                }
            }

const myErr = new CustomError('my message');

Object.defineProperty(myErr, 'code', {
                value: 'derp',
                writable: false,
                configurable: false,
            });
            const err = errcode(myErr, 'ERR_WAT');

expect(err).to.be.a(CustomError);
            expect(err.stack).to.equal(myErr.stack);
            expect(err.code).to.be('ERR_WAT');

// original prototype chain should be intact
            expect(() => {
                const otherErr = new CustomError('my message');

otherErr.code = 'derp';
            }).to.throwError();
        });

it('should support errors that are not Errors', () => {
            const err = errcode({
                message: 'Oh noes!',
            }, 'ERR_WAT');

expect(err.message).to.be('Oh noes!');
            expect(err.code).to.be('ERR_WAT');
        });
    });

describe('falsy first arguments', () => {
        it('should not allow passing null as the first argument', () => {
            expect(() => { errcode(null); }).to.throwError((err) => {
                expect(err).to.be.a(TypeError);
            });
        });

it('should not allow passing undefined as the first argument', () => {
            expect(() => { errcode(undefined); }).to.throwError((err) => {
                expect(err).to.be.a(TypeError);
            });
        });
    });
});
PK�^�\�`.��index.jsnu�[���'use strict';

function assign(obj, props) {
    for (const key in props) {
        Object.defineProperty(obj, key, {
            value: props[key],
            enumerable: true,
            configurable: true,
        });
    }

return obj;
}

function createError(err, code, props) {
    if (!err || typeof err === 'string') {
        throw new TypeError('Please pass an Error to err-code');
    }

if (!props) {
        props = {};
    }

if (typeof code === 'object') {
        props = code;
        code = undefined;
    }

if (code != null) {
        props.code = code;
    }

try {
        return assign(err, props);
    } catch (_) {
        props.message = err.message;
        props.stack = err.stack;

const ErrClass = function () {};

ErrClass.prototype = Object.create(Object.getPrototypeOf(err));

return assign(new ErrClass(), props);
    }
}

module.exports = createError;
PK�^�\!S�index.umd.jsnu�[���(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.errCode = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
'use strict';

return obj;
}

function createError(err, code, props) {
    if (!err || typeof err === 'string') {
        throw new TypeError('Please pass an Error to err-code');
    }

if (!props) {
        props = {};
    }

if (typeof code === 'object') {
        props = code;
        code = undefined;
    }

if (code != null) {
        props.code = code;
    }

try {
        return assign(err, props);
    } catch (_) {
        props.message = err.message;
        props.stack = err.stack;

const ErrClass = function () {};

ErrClass.prototype = Object.create(Object.getPrototypeOf(err));

return assign(new ErrClass(), props);
    }
}

module.exports = createError;

},{}]},{},[1])(1)
});
PK�^�\A�O�MM
bower.jsonnu�[���{
  "name": "err-code",
  "version": "1.1.1",
  "description": "Create new error instances with a code and additional properties",
  "main": "index.umd.js",
  "homepage": "https://github.com/IndigoUnited/js-err-code",
  "authors": [
    "IndigoUnited <hello@indigounited.com> (http://indigounited.com)"
  ],
  "moduleType": [
    "amd",
    "globals",
    "node"
  ],
  "keywords": [
      "error",
      "err",
      "code",
      "properties",
      "property"
  ],
  "license": "MIT",
  "ignore": [
    "**/.*",
    "node_modules",
    "bower_components",
    "test",
    "tests"
  ]
}
PK�^�\�j�WWpackage.jsonnu�[���PK�^�\��U�bb�test/test.jsnu�[���PK�^�\�`.��1index.jsnu�[���PK�^�\!S�index.umd.jsnu�[���PK�^�\A�O�MM
g$bower.jsonnu�[���PKv�&

/home/emeraadmin/www/node_modules/npm/../xmlbuilder/../xmlbuilder/../debug/../../4d695/err-code.zip