@epic-web/workshop-app 5.0.3 → 5.1.1

package/node_modules/chai/lib/chai/interface/expect.js

@@ -1,55 +0,0 @@
-/*!
- * chai
- * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import * as chai from '../../../index.js';
-import {Assertion} from '../assertion.js';
-import {AssertionError} from 'assertion-error';
-
-/**
- * @param {unknown} val
- * @param {string} message
- * @returns {Assertion}
- */
-function expect(val, message) {
-  return new Assertion(val, message);
-}
-
-export {expect};
-
-/**
- * ### .fail([message])
- * ### .fail(actual, expected, [message], [operator])
- *
- * Throw a failure.
- *
- *     expect.fail();
- *     expect.fail("custom error message");
- *     expect.fail(1, 2);
- *     expect.fail(1, 2, "custom error message");
- *     expect.fail(1, 2, "custom error message", ">");
- *     expect.fail(1, 2, undefined, ">");
- *
- * @name fail
- * @param {unknown} actual
- * @param {unknown} expected
- * @param {string} message
- * @param {string} operator
- * @namespace expect
- * @public
- */
-expect.fail = function (actual, expected, message, operator) {
-  if (arguments.length < 2) {
-      message = actual;
-      actual = undefined;
-  }
-
-  message = message || 'expect.fail()';
-  throw new AssertionError(message, {
-      actual: actual
-    , expected: expected
-    , operator: operator
-  }, chai.expect.fail);
-};

package/node_modules/chai/lib/chai/interface/should.js

@@ -1,221 +0,0 @@
-/*!
- * chai
- * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {Assertion} from '../assertion.js';
-import {AssertionError} from 'assertion-error';
-
-/**
- * @returns {void}
- */
-function loadShould () {
-  // explicitly define this method as function as to have it's name to include as `ssfi`
-  /**
-   * @returns {Assertion}
-   */
-  function shouldGetter() {
-    if (this instanceof String
-        || this instanceof Number
-        || this instanceof Boolean
-        || typeof Symbol === 'function' && this instanceof Symbol
-        || typeof BigInt === 'function' && this instanceof BigInt) {
-      return new Assertion(this.valueOf(), null, shouldGetter);
-    }
-    return new Assertion(this, null, shouldGetter);
-  }
-  /**
-   * @param {unknown} value
-   */
-  function shouldSetter(value) {
-    // See https://github.com/chaijs/chai/issues/86: this makes
-    // `whatever.should = someValue` actually set `someValue`, which is
-    // especially useful for `global.should = require('chai').should()`.
-    //
-    // Note that we have to use [[DefineProperty]] instead of [[Put]]
-    // since otherwise we would trigger this very setter!
-    Object.defineProperty(this, 'should', {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  }
-  // modify Object.prototype to have `should`
-  Object.defineProperty(Object.prototype, 'should', {
-    set: shouldSetter
-    , get: shouldGetter
-    , configurable: true
-  });
-
-  var should = {};
-
-  /**
-   * ### .fail([message])
-   * ### .fail(actual, expected, [message], [operator])
-   *
-   * Throw a failure.
-   *
-   *     should.fail();
-   *     should.fail("custom error message");
-   *     should.fail(1, 2);
-   *     should.fail(1, 2, "custom error message");
-   *     should.fail(1, 2, "custom error message", ">");
-   *     should.fail(1, 2, undefined, ">");
-   *
-   * @name fail
-   * @param {unknown} actual
-   * @param {unknown} expected
-   * @param {string} message
-   * @param {string} operator
-   * @namespace BDD
-   * @public
-   */
-  should.fail = function (actual, expected, message, operator) {
-    if (arguments.length < 2) {
-        message = actual;
-        actual = undefined;
-    }
-
-    message = message || 'should.fail()';
-    throw new AssertionError(message, {
-        actual: actual
-      , expected: expected
-      , operator: operator
-    }, should.fail);
-  };
-
-  /**
-   * ### .equal(actual, expected, [message])
-   *
-   * Asserts non-strict equality (`==`) of `actual` and `expected`.
-   *
-   *     should.equal(3, '3', '== coerces values to strings');
-   *
-   * @name equal
-   * @param {unknown} actual
-   * @param {unknown} expected
-   * @param {string} message
-   * @namespace Should
-   * @public
-   */
-  should.equal = function (actual, expected, message) {
-    new Assertion(actual, message).to.equal(expected);
-  };
-
-  /**
-   * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
-   *
-   * Asserts that `function` will throw an error that is an instance of
-   * `constructor`, or alternately that it will throw an error with message
-   * matching `regexp`.
-   *
-   *     should.throw(fn, 'function throws a reference error');
-   *     should.throw(fn, /function throws a reference error/);
-   *     should.throw(fn, ReferenceError);
-   *     should.throw(fn, ReferenceError, 'function throws a reference error');
-   *     should.throw(fn, ReferenceError, /function throws a reference error/);
-   *
-   * @name throw
-   * @alias Throw
-   * @param {Function} fn
-   * @param {Error} errt
-   * @param {RegExp} errs
-   * @param {string} msg
-   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-   * @namespace Should
-   * @public
-   */
-  should.Throw = function (fn, errt, errs, msg) {
-    new Assertion(fn, msg).to.Throw(errt, errs);
-  };
-
-  /**
-   * ### .exist
-   *
-   * Asserts that the target is neither `null` nor `undefined`.
-   *
-   *     var foo = 'hi';
-   *     should.exist(foo, 'foo exists');
-   *
-   * @param {unknown} val
-   * @param {string} msg
-   * @name exist
-   * @namespace Should
-   * @public
-   */
-  should.exist = function (val, msg) {
-    new Assertion(val, msg).to.exist;
-  }
-
-  // negation
-  should.not = {}
-
-  /**
-   * ### .not.equal(actual, expected, [message])
-   *
-   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
-   *
-   *     should.not.equal(3, 4, 'these numbers are not equal');
-   *
-   * @name not.equal
-   * @param {unknown} actual
-   * @param {unknown} expected
-   * @param {string} msg
-   * @namespace Should
-   * @public
-   */
-  should.not.equal = function (actual, expected, msg) {
-    new Assertion(actual, msg).to.not.equal(expected);
-  };
-
-  /**
-   * ### .throw(function, [constructor/regexp], [message])
-   *
-   * Asserts that `function` will _not_ throw an error that is an instance of
-   * `constructor`, or alternately that it will not throw an error with message
-   * matching `regexp`.
-   *
-   *     should.not.throw(fn, Error, 'function does not throw');
-   *
-   * @name not.throw
-   * @alias not.Throw
-   * @param {Function} fn
-   * @param {Error} errt
-   * @param {RegExp} errs
-   * @param {string} msg
-   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
-   * @namespace Should
-   * @public
-   */
-  should.not.Throw = function (fn, errt, errs, msg) {
-    new Assertion(fn, msg).to.not.Throw(errt, errs);
-  };
-
-  /**
-   * ### .not.exist
-   *
-   * Asserts that the target is neither `null` nor `undefined`.
-   *
-   *     var bar = null;
-   *     should.not.exist(bar, 'bar does not exist');
-   *
-   * @namespace Should
-   * @name not.exist
-   * @param {unknown} val
-   * @param {string} msg
-   * @public
-   */
-  should.not.exist = function (val, msg) {
-    new Assertion(val, msg).to.not.exist;
-  }
-
-  should['throw'] = should['Throw'];
-  should.not['throw'] = should.not['Throw'];
-
-  return should;
-};
-
-export const should = loadShould;
-export const Should = loadShould;

package/node_modules/chai/lib/chai/utils/addChainableMethod.js

@@ -1,147 +0,0 @@
-/*!
- * Chai - addChainingMethod utility
- * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {Assertion} from '../assertion.js';
-import {addLengthGuard} from './addLengthGuard.js';
-import {flag} from './flag.js';
-import {proxify} from './proxify.js';
-import {transferFlags} from './transferFlags.js';
-
-/**
- * Module variables
- */
-
-// Check whether `Object.setPrototypeOf` is supported
-var canSetPrototype = typeof Object.setPrototypeOf === 'function';
-
-// Without `Object.setPrototypeOf` support, this module will need to add properties to a function.
-// However, some of functions' own props are not configurable and should be skipped.
-var testFn = function() {};
-var excludeNames = Object.getOwnPropertyNames(testFn).filter(function(name) {
-  var propDesc = Object.getOwnPropertyDescriptor(testFn, name);
-
-  // Note: PhantomJS 1.x includes `callee` as one of `testFn`'s own properties,
-  // but then returns `undefined` as the property descriptor for `callee`. As a
-  // workaround, we perform an otherwise unnecessary type-check for `propDesc`,
-  // and then filter it out if it's not an object as it should be.
-  if (typeof propDesc !== 'object')
-    return true;
-
-  return !propDesc.configurable;
-});
-
-// Cache `Function` properties
-var call  = Function.prototype.call,
-    apply = Function.prototype.apply;
-
-/**
- * ### .addChainableMethod(ctx, name, method, chainingBehavior)
- *
- * Adds a method to an object, such that the method can also be chained.
- *
- *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
- *         var obj = utils.flag(this, 'object');
- *         new chai.Assertion(obj).to.be.equal(str);
- *     });
- *
- * Can also be accessed directly from `chai.Assertion`.
- *
- *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);
- *
- * The result can then be used as both a method assertion, executing both `method` and
- * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
- *
- *     expect(fooStr).to.be.foo('bar');
- *     expect(fooStr).to.be.foo.equal('foo');
- *
- * @param {object} ctx object to which the method is added
- * @param {string} name of method to add
- * @param {Function} method function to be used for `name`, when called
- * @param {Function} chainingBehavior function to be called every time the property is accessed
- * @namespace Utils
- * @name addChainableMethod
- * @public
- */
-export function addChainableMethod(ctx, name, method, chainingBehavior) {
-  if (typeof chainingBehavior !== 'function') {
-    chainingBehavior = function () { };
-  }
-
-  var chainableBehavior = {
-      method: method
-    , chainingBehavior: chainingBehavior
-  };
-
-  // save the methods so we can overwrite them later, if we need to.
-  if (!ctx.__methods) {
-    ctx.__methods = {};
-  }
-  ctx.__methods[name] = chainableBehavior;
-
-  Object.defineProperty(ctx, name,
-    { get: function chainableMethodGetter() {
-        chainableBehavior.chainingBehavior.call(this);
-
-        var chainableMethodWrapper = function () {
-          // Setting the `ssfi` flag to `chainableMethodWrapper` causes this
-          // function to be the starting point for removing implementation
-          // frames from the stack trace of a failed assertion.
-          //
-          // However, we only want to use this function as the starting point if
-          // the `lockSsfi` flag isn't set.
-          //
-          // If the `lockSsfi` flag is set, then this assertion is being
-          // invoked from inside of another assertion. In this case, the `ssfi`
-          // flag has already been set by the outer assertion.
-          //
-          // Note that overwriting a chainable method merely replaces the saved
-          // methods in `ctx.__methods` instead of completely replacing the
-          // overwritten assertion. Therefore, an overwriting assertion won't
-          // set the `ssfi` or `lockSsfi` flags.
-          if (!flag(this, 'lockSsfi')) {
-            flag(this, 'ssfi', chainableMethodWrapper);
-          }
-
-          var result = chainableBehavior.method.apply(this, arguments);
-          if (result !== undefined) {
-            return result;
-          }
-
-          var newAssertion = new Assertion();
-          transferFlags(this, newAssertion);
-          return newAssertion;
-        };
-
-        addLengthGuard(chainableMethodWrapper, name, true);
-
-        // Use `Object.setPrototypeOf` if available
-        if (canSetPrototype) {
-          // Inherit all properties from the object by replacing the `Function` prototype
-          var prototype = Object.create(this);
-          // Restore the `call` and `apply` methods from `Function`
-          prototype.call = call;
-          prototype.apply = apply;
-          Object.setPrototypeOf(chainableMethodWrapper, prototype);
-        }
-        // Otherwise, redefine all properties (slow!)
-        else {
-          var asserterNames = Object.getOwnPropertyNames(ctx);
-          asserterNames.forEach(function (asserterName) {
-            if (excludeNames.indexOf(asserterName) !== -1) {
-              return;
-            }
-
-            var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
-            Object.defineProperty(chainableMethodWrapper, asserterName, pd);
-          });
-        }
-
-        transferFlags(this, chainableMethodWrapper);
-        return proxify(chainableMethodWrapper);
-      }
-    , configurable: true
-  });
-}

package/node_modules/chai/lib/chai/utils/addLengthGuard.js

@@ -1,60 +0,0 @@
-const fnLengthDesc = Object.getOwnPropertyDescriptor(function () {}, 'length');
-
-/*!
- * Chai - addLengthGuard utility
- * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-/**
- * ### .addLengthGuard(fn, assertionName, isChainable)
- *
- * Define `length` as a getter on the given uninvoked method assertion. The
- * getter acts as a guard against chaining `length` directly off of an uninvoked
- * method assertion, which is a problem because it references `function`'s
- * built-in `length` property instead of Chai's `length` assertion. When the
- * getter catches the user making this mistake, it throws an error with a
- * helpful message.
- *
- * There are two ways in which this mistake can be made. The first way is by
- * chaining the `length` assertion directly off of an uninvoked chainable
- * method. In this case, Chai suggests that the user use `lengthOf` instead. The
- * second way is by chaining the `length` assertion directly off of an uninvoked
- * non-chainable method. Non-chainable methods must be invoked prior to
- * chaining. In this case, Chai suggests that the user consult the docs for the
- * given assertion.
- *
- * If the `length` property of functions is unconfigurable, then return `fn`
- * without modification.
- *
- * Note that in ES6, the function's `length` property is configurable, so once
- * support for legacy environments is dropped, Chai's `length` property can
- * replace the built-in function's `length` property, and this length guard will
- * no longer be necessary. In the mean time, maintaining consistency across all
- * environments is the priority.
- *
- * @param {Function} fn
- * @param {string} assertionName
- * @param {boolean} isChainable
- * @returns {unknown}
- * @namespace Utils
- * @name addLengthGuard
- */
-export function addLengthGuard(fn, assertionName, isChainable) {
-  if (!fnLengthDesc.configurable) return fn;
-
-  Object.defineProperty(fn, 'length', {
-    get: function () {
-      if (isChainable) {
-        throw Error('Invalid Chai property: ' + assertionName + '.length. Due' +
-          ' to a compatibility issue, "length" cannot directly follow "' +
-          assertionName + '". Use "' + assertionName + '.lengthOf" instead.');
-      }
-
-      throw Error('Invalid Chai property: ' + assertionName + '.length. See' +
-        ' docs for proper usage of "' + assertionName + '".');
-    }
-  });
-
-  return fn;
-}

package/node_modules/chai/lib/chai/utils/addMethod.js

@@ -1,67 +0,0 @@
-/*!
- * Chai - addMethod utility
- * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {addLengthGuard} from './addLengthGuard.js';
-import {flag} from './flag.js';
-import {proxify} from './proxify.js';
-import {transferFlags} from './transferFlags.js';
-import {Assertion} from '../assertion.js';
-
-/**
- * ### .addMethod(ctx, name, method)
- *
- * Adds a method to the prototype of an object.
- *
- *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {
- *         var obj = utils.flag(this, 'object');
- *         new chai.Assertion(obj).to.be.equal(str);
- *     });
- *
- * Can also be accessed directly from `chai.Assertion`.
- *
- *     chai.Assertion.addMethod('foo', fn);
- *
- * Then can be used as any other assertion.
- *
- *     expect(fooStr).to.be.foo('bar');
- *
- * @param {object} ctx object to which the method is added
- * @param {string} name of method to add
- * @param {Function} method function to be used for name
- * @namespace Utils
- * @name addMethod
- * @public
- */
-export function addMethod(ctx, name, method) {
-  var methodWrapper = function () {
-    // Setting the `ssfi` flag to `methodWrapper` causes this function to be the
-    // starting point for removing implementation frames from the stack trace of
-    // a failed assertion.
-    //
-    // However, we only want to use this function as the starting point if the
-    // `lockSsfi` flag isn't set.
-    //
-    // If the `lockSsfi` flag is set, then either this assertion has been
-    // overwritten by another assertion, or this assertion is being invoked from
-    // inside of another assertion. In the first case, the `ssfi` flag has
-    // already been set by the overwriting assertion. In the second case, the
-    // `ssfi` flag has already been set by the outer assertion.
-    if (!flag(this, 'lockSsfi')) {
-      flag(this, 'ssfi', methodWrapper);
-    }
-
-    var result = method.apply(this, arguments);
-    if (result !== undefined)
-      return result;
-
-    var newAssertion = new Assertion();
-    transferFlags(this, newAssertion);
-    return newAssertion;
-  };
-
-  addLengthGuard(methodWrapper, name, false);
-  ctx[name] = proxify(methodWrapper, name);
-}

package/node_modules/chai/lib/chai/utils/addProperty.js

@@ -1,71 +0,0 @@
-/*!
- * Chai - addProperty utility
- * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {Assertion} from '../assertion.js';
-import {flag} from './flag.js';
-import {isProxyEnabled} from './isProxyEnabled.js';
-import {transferFlags} from './transferFlags.js';
-
-/**
- * ### .addProperty(ctx, name, getter)
- *
- * Adds a property to the prototype of an object.
- *
- *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {
- *         var obj = utils.flag(this, 'object');
- *         new chai.Assertion(obj).to.be.instanceof(Foo);
- *     });
- *
- * Can also be accessed directly from `chai.Assertion`.
- *
- *     chai.Assertion.addProperty('foo', fn);
- *
- * Then can be used as any other assertion.
- *
- *     expect(myFoo).to.be.foo;
- *
- * @param {object} ctx object to which the property is added
- * @param {string} name of property to add
- * @param {Function} getter function to be used for name
- * @namespace Utils
- * @name addProperty
- * @public
- */
-export function addProperty(ctx, name, getter) {
-  getter = getter === undefined ? function () {} : getter;
-
-  Object.defineProperty(ctx, name,
-    { get: function propertyGetter() {
-        // Setting the `ssfi` flag to `propertyGetter` causes this function to
-        // be the starting point for removing implementation frames from the
-        // stack trace of a failed assertion.
-        //
-        // However, we only want to use this function as the starting point if
-        // the `lockSsfi` flag isn't set and proxy protection is disabled.
-        //
-        // If the `lockSsfi` flag is set, then either this assertion has been
-        // overwritten by another assertion, or this assertion is being invoked
-        // from inside of another assertion. In the first case, the `ssfi` flag
-        // has already been set by the overwriting assertion. In the second
-        // case, the `ssfi` flag has already been set by the outer assertion.
-        //
-        // If proxy protection is enabled, then the `ssfi` flag has already been
-        // set by the proxy getter.
-        if (!isProxyEnabled() && !flag(this, 'lockSsfi')) {
-          flag(this, 'ssfi', propertyGetter);
-        }
-
-        var result = getter.call(this);
-        if (result !== undefined)
-          return result;
-
-        var newAssertion = new Assertion();
-        transferFlags(this, newAssertion);
-        return newAssertion;
-      }
-    , configurable: true
-  });
-}

package/node_modules/chai/lib/chai/utils/compareByInspect.js

@@ -1,26 +0,0 @@
-/*!
- * Chai - compareByInspect utility
- * Copyright(c) 2011-2016 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {inspect} from './inspect.js';
-
-/**
- * ### .compareByInspect(mixed, mixed)
- *
- * To be used as a compareFunction with Array.prototype.sort. Compares elements
- * using inspect instead of default behavior of using toString so that Symbols
- * and objects with irregular/missing toString can still be sorted without a
- * TypeError.
- *
- * @param {unknown} a first element to compare
- * @param {unknown} b second element to compare
- * @returns {number} -1 if 'a' should come before 'b'; otherwise 1
- * @name compareByInspect
- * @namespace Utils
- * @public
- */
-export function compareByInspect(a, b) {
-  return inspect(a) < inspect(b) ? -1 : 1;
-}

package/node_modules/chai/lib/chai/utils/expectTypes.js

@@ -1,50 +0,0 @@
-/*!
- * Chai - expectTypes utility
- * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
- * MIT Licensed
- */
-
-import {AssertionError} from 'assertion-error';
-import {flag} from './flag.js';
-import {type} from './type-detect.js';
-
-/**
- * ### .expectTypes(obj, types)
- *
- * Ensures that the object being tested against is of a valid type.
- *
- *     utils.expectTypes(this, ['array', 'object', 'string']);
- *
- * @param {unknown} obj constructed Assertion
- * @param {Array} types A list of allowed types for this assertion
- * @namespace Utils
- * @name expectTypes
- * @public
- */
-export function expectTypes(obj, types) {
-  var flagMsg = flag(obj, 'message');
-  var ssfi = flag(obj, 'ssfi');
-
-  flagMsg = flagMsg ? flagMsg + ': ' : '';
-
-  obj = flag(obj, 'object');
-  types = types.map(function (t) { return t.toLowerCase(); });
-  types.sort();
-
-  // Transforms ['lorem', 'ipsum'] into 'a lorem, or an ipsum'
-  var str = types.map(function (t, index) {
-    var art = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(t.charAt(0)) ? 'an' : 'a';
-    var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
-    return or + art + ' ' + t;
-  }).join(', ');
-
-  var objType = type(obj).toLowerCase();
-
-  if (!types.some(function (expected) { return objType === expected; })) {
-    throw new AssertionError(
-      flagMsg + 'object tested must be ' + str + ', but ' + objType + ' given',
-      undefined,
-      ssfi
-    );
-  }
-}