analytics/webcontent/bi/js/vida/barejs/node/bare.debug.js

/*!
 * @name @waca/barejs
 * @version 1.1.20181003
 * @license
 * Licenced Materials - Property of IBM
 * 
 * (C) Copyright IBM Corp. 2016, 2018
 * 
 * US Government Users Restricted Rights - Use, duplication or
 * disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 */
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(1);
	__webpack_require__(13);
	__webpack_require__(16);
	module.exports = __webpack_require__(18);


/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015, 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function(
	        Object,
	        Array,
	        String,
	        Error,
	        TypeError,
	        ObjectPolyfill,
	        Map,
	        Set,
	        Symbol,
	        WeakMap
	    )
	{
	"use strict";

	/*global console, setTimeout*/
	/*jshint latedef:false*/

	/**
	 * Note: decl is not a constructor; call its static members.
	 * @class module:barejs.decl
	 * @abstract
	 * @classdesc Module for declaring classes, interfaces, enums, and checking implementations.
	 * decl uses the inheritance natively supported by JavaScript, instead of trying to emulate
	 * multiple inheritance or providing "super" or "base" keyword emulation. This combined with the
	 * fact that decl doesn't generate a constructor function (the defining code has to supply it)
	 * leads to classes with no run-time overhead. It also means there is no "magic" performed.
	 * Implementors using decl's inheritance are responsible for calling the base class
	 * constructor and methods using the standard JavaScript call mechanism:
	 *
	 *      function A( _name )
	 *      {
	 *          this.name = _name;
	 *      }
	 *
	 *      decl.declareClass( A,
	 *      {
	 *          toString: function()
	 *          {
	 *              return this.name;
	 *          }
	 *      }
	 *
	 *      function B( _name, _age )
	 *      {
	 *          // Invoke base class constructor on this object
	 *          A.call( this, _name );
	 *          this.age = _age;
	 *      }
	 *
	 *      decl.declareClass( B, A,
	 *      {
	 *          toString: function()
	 *          {
	 *              // Invoke A::toString() and append our age to it.
	 *              return A.prototype.toString.call( this ) + "; age " + this.age;
	 *          }
	 *      } );
	 *
	 * In the debug version of barejs, decl adds a lot of metadata to provide a great debugging experience.
	 * When defined with named constructors, objects created with decl will be highly discoverable and debuggable in browsers like Chrome.
	 */

	// List of classes that are not allowed to be casted to.
	var uncastable_types = new Set();
	var uncastable_keys = new Map();

	// Grab slice from an array
	var slice = Array.prototype.slice;
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var canWriteFnName = !!( Object.defineProperties && Object.getOwnPropertyDescriptor );
	/*istanbul ignore else: NodeJS supports this*/
	if ( canWriteFnName )
	{
	    canWriteFnName = Object.getOwnPropertyDescriptor( Function.prototype, "name" );
	    canWriteFnName = !canWriteFnName || canWriteFnName.configurable;
	}

	var reSymbolProto = /^(?:@@([a-zA-Z0-9_\$]+)|\[\[([a-zA-Z0-9_\$]+)\]\])$/;
	var reStaticIgnore = /^(?:constructor|prototype|name|interfaces|superclass|\$private)$/;
	var metaData = new WeakMap();

	/**
	 * Convenience property to ease defining a read only property on an Interface.
	 * It as simply a shortcut for '{ allowGet: true, allowSet: false }':
	 *
	 *      decl.declareInterface( function MyInterface() {},
	 *      {
	 *          // The following two definitions have exactly the same effect:
	 *          myProperty: decl.readOnlyProperty,
	 *          myProperty: { allowGet: true, allowSet: false }
	 *      } );
	 *
	 * @member {object}
	 * @readonly
	 * @memberof module:barejs.decl
	 */
	var readOnlyProperty  = ObjectPolyfill.freeze( { allowGet: true, allowSet: false } );

	var native_ctors = [ Object, Array, Function, Boolean, Number, Math, Date, String, RegExp, Symbol,
	                    Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError ];

	// Detect a bunch more of optional native constructors, so our native_ctor array is complete
	//jshint -W117
	/*istanbul ignore else*/
	if ( typeof ArrayBuffer !== "undefined" )
	    native_ctors.push( ArrayBuffer );
	/*istanbul ignore else*/
	if ( typeof Float32Array !== "undefined" )
	    native_ctors.push( Float32Array );
	/*istanbul ignore else*/
	if ( typeof Float64Array !== "undefined" )
	    native_ctors.push( Float64Array );
	/*istanbul ignore else*/
	if ( typeof Promise !== "undefined" )
	    native_ctors.push( Promise );
	/*istanbul ignore else*/
	if ( typeof Proxy !== "undefined" )
	    native_ctors.push( Proxy );
	/*istanbul ignore else*/
	if ( typeof Uint8Array !== "undefined" )
	    native_ctors.push( Uint8Array );
	/*istanbul ignore else*/
	if ( typeof Uint8ClampedArray !== "undefined" )
	    native_ctors.push( Uint8ClampedArray );
	/*istanbul ignore else*/
	if ( typeof Uint16Array !== "undefined" )
	    native_ctors.push( Uint16Array );
	/*istanbul ignore else*/
	if ( typeof Uint32Array !== "undefined" )
	    native_ctors.push( Uint32Array );
	//jshint +W117


	/**
	 * Convenience property to ease defining a read/write property on an Interface.
	 * It as simply a shortcut for '{ allowGet: true, allowSet: true }':
	 *
	 *      decl.declareInterface( function MyInterface() {},
	 *      {
	 *          // The following two definitions have exactly the same effect:
	 *          myProperty: decl.readWriteProperty,
	 *          myProperty: { allowGet: true, allowSet: true }
	 *      } );
	 *
	 * @member {object}
	 * @readonly
	 * @memberof module:barejs.decl
	 */
	var readWriteProperty = ObjectPolyfill.freeze( { allowGet: true, allowSet: true } );

	/*
	 * Enable validating interfaces are implemented in debug mode
	 * Except for Rhino, since it can't handle it...
	 */
	/*istanbul ignore else: We always test in DEBUG*/
	if ( !(false) &&
	        // Detect Rhino so we can ignore it
	        !( typeof load === "function" && ( typeof Packages === "function" || typeof Packages === "object" ) )
	    )
	{
	    var validateQueue = [];

	    /**
	     * Validate a class implements all interface members.
	     * @param {function} _class The class to validate.
	     * @memberof module:barejs.decl~
	     * @private
	     */
	    var validateInterfacesImplemented = function( _class )
	    {
	        var errors = [];

	        if ( _class && _class.interfaces )
	        {
	            _class.interfaces.forEach( function( _interface, _idxInterface )
	            {
	                var lines = [];

	                for ( var members = InterfaceMetaData.get( _interface ).members, i = 0, len = members.length; i < len; ++i )
	                {
	                    var member = members[i];
	                    var error = null;

	                    switch ( member.type )
	                    {
	                        case "function":
	                            var def = member.interfaces[0].prototype[member.name];
	                            var impl = _class.prototype[member.name];

	                            if ( typeof impl !== "function" )
	                                error = "Missing implementation for {def}";
	                            else if ( ( impl.length !== def.length ) && ( impl.proxy !== true ) )
	                                error = "Signature mismatch, {def} defines " + def.length + " arguments but implementation has " + impl.length;
	                            break;

	                        case "property":
	                            if ( !( member.name in _class.prototype ) )
	                                error = "Missing prototype definition for {def}";
	                            break;
	                    }

	                    if ( error !== null )
	                        lines.push( error.replace( "{def}", String( member ) ) );
	                }

	                if ( lines.length > 0 )
	                {
	                    errors.push(
	                        "[" + describe( _interface ) + " @ index " + _idxInterface + "]\r\n\t\t" +
	                        lines.join( "\r\n\t\t" )
	                    );
	                }
	            }, this );
	        }

	        if ( errors.length > 0 )
	            throw new Error( describe( _class ) + " has the following errors:\r\n\t" + errors.join( "\r\n\t" ) );
	    };

	    /**
	     * Callback function to validate interfaces
	     * @memberof module:barejs.decl~
	     * @private
	     */
	    var handleValidateQueue = function()
	    {
	        // reset timeout id
	        delete validateQueue.timeout;

	        /*istanbul ignore if: sanity check, this function should not be called/queued with an empty queue*/
	        if ( validateQueue.length < 1 )
	            return;

	        // The code below will report errors by throwing an exception. Ensure the validateQueue is empty
	        var queue = validateQueue;
	        validateQueue = [];

	        queue.forEach( function( _class )
	        {
	            // For interfaces, just create the metadata; this will do basic validation
	            if ( isInterface( _class ) )
	                InterfaceMetaData.get( _class );
	            else
	                validateInterfacesImplemented( _class );
	        } );
	    };
	}

	/**
	 * Generic getter method
	 * @param {string} _name The name of the property.
	 * @returns The value of the property
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function _get( _name )
	{
	    /*jshint validthis:true*/
	    return this[_name];
	}

	/**
	 * Generic setter method.
	 * @param {string} _name The name of the property.
	 * @param _value The value to assign.
	 * @returns The new value of the property
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function _set( _name, _value )
	{
	    /*jshint validthis:true*/
	    return ( this[_name] = _value );
	}

	/**
	 * Used during object prototype expansion to resolve a getter definition
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function resolvePropertyAccessor( _target )
	{
	    // It is possible the target is also a property definition. Resolve it
	    if ( _target && ( typeof _target === "object" ) )
	    {
	        if ( hasOwnProperty.call( _target, "value" ) )
	            return _target.value;
	        else if ( hasOwnProperty.call( _target, "get" ) )
	            return _target.get;
	    }
	    return _target;
	}

	/**
	 * Iterator function that will modify the context to have a defineProperty
	 * definition instead of direct properties. If the value is already a property definition, it is left
	 * untouched. Once the object has been parsed, it can then be given to Object.create.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function toDefineProperty( _value, _name, _object, _lookup )
	{
	    var def;

	    if ( _value && ( typeof _value === "object" ) )
	    {
	        if ( hasOwnProperty.call( _value, "value" ) )
	        {
	            def = _value;
	        }
	        // Guard against map values as they have
	        else if ( hasOwnProperty.call( _value, "get" ) || hasOwnProperty.call( _value, "set" ) )
	        {
	            def = _value;
	            // If there is no property support, we silently ignore properties
	            /*istanbul ignore if: NodeJS supports properties*/
	            if ( !ObjectPolyfill.propertyGetSetSupport )
	                return null;

	            // If there is a getter or setter, see if we need to resolve it
	            if ( typeof def.get === "string" )
	            {
	                def.getterName = def.get;
	                def.get = resolvePropertyAccessor( _object[def.get] || ( _lookup && _lookup[def.get] ) );
	            }
	            if ( typeof def.set === "string" )
	            {
	                def.setterName = def.set;
	                def.set = resolvePropertyAccessor( _object[def.set] || ( _lookup && _lookup[def.set] ) );
	            }
	        }
	    }

	    if ( !def )
	    {
	        def =
	        {
	            // Make Symbols and string keys starting with "_" not enumerable by default
	            enumerable: ObjectPolyfill.shouldBeEnumerable( _name ),
	            writable: true,
	            value: _value
	        };
	    }

	    return def;
	}

	/**
	 * Same purpose as toDefineProperty, but specialised for interfaces, on which we expect only
	 * functions or objects that define get/set access. Performs validation no other properties are present.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function toDefinePropertyInterface( _value, _name )
	{
	    var ok = false;
	    var allowGet, allowSet;

	    switch ( _value && typeof _value )
	    {
	        case "function":
	            // Functions are always OK
	            ok = true;
	            break;

	        case "object":
	            // If the decl constants where used, there is no sense in validating them
	            ok = ( _value === readOnlyProperty ) || ( _value === readWriteProperty );

	            // If not, validate the object given to us
	            if ( !ok )
	            {
	                allowGet = ( "allowGet" in _value ) && _value.allowGet;
	                allowSet = ( "allowSet" in _value ) && _value.allowSet;
	                // allowGet, if defined, should be a boolean
	                if ( typeof allowGet !== "boolean" )
	                    throw new TypeError( "allowGet value is not a boolean" );
	                // allowSet, if defined, should be a boolean
	                if ( typeof allowSet !== "boolean" )
	                    throw new TypeError( "allowSet value is not a boolean" );

	                ok = allowGet || allowSet; // at least one needs to be true.
	            }
	            break;
	    }

	    if ( !ok )
	        throw new TypeError( "Values on an interface prototype must be either a function or an object containing allowGet or allowSet boolean properties." );

	    return { enumerable: true, value: _value };
	}

	/**
	 * Convenience method that will add a displayName to _function if not present, by concatenating
	 * _objectName and _propName with a '.', optionally appending _suffix after _propName.
	 * @param {function} _function The function to add the displayName to.
	 * @param {string} _objectName The name of the object, for example "MyClass.prototype"
	 * @param {string} _propName The name of the property (the function is added as), for example "myMethod"
	 * @param {string} [_suffix] Optional: part to append to the name, for example " [GET]" for a getter function
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function displayName( _function, _objectName, _propName, _suffix )
	{
	    if ( canWriteFnName && !hasOwnProperty.call( _function, "name" ) )
	        ObjectPolyfill.defineProperty( _function, "name", { configurable: true, value: _propName } );
	    if ( !( "displayName" in _function ) )
	        ObjectPolyfill.defineProperty( _function, "displayName", { configurable: true, value: _objectName + "." + _propName + ( _suffix || "" ) } );
	}

	/**
	 * Utility method that returns _def expanded to a defineProperties argument.
	 * Arguments that are a property definition are left alone, other are expanded to be a property definition
	 * @param {object} _def The object whose properties to expand.
	 * @param {function} _callback Function to use for the expand operation.
	 * @param {string} [_objName] Optional: the logical name of _def, e.g. "MyClass.prototype"
	 * @returns {object} _def made suitable for Object.defineProperties (or second argument of Object.create).
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function expandDefineProperties( _def, _lookup, _callback, _objName )
	{
	    if ( _def )
	    {
	        // Ensure object
	        _def = Object( _def );

	        for ( var names = Object.keys( _def ), i = 0, len = names.length, name, prop, sym; i < len; ++i )
	        {
	            name = names[i];
	            sym = reSymbolProto.exec( name );
	            if ( sym )
	            {
	                //jshint -W122
	                // The regexp matches one of two possible forms ("@@symbolName" or "[[symbolName]]"),
	                // which means the symbol name may be in either capture group
	                sym = Symbol[ sym[1] || sym[2] ];
	                if ( typeof sym !== "symbol" )
	                {
	                    delete _def[name];
	                    continue;
	                }
	                //jshint +W122
	            }
	            prop = _callback( _def[name], sym || name, _def, _lookup );

	            if ( sym )
	            {
	                delete _def[name];
	                _def[sym] = prop;
	            }
	            else if ( _def[name] !== prop )
	            {
	                // on rare occasions we may need to drop a property, e.g. when there is no getter/setter support.
	                if ( prop === null )
	                    delete _def[name];
	                else
	                    _def[name] = prop;
	            }

	            if ( prop && _objName )
	            {
	                if ( "value" in prop )
	                {
	                    if ( ObjectPolyfill.isCallable( prop.value ) )
	                        displayName( prop.value, _objName, name );
	                }
	                else
	                {
	                    if ( prop.get && !prop.getterName )
	                        displayName( prop.get, _objName, name, " [GET]" );
	                    if ( prop.set && !prop.setterName )
	                        displayName( prop.set, _objName, name, " [SET]" );
	                }
	            }
	        }
	    }

	    return _def;
	}

	/**
	 * Tells the proxy system casting to this type is not allowed. Should only be used for very low
	 * level classes, otherwise performance will be impacted.
	 * @param {function} _class The type to disallow casting to
	 * @returns {Symbol} Key to cast to this type. NEVER export this key in any way.
	 * @memberof module:barejs.decl
	 */
	function preventCast( _class ){
	    if ( typeof _class !== "function" )
	        throw new TypeError( "_class must be a function" );

	    if ( uncastable_types.has( _class ) )
	        throw new Error( "Already declared uncastable" );

	    // Register uncastable, generate key and store it at the correct index
	    // Symbol is meant to make a "private key", so it seems suitable enough to use as a key for preventCast.
	    var key = Symbol( _class.name );
	    uncastable_types.add( _class );
	    uncastable_keys.set( key, _class );
	    return key;
	}

	// Allow decl to cast back without knowing the right type
	// NOTE: This value should never be exported
	var ObjectKey = preventCast( Object );


	/**
	 * Method that sets up inheritance. Doesn't perform any validation, this should be done beforehand.
	 * @param {function} _class Class to set up the inheritance for
	 * @param {function} _base The class to derive from.
	 * @returns {function} Class, now deriving from _base
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function derive( _class, _base, _proto )
	{
	    // Apply prototype inheritance
	    _class.prototype = Object.create( _base.prototype, _proto || undefined );

	    // Reset the constructor (non enumerable, but writable, just like browsers set it).
	    ObjectPolyfill.defineProperty( _class.prototype, "constructor", { writable : true, value : _class } );

	    // Set superclass on constructor function
	    // Note: decl methods should not rely too much on superclass being set, it's for convenience only
	    return ObjectPolyfill.defineProperty( _class, "superclass", { value : _base } );
	}

	//
	// Helper classes for metadata
	//

	/**
	 * @classdesc Base class to gather information about a member of an interface.
	 * @class module:barejs.decl~InterfaceMember
	 * @param {function[]} _interfaces The interface(s) on which the method is defined.
	 * @param {string} _name The name of the method on the interface.
	 * @private
	 */
	function InterfaceMember( _interfaces, _name )
	{
	    this.interfaces = _interfaces;
	    this.name = _name;
	}

	derive( InterfaceMember, Object,
	/** @lends module:barejs.decl~InterfaceMember */
	{
	    type: { value: "member" },

	    /**
	     * Provides a string representation of the member, for example "member myFunction on interface IMyInterface".
	     * @returns {string} The string representation of the member
	     */
	    toString: { value: function toString()
	    {
	        return this.type + " \"" + String( this.name ) + "\" defined on " + this.interfaces.map( describe ).join( ", " );
	    } }
	} );

	/**
	 * @classdesc Stores information about a method on an interface.
	 * @class module:barejs.decl~InterfaceMethod
	 * @param {function} _interface The interface on which the method is defined.
	 * @param {string} _name The name of the method on the interface.
	 * @private
	 */
	function InterfaceMethod( _interface, _name )
	{
	    InterfaceMember.call( this, [_interface], _name );
	}

	derive( InterfaceMethod, InterfaceMember,
	/** @lends module:barejs.decl~InterfaceMethod */
	{
	    type: { value: "function" }
	} );

	/**
	 * @classdesc Stores information about a property on an interface
	 * @class module:barejs.decl~InterfaceProperty
	 * @param {function[]} _interfaces The interfaces on which the property is defined.
	 * @param {string} _name The name of the property on the interface.
	 * @param {boolean} _allowGet Whether getting this property is allowed.
	 * @param {boolean} _allowSet Whether setting this property is allowed.
	 * @private
	 */
	function InterfaceProperty( _interfaces, _name, _allowGet, _allowSet )
	{
	    InterfaceMember.call( this, _interfaces, _name );

	    this.allowGet = _allowGet;
	    this.allowSet = _allowSet;
	}

	derive( InterfaceProperty, InterfaceMember,
	/** @lends module:barejs.decl~InterfaceProperty */
	{
	    type: { value: "property" },

	    /**
	     * Merge two definitions into a new InterfaceProperty. Used to resolve collisions between interfaces
	     * @param {module:barejs.decl~InterfaceProperty} _otherProperty The property to merge with.
	     * @returns {module:barejs.decl~InterfaceProperty} The merged InterfaceProperty. Might be the original, if the interfaces was already known.
	     */
	    merge: { value: function( _otherProperty )
	    {
	        if ( _otherProperty === this ) // sanity
	            return this;

	        // merge interfaces arrays
	        for ( var interfaces = this.interfaces.slice( 0 ), i = 0, len = _otherProperty.interfaces.length, iface; i < len; ++i )
	        {
	            if ( interfaces.indexOf( iface = _otherProperty.interfaces[i] ) )
	                interfaces.push( iface );
	        }

	        return new InterfaceProperty( interfaces, this.name, this.allowGet || _otherProperty.allowGet, this.allowSet || _otherProperty.allowSet );
	    } }
	} );

	/**
	 * Stores metadata about members of this interface, members of base interfaces and the combined list.
	 * This allows methods like hasInterface and proxy to quickly iterate over the list of members.
	 * @class module:barejs.decl~InterfaceMetaData
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function InterfaceMetaData()
	{
	    this.directMembers = [];
	    this.inheritedMembers = [];
	    this.members = null;
	}

	/**
	 * merge directMembers and inheritedMembers into one
	 */
	InterfaceMetaData.prototype.merge = function()
	{
	    var mergeMap;
	    var i, len, member;

	    if ( this.members )
	        return;

	    if ( this.inheritedMembers.length < 1 )
	    {
	        this.members = this.directMembers;
	    }
	    else if ( this.directMembers.length < 1 )
	    {
	        this.members = this.inheritedMembers;
	    }
	    else
	    {
	        mergeMap = Object.create( null );

	        // Start by copying the directMembers
	        this.members = this.directMembers.slice( 0 );
	        // Then iterate them to initialize the merge map
	        for ( i = 0, len = this.members.length; i < len; ++i )
	            mergeMap[this.members[i].name] = true;

	        // Next, iterate inherited members
	        for ( i = 0, len = this.inheritedMembers.length; i < len; ++i )
	        {
	            // No point in updating the merge map, this is the last iteration of the merge
	            // Only add the member if it wasn't redefined
	            if ( mergeMap[(member = this.inheritedMembers[i]).name] !== true )
	                this.members.push( member );
	        }

	        this.members.sort( function( _a, _b )
	        {
	            if ( _a.name === _b.name )
	                return 0;
	            var ta = typeof _a.name;
	            return ( ta ===  typeof _b.name ) && ( ta === "string" ) && ( _a.name > _b.name ) ? 1 : -1;
	        } );
	    }
	};

	/**
	 * Build meta data for an interface, like the list of all methods required by the interface.
	 */
	InterfaceMetaData.get = function( _interface )
	{
	    if ( !isInterface( _interface ) )
	        throw new TypeError( "_interface is not an Interface" );

	    var meta = metaData.get( _interface );
	    if ( !meta )
	    {
	        metaData.set( _interface, meta = new InterfaceMetaData() );

	        var mergeMap = Object.create( null );

	        // Merge inherited members
	        if ( _interface.interfaces )
	        {
	            _interface.interfaces.forEach( function( _extendedInterface )
	            {
	                var members = InterfaceMetaData.get( _extendedInterface ).members, member, existing;
	                for ( var i = 0, len = members.length; i < len; ++i )
	                {
	                    member = members[i];

	                    if ( ( existing = mergeMap[member.name] ) && ( existing !== member ) )
	                    {
	                        // See if we need to do property merge magic
	                        if ( ( existing.type === "property" ) && ( member.type === "property" ) )
	                        {
	                            meta.inheritedMembers[meta.inheritedMembers.indexOf( existing )] =
	                                mergeMap[member.name] = existing.merge( member );
	                        }
	                        else
	                        {
	                            // Report the conflict
	                            throw new Error( describe( _interface ) + " has a conflict in extended interfaces: The " + existing + " conflicts with " + member + "." );
	                        }
	                    }
	                    else
	                    {
	                        mergeMap[member.name] = member;
	                        meta.inheritedMembers.push( member );
	                    }
	                }
	            } );
	        }

	        // Add direct members (freeze prototype too, to protect it from modification after metadata is built).
	        for ( var names = Object.keys( ObjectPolyfill.freeze( _interface.prototype ) ).concat( ObjectPolyfill.getOwnPropertySymbols( _interface.prototype ) ), i = 0, len = names.length; i < len; ++i )
	        {
	            var name = names[i], target = _interface.prototype[name];

	            // Protect proxy features from colliding with the interface.
	            if ( ( name === "as" ) || ( name === "is" ) )
	                throw new Error( "The " + ( new InterfaceMember( [_interface], name ) ) + " uses the reserved name \"" + name + "\", which is not allowed." );
	            // Explicitly ignore the constructor property for Rhino
	            if ( name === "constructor" )
	                continue;

	            var member = null, existing = mergeMap[name];

	            // First, just create the metadata (not adding it)
	            switch ( target && typeof target )
	            {
	                case "function":
	                    member = new InterfaceMethod( _interface, name );
	                    break;

	                case "object":
	                    if ( ( "allowGet" in target ) || ( "allowSet" in target  ) )
	                    {
	                        member = new InterfaceProperty( [_interface], name, target.allowGet === true, target.allowSet === true );
	                        if ( !( member.allowGet || member.allowSet ) )
	                            throw new Error( "The " + member + " is invalid: it doesn't allow get or set." );
	                    }
	                    break;
	            }

	            if ( !member )
	            {
	                throw new Error(
	                    "The " + ( new InterfaceMember( [_interface], name ) ) + " is invalid: expected a function, " +
	                    "or an object with allowGet or allowSet property, but got " + ( typeof target ) + target + " instead."
	                );
	            }

	            // Override or report conflict
	            if ( existing )
	            {
	                // Interfaces are allowed to redefine properties with more access (i.e. readWrite over read).
	                // They are not allowed to revoke access or redefine a property with similar access
	                if ( ( member.type === "property" ) && ( existing.type === "property" ) )
	                {
	                    // Test if the interface is removing access
	                    if ( existing.allowGet && !member.allowGet )
	                        throw new Error( "The " + member + " has a conflict with " + existing + ": it is removing get access." );
	                    if ( existing.allowSet && !member.allowSet )
	                        throw new Error( "The " + member + " has a conflict with " + existing + ": it is removing set access." );
	                    if ( ( existing.allowGet === member.allowGet ) && ( existing.allowSet === member.allowSet ) )
	                        throw new Error( "The " + member + " is redefining " + existing + " with equal get/set access (so it is obsolete)." );
	                }
	                else
	                {
	                    throw new Error( "The " + member + " conflicts with " + existing + "." );
	                }
	            }

	            meta.directMembers.push( member );
	        }

	        meta.merge();
	    }

	    return meta;
	};

	/**
	 * Stores metadata about names and values on an enum.
	 * This allows for quick reverse lookup
	 * @class module:barejs.decl~EnumMetaData
	 * @private
	 */
	function EnumMetaData( _enum )
	{
	    this.names = ObjectPolyfill.freeze( Object.keys( _enum ) );
	    // Use _get to resolve the enum property value
	    this.values = ObjectPolyfill.freeze( this.names.map( _get, _enum ) );
	}

	/**
	 * Perform a case insensitive name lookup for an enum
	 * @param {module:barejs.decl~Enum} _enum The enum to look up the name for
	 * @param {string} _name The name to match
	 * @returns {string} the found name, or null if not found.
	 */
	EnumMetaData.prototype.ciName = function( _name )
	{
	    var nameLower = String( _name ).toLowerCase();

	    for ( var i = this.names.length - 1; i >= 0; --i )
	    {
	        if ( nameLower === this.names[i].toLowerCase() )
	            return this.names[i];
	    }
	    return null;
	};

	/**
	 * Retrieve metadata for an enum
	 */
	EnumMetaData.get = function( _enum )
	{
	    var meta = metaData.get( _enum.constructor );
	    if ( !meta )
	        metaData.set( _enum.constructor, meta = new EnumMetaData( _enum ) );

	    return meta;
	};

	//
	// Helper classes
	//

	function NullObject() {}

	NullObject.prototype = null;

	/**
	 * Internal class for decl, serving as a base class for {@link module:barejs.decl~Interface Interface} and {@link module:barejs.decl~Enum Enum}.
	 * Does not have Object.prototype in its prototype chain, so objects deriving from SpecialType are not instanceof Object.
	 * @class module:barejs.decl~SpecialType
	 */
	function SpecialType() {}

	derive( SpecialType, NullObject,
	/** @lends module:barejs.decl~SpecialType# */
	{
	    // JSHint complains hasOwnProperty is a really bad name, but we are simply "restoring" it on a special type.
	    // jshint -W001
	    /**
	     * A SpecialType is not instanceof Object, but does have the Object.prototype.hasOwnProperty method.
	     * @function
	     * @param {string} _name The name of the property to check
	     * @returns {boolean} True if the object has a direct property with _name, false otherwise.
	     */
	    hasOwnProperty: { value: hasOwnProperty }
	    // jshint +W001
	} );


	/**
	 * Base class for interfaces
	 * @class module:barejs.decl~Interface
	 * @extends module:barejs.decl~SpecialType
	 */
	function Interface() {}

	// Make Interface a "special type" (new Interface() instanceof Object === false)
	derive( Interface, SpecialType,
	/** @lends module:barejs.decl~Interface# */
	{
	    /**
	     * toString for Interface.
	     * @function
	     * @returns {string} The string [interface InterfaceName], where InterfaceName is
	     * the name of the interface constructor function, or "Interface" for anonymous interfaces.
	     */
	    toString: { value: function toString()
	    {
	        return "[interface " + ( this.constructor.name || "Interface" ) + "]";
	    } }
	} );

	/**
	 * Base class for Enum types declared with {@link module:barejs.decl#declareEnum decl.declareEnum}
	 * @class module:barejs.decl~Enum
	 * @extends module:barejs.decl~SpecialType
	 */
	function Enum() {}

	// Make Enum a "special type" (new Enum() instanceof Object === false)
	derive( Enum, SpecialType,
	/** @lends module:barejs.decl~Enum# */
	{
	    // Allow subclasses to redefine these methods (so make them writable)

	    /**
	     * Enum method: get the name of the specified value. If multiple names lead to the same value, the
	     * first found name is returned
	     * @function
	     * @param {string} _value The value for which to get the name
	     * @returns The name of the value, or null if not found
	     */
	    nameOf:
	    {
	        writable: true,
	        value: function nameOf( _value )
	        {
	            var meta = EnumMetaData.get( this );

	            return meta.names[meta.values.indexOf( _value )] || null;
	        }
	    },

	    /**
	     * Enum method: get the value of the specified name
	     * @function
	     * @param {string} _name The name of the value to get
	     * @param {boolean} [_caseInsensitive=false] Optional, set to true to perform a case insensitive search
	     * @returns {object} The enum value, or null if it wasn't found.
	     */
	    valueOf:
	    {
	        writable: true,
	        value: function valueOf( _name, _caseInsensitive )
	        {
	            // Case sensitive or insensitive, see if the name is defined.
	            if ( this.hasOwnProperty( _name ) )
	                return this[_name];
	            // If we're not case insensitive, we're not going to find the value
	            if ( _caseInsensitive !== true )
	                return null;

	            // Do a case insensitive lookup
	            _name = EnumMetaData.get( this ).ciName( _name );
	            // ciName will return null if the name didn't match any entry
	            return _name && this[_name];
	        }
	    },

	    /**
	     * Enum method: check if the enum has the specified name
	     * @function
	     * @param {string} _name The name to check
	     * @param {boolean} [_caseInsensitive=false] Optional, set to true to perform a case insensitive search
	     * @returns {boolean} True if the enum has the name, false otherwise.
	     */
	    hasName:
	    {
	        writable: true,
	        value: function hasName( _name, _caseInsensitive )
	        {
	            // Always check hasOwnProperty first, to avoid the array lookup of case insensitive.
	            return this.hasOwnProperty( _name ) || ( ( _caseInsensitive === true ) && ( EnumMetaData.get( this ).ciName( _name ) !== null ) );
	        }
	    },

	    /**
	     * Check if the enum has the specified value
	     * @function
	     * @param {object} _value The enum value to check for
	     * @returns {boolean} True if the enum has the value, false otherwise.
	     */
	    hasValue:
	    {
	        writable: true,
	        value: function hasValue( _value )
	        {
	            return EnumMetaData.get( this ).values.indexOf( _value ) >= 0;
	        }
	    },

	    /**
	     * Utility method to parse an enum value, for example from input parsed from JSON.
	     * Takes the following steps:
	     *
	     *      1. if _value is an actual enum value, return _value.
	     *      2. if _value is a name of enum, return the value of that name
	     *      3. if _throw is true, throw a RangeError
	     *      4. return null
	     *
	     * @function
	     * @param _value The value to parse
	     * @param {boolean} _caseInsensitive Whether name matching should be case insensitive.
	     *                  Defaults to false, specify true for case insensitive.
	     * @param {boolean} [_throw=false] Optional: set to true to perform strict validation.
	     * @returns The parsed value, or null if the value didn't parse.
	     */
	    parse:
	    {
	        writable: true,
	        value: function parse( _value, _caseInsensitive, _throw )
	        {
	            var enumMeta = EnumMetaData.get( this );

	            if ( enumMeta.values.indexOf( _value ) >= 0 )
	                return _value;
	            // After this point, _value is considered to be a potential name
	            var name = _value;
	            // Perform case insensitive lookup if needed
	            if ( !this.hasOwnProperty( name ) && ( _caseInsensitive === true ) )
	                name = EnumMetaData.get( this ).ciName( name );
	            if ( name && this.hasOwnProperty( name ) )
	                return this[name];
	            if ( _throw === true )
	                throw new RangeError( "Could not parse enum value " + _value );
	            return null;
	        }
	    },

	    /**
	     * Get the names of an enum
	     * @function
	     * @returns {Array} The names of an enum
	     */
	    names:
	    {
	        writable: true,
	        value: function names()
	        {
	            return EnumMetaData.get( this ).names;
	        }
	    },

	    /**
	     * Get the values of an enum
	     * @function
	     * @returns {Array} The values of an enum
	     */
	    values:
	    {
	        writable: true,
	        value: function values()
	        {
	            return EnumMetaData.get( this ).values;
	        }
	    },

	    /**
	     * Iterate over all enum name/value pairs. Signature attempts to match Array.prototype.forEach.
	     * @function
	     * @param {function} _callback The callback, called with _value, _name, _enum
	     * @param {object} [_thisArg] Optional: the scope to call the callback in.
	     */
	    forEach:
	    {
	        writable: true,
	        value: function forEach( _callback/*, _thisArg*/ )
	        {
	            for ( var meta = EnumMetaData.get( this ), idx = 0, len = meta.names.length, thisArg = ( arguments[1] || null ) && Object( arguments[1] ); idx < len; ++idx )
	                _callback.call( thisArg, meta.values[idx], meta.names[idx], this );
	        }
	    },

	    /**
	     * toString for Enum.
	     * @function
	     * @returns {string} The string [enum EnumName], where EnumName is
	     * the name of the enum constructor function, or "Enum" for anonymous enumerations.
	     */
	    toString: { value: function toString()
	    {
	        return "[enum " + ( this.constructor.name || "Enum" ) + "]";
	    } }
	} );

	// These methods are added to a declareClass prototype
	var classProtoExtension =
	{
	    /**
	     * To be executed in the context of an object.
	     * Allow "casting" between interface proxies and the original object.
	     * @param {function} _class The type (constructor function) to cast to.
	     * @param {boolean} [_strict=false] Optional: set to true to avoid a duck-type check, and only check `decl`
	     * metadata for interfaces implemented.
	     * @returns {object} A proxy, the original object, or null if the "cast" could not be performed.
	     */
	    as: { value : function as( _class, _strict )
	    {
	        // jshint validthis:true
	        // Give ObjectKey special treatment, making it a "master key", allowing to cast back objects
	        // that are not even instanceof Object.
	        if ( _class === ObjectKey )
	            return this;

	        // _class is supposed to be either a constructor function or a proxy key
	        if ( typeof _class !== "function" )
	        {
	            // Allow casting back by key (Symbol, handed out by preventCast).
	            var type = uncastable_keys.get( _class );
	            if ( type )
	                return this instanceof type ? this : null;

	            throw new TypeError( "as requires _class to be a (constructor) function" );
	        }
	        else if ( uncastable_types.has( _class ) )
	        {
	            throw new Error( "as does not allow casting to this type, specify a more specific type" );
	        }

	        // If we get here, _class is a function
	        if ( isInterface( _class ) && hasInterface( this, _class, _strict ) )
	            return proxy( this, _class );
	        else if ( this instanceof _class )
	            return this;

	        // Type change failed
	        return null;
	    } },

	    /**
	     * To be executed in the context of an object.
	     * Allow checking if an object adheres to a specific type, or equals an instance.
	     * @param {function} _other (Type|Interface) to test for, OR {object} (Instance) to check equality against
	     * @param {boolean} [_strict=false] Optional: if _other is an Interface, set to true to avoid a duck-type
	     *                          check, and only check `decl` metadata for interfaces implemented.
	     *                          If `_other` is not an Interface, this param is ignored.
	     * @returns {boolean} True if this object adheres to the type, or equals the _other instance. False otherwise.
	     */
	    is: { value: function is( _other, _strict )
	    {
	        // jshint validthis:true
	        if ( typeof _other === "function" )
	            return ( this instanceof _other ) || ( ( isInterface( _other ) && hasInterface( this, _other, _strict ) ) );
	        else if ( isProxy( _other ) )
	            return this === _other.as( ObjectKey );
	        else
	            return this === _other;
	    } }
	};


	//
	// Helper methods
	//

	/**
	 * Attempts to discover an object's base class.
	 * @param {function} _class Class constructor function
	 * @returns {function} The bas constructor, defaults to Object if the base cannot be determined.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function getBase( _class )
	{
	    var proto = null;

	    if ( typeof _class === "function" )
	    {
	        proto = ObjectPolyfill.getPrototypeOf( _class.prototype );
	        proto = proto && proto.constructor ? proto.constructor : Object;
	    }
	    return proto;
	}


	/**
	 * Get the type of _target.
	 * This is typeof enhanced.
	 * @param _target The thing to get the type of.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function type( _target )
	{
	    var t = _target === null ? "null" : typeof _target;

	    if ( t === "function" )
	    {
	        if ( _target.prototype instanceof Interface )
	            t = "interface";
	        else if ( _target.prototype instanceof Enum )
	            t = "enum";
	        else if ( !( "prototype" in _target ) )
	            t = "native function";
	        else if ( "superclass" in _target )
	            t = "class";
	    }
	    else if ( t === "object" )
	    {
	        if ( Array.isArray( _target ) )
	            return "array";
	        else if ( _target instanceof Enum )
	            t = "enum";
	        else if ( _target instanceof Interface )
	            t = "proxy";
	    }

	    return t;
	}

	/**
	 * Helper method that tries to get the name of a class.
	 * @param {function|Object} _target The object to get the name of
	 * @returns {string} The name of target, or null
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function name( _target )
	{
	    if ( !_target )
	        return null;
	    else if ( typeof _target === "function" )
	        return _target.name || null;
	    else if ( _target.constructor )
	        return _target.constructor.name || null;
	    return null;
	}

	/**
	 * Helper method that tries to build a description of an object. It gets the right type description
	 * using type, and tries to append the name to it. The name is only available in environments that
	 * support the name property on functions, and of course the function must be named.
	 * Example: describe( SampleClass );
	 * If SampleClass is a named function this might return "class SampleClass".
	 * Otherwise, it will return "class (Anonymous)".
	 * @param {function} _fn The function to describe.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function describe( _target )
	{
	    var n = name( _target );

	    return n ? type( _target ) + " " + n : type( _target );
	}

	/**
	 * Check if the prototype object is clean (has no properties defined).
	 * @param {function} _class The constructor function whose prototype object to check.
	 * @param {string} [_requester] Optional: name of the function requesting the check
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function checkCleanPrototype( _class, _requester )
	{
	    var props = Object.keys( _class.prototype ),
	        idx = props.indexOf( "constructor" );

	    if ( idx >= 0 )
	        props.splice( idx, 1 );

	    if ( props.length > 0 )
	    {
	        throw new Error(
	            ( _requester ? _requester + ": " : "" ) + describe( _class ) + " already has properties defined on the prototype: " +
	            props.join( ", " )
	        );
	    }
	}

	/**
	 * Port "static" functions over from the base class.
	 * @param {function} _class The constructor function to update with base class static functions.
	 * @param {function} _base The base constructor to copy static functions of.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function applyStatic( _class, _base, _stat )
	{
	    if ( _base && ( native_ctors.indexOf( _base ) < 0 ) )
	    {
	        var descriptors = ObjectPolyfill.getOwnPropertyDescriptors( _base );
	        var staticInherited;
	        var keys = Object.keys( descriptors );
	        for ( var i = 0, len = keys.length; i < len; ++i )
	        {
	            var key = keys[i];

	            // Ignore keys that match reStaticIgnore,
	            if ( ( typeof key !== "string" || !reStaticIgnore.test( key ) ) &&
	                // or keys that are already on _class or _stat,
	                ( !hasOwnProperty.call( _class, key ) && !( _stat && hasOwnProperty.call( _stat, key ) ) ) &&
	                // or keys that are explicitly ignored using a $private function
	                !( _base.$private && _base.$private( key ) ) )
	            {
	                var def = descriptors[key];
	                if ( "value" in def && typeof def.value !== "function" && def.writable && ObjectPolyfill.propertyGetSetSupport )
	                {
	                    // Upgrade def to a get/set proxy
	                    def =
	                    {
	                        configurable: def.configurable,
	                        enumerable: def.enumerable,
	                        "get": _get.bind( _base, key ),
	                        "set": _set.bind( _base, key )
	                    };
	                }
	                // Make sure the definition is always configurable, as we're "inheriting"
	                def.configurable = true;
	                if ( !staticInherited )
	                    staticInherited = {};
	                staticInherited[key] = def;
	            }
	        }

	        if ( staticInherited )
	            defineObject( _class, staticInherited );
	    }

	    if ( _stat )
	        defineObject( _class, _stat );
	}

	/**
	 * Helper function that sets the interfaces for a class and validates they are actually interfaces.
	 * This method does not perform any validation on _class or its state.
	 * @param {function} _class The class constructor
	 * @param {Array} _interfaces The list of interfaces.
	 * @param {Array} _baseInterfaces The list of interfaces on the base class.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function setInterfaces( _class, _interfaces, _baseInterfaces )
	{
	    var interfaces = ( _baseInterfaces && _baseInterfaces.slice( 0 ) ) || [];

	    if ( _interfaces && _interfaces.length )
	    {
	        // Validate the interfaces specified are indeed interfaces.
	        for ( var idx = 0, len = _interfaces.length; idx < len; ++idx )
	        {
	            // An interface should derive DIRECTLY from Interface.
	            if ( getBase( _interfaces[idx] ) !== Interface )
	                throw new Error( "Interface " + idx + " is not a valid interface." );

	            if ( interfaces.indexOf( _interfaces[idx] ) < 0 )
	                interfaces.push( _interfaces[idx] );
	            else if ( !(false) && ( typeof console !== "undefined" ) )
	                console.info( describe( _class ) + " declares to implement " + describe( _interfaces[idx] ) + " also implemented by a base class." );
	        }
	    }

	    // Freeze the interfaces array for security
	    ObjectPolyfill.defineProperty( _class, "interfaces", { value : ObjectPolyfill.freeze( interfaces ) } );
	}

	/**
	 * See if _interface matches _searchInterface. This includes looking at extended interfaces.
	 * @param {function} _interface The interface to check
	 * @param {function} _searchInterface The interface to look for in _interface's tree.
	 * @returns {boolean} True if the interface matches, false otherwise
	 */
	function matchInterface( _interface, _searchInterface )
	{
	    if ( _interface === _searchInterface )
	        return true;

	    if ( _interface.interfaces )
	    {
	        for ( var idx = 0, len = _interface.interfaces.length; idx < len; ++idx )
	        {
	            if ( matchInterface( _interface.interfaces[idx], _searchInterface ) )
	                return true;
	        }
	    }

	    return false;
	}

	/**
	 * Wrapper for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is Object.is} that will "unproxy" values.
	 *
	 *      // This returns false, Object.is sees two different objects:
	 *      Object.is( instance, instance.as( MyInterface );
	 *
	 *      // This returns true, decl will unproxy proxies.
	 *      decl.is( instance, instance.as( MyInterface ) );
	 *
	 * @param _a Any value to check for equality
	 * @param _b Any value to check for equality
	 * @returns {boolean} True if the values are considered equal, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function is( _a, _b )
	{
	    return Object.is(
	        isProxy( _a ) ? _a.as( ObjectKey ) : _a,
	        isProxy( _b ) ? _b.as( ObjectKey ) : _b
	    );
	}

	/**
	 * Check if the _target is an interface.
	 * Only works with class constructors, since there should be no instance of an interface.
	 * @param {function} _target The class constructor to test if it is an interface.
	 * @returns {boolean} True if _target is an interface, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function isInterface( _target )
	{
	    return ( typeof _target === "function" ) && ( _target.prototype instanceof Interface );
	}

	/**
	 * Check if the _target is an enum.
	 * Only works with instances, since enums should not expose their class constructor directly.
	 * @param {object} _target The instance to test if it is an enum.
	 * @returns {boolean} True if _target is an enum, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function isEnum( _target )
	{
	    // Enums should always be an instance
	    return _target instanceof Enum;
	}

	/**
	 * Check if the target is a proxy object.
	 * @param {object} _target The object to check.
	 * @returns {boolean} True if _target is a proxy object, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function isProxy( _target )
	{
	    // _target must be an object, instanceof Interface, having an "as" method directly on the object (the "is" method is not tested)
	    return ( _target instanceof Interface ) && _target.hasOwnProperty( "as" );
	}

	/**
	 * Checks if _class has _base as a superclass. Also true if _class === _base.
	 * Do not use this method to check if an Object is of a specific type, use the instanceof operator
	 * for that instead.
	 * @param {function} _class The function to check.
	 * @param {function} _base The base class to check for.
	 * @returns {boolean} True if the class has the base class, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function hasBase( _class, _base )
	{
	    if ( typeof _class !== "function" )
	        throw new TypeError( "_class is not a (constructor) function" );
	    if ( typeof _base !== "function" )
	        throw new TypeError( "_base is not a (constructor) function" );

	    return ( _class === _base ) || ( _class.prototype instanceof _base );
	}

	/**
	 * Create and return a proxy object for the target
	 * @param {object} _target The object to proxy
	 * @param {function} _interface The interface defining the members to proxy.
	 * @returns {object} The proxy object (instanceof _interface).
	 * @memberof module:barejs.decl
	 */
	function proxy( _target, _interface )
	{
	    if ( !isInterface( _interface ) )
	        throw new TypeError( describe( _interface ) + " is not a valid Interface" );
	    if ( !_target )
	        throw new Error( "Cannot proxy " + describe( _target ) + " as " + describe( _interface ) );
	    // Don't proxy a proxy, instead attempt to proxy on the source object
	    if ( isProxy( _target ) )
	        return proxy( _target.as( ObjectKey ), _interface );

	    // Create the proxy object
	    var props =
	    {
	        // Adding the constructor shows proxy objects named as the interface in the debugger
	        // (provided the interface function is named)
	        constructor: { value : _interface },
	        // Add the as and is methods to the proxy, read-only and not enumerated
	        as: { value : classProtoExtension.as.value.bind( _target ) },
	        is: { value : classProtoExtension.is.value.bind( _target ) }
	    };

	    for ( var members = InterfaceMetaData.get( _interface ).members, idx = 0, len = members.length, member, prop; idx < len; ++idx )
	    {
	        switch ( ( member = members[idx] ).type )
	        {
	            case "function":
	                prop = _target[member.name];
	                if ( typeof prop !== "function" )
	                    throw new Error( "as( " + describe( _interface ) + " ) expected " + member + " to be on " + describe( _target.constructor ) + ", but it is missing." );

	                // Make the function proxies read-only, enumerable
	                props[member.name] = { value : prop.bind( _target ), enumerable : true };
	                break;

	            case "property":
	                if ( !( member.name in _target ) )
	                    throw new Error( "as( " + describe( _interface ) + " ) expected " + member + " to be on " + describe( _target.constructor ) + ", but it is missing." );

	                if ( ObjectPolyfill.propertyGetSetSupport )
	                {
	                    prop = { enumerable: true };
	                    if ( member.allowGet )
	                        prop.get = _get.bind( _target, member.name );
	                    if ( member.allowSet )
	                        prop.set = _set.bind( _target, member.name );
	                    // No point in checking for property support: we already checked that in the if above
	                    props[member.name] = prop;
	                }
	                else if ( typeof console !== undefined )
	                {
	                    console.warn( "interface proxy skipping " + member + ", since the environment doesn't support getters and setters." );
	                }
	                break;
	        }
	    }

	    // Attempt to seal the proxy; we don't need to freeze since no properties are configurable
	    return ObjectPolyfill.seal( Object.create( _interface.prototype, props ) );
	}

	/**
	 * Duck-type check for compliance with an interface
	 * @param {object} _target The object to validate
	 * @param {function} _interface The interface to check for
	 * @returns {boolean} True if the object seems to implement all members
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function duckHasInterface( _target, _interface )
	{
	    var valid = !!_target;
	    if ( valid )
	    {
	        // Ensure object
	        _target = Object( _target );

	        for ( var m = InterfaceMetaData.get( _interface ).members, i = m.length - 1; valid && i >= 0; --i )
	        {
	            switch( m[i].type )
	            {
	                case "function":
	                    valid = typeof _target[m[i].name] === "function";
	                    break;

	                case "property":
	                    valid = m[i].name in _target;
	                    break;
	            }
	        }
	    }

	    return valid;
	}

	/**
	 * Checks if _target (or a base class) implements the specified Interface.
	 * Works on both instances and the class constructor.
	 * @param {object|Function} _target The object or class constructor to check.
	 * @param {function} _interface The interface to check for. If interface is not a valid interface,
	 * this method always returns false.
	 * @param {boolean} [_strict=false] Optional: set to true to avoid a duck-type check, and only check decl
	 *                          metadata for interfaces implemented.
	 * @returns {boolean} True if _target (or a base class) implements the interface, false otherwise.
	 * @memberof module:barejs.decl
	 */
	function hasInterface( _target, _interface, _strict )
	{
	    if ( !isInterface( _interface ) )
	        throw new TypeError( "hasInterface: _interface must be an interface defined with decl.declareInterface, but is " + describe( _interface ) );
	    if ( !_target )
	        return false;
	    // Detect proxies
	    if ( isProxy( _target ) )
	        return hasInterface( _target.as( ObjectKey ), _interface, _strict );

	    var isFn = typeof _target === "function";

	    // Walk up the inheritance tree
	    for ( var base = isFn ? _target : _target.constructor; base && ( base !== Object ) && ( base !== Interface ) && ( base !== Enum ); base = getBase( base ) )
	    {
	        if ( base.interfaces && matchInterface( base, _interface ) )
	            return true;
	    }

	    // Resort to duck-type check
	    return ( _strict !== true ) && duckHasInterface( isFn ? _target.prototype : _target, _interface );
	}


	//
	// Start of Declare methods
	//

	/**
	 * Helper method that unifies errors returned by declare* methods.
	 * @param {string} _name The name of the function from which the error is triggered
	 * @param {Array} _arguments or (arguments object) of arguments
	 * @param {string} _message The custom part of the message
	 * @returns {string} The error message
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function formatErrorMessage( _name, _arguments, _message )
	{
	    return _name + "( " + Array.prototype.map.call( _arguments, describe ).join( ", " ) + " ): " + _message;
	}

	/**
	 * Helper method that will validate the _class argument passed to declare(Class|Interface|Enum).
	 * Ensures consistent validation across methods.
	 * @param {function} _class The _class argument as received by the declare method.
	 * @param {string} _method The name of the method requesting the validation.
	 * @param {Array} _arguments The arguments passed to the requesting method.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function validateClassArg( _class, _method, _arguments )
	{
	    // Validation
	    if ( !_class || ( typeof _class !== "function" ) )
	        throw new TypeError( formatErrorMessage( _method, _arguments, "_class is not a function." ) );
	    // Some special methods don't have a prototype, warn when these are passed to declareClass
	    if ( !( "prototype" in _class ) )
	        throw new Error( formatErrorMessage( _method, _arguments, "_class doesn't have a prototype property; it is probably a built-in function." ) );
	    if ( ( "superclass" in _class ) || ( "interfaces" in _class ) )
	        throw new Error( formatErrorMessage( _method, _arguments, "The " + describe( _class ) + " is already declared, cannot perform " + _method + "." ) );
	    if ( native_ctors.indexOf( _class ) >= 0 )
	        throw new Error( formatErrorMessage( _method, _arguments, "Attempt to call " + _method + " on built-in type" + ( _class.name ? " " + _class.name + "." : "" ) ) );
	    // Note: this check can fail if the base prototype can not be detected. We still perform it as
	    // a convenience for detecting errors, and hope the check for existing properties on the
	    // prototype will catch the other cases.
	    var base = getBase( _class );
	    if ( base && ( base !== Object ) )
	        throw new Error( formatErrorMessage( _method, _arguments, "_class already has a base " + describe( base ) + "." ) );

	    // Throw an error if anything has been defined on the original prototype
	    checkCleanPrototype( _class, _method );
	}

	/**
	 * Helper method that will pop the last value of an array if it's not a function.
	 * If the last argument is a function, or the array is empty, the _array is not modified and null is returned.
	 * @param {Array} _array The array to pop the non-function from.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function popNonFunction( _array )
	{
	    var len = _array.length;
	    return ( len > 0 ) && ( typeof _array[len - 1] !== "function" ) ? Object( _array.pop() ) : null;
	}

	/**
	 * Helper method that perform the actual class definition for both abstractClass and declareClass.
	 * @param {String} _definingName The function that is requesting a class be made, e.g. abstractClass or declareClass.
	 * @param {arguments} _args The arguments passed along to the declare function.
	 * @param {Boolean} [_validate=false] Optional: whether interfaces should be validated for implementation.
	 * @memberof module:barejs.decl~
	 * @private
	 */
	function makeClass( _definingName, _args, _validate )
	{
	    // normalize optional interfaces and/or prototype properties
	    var cls = _args[0],
	        base = null,
	        interfaces = null,
	        stat = null,
	        proto = null;

	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( true )
	        validateClassArg( cls, _definingName, _args );

	    if ( _args.length > 1 )
	    {
	        interfaces = slice.call( _args, 1, _args.length );

	        // If the first additional argument is null or a constructor function (not an interface), it is a base class.
	        if ( ( interfaces[0] === null ) || ( ( typeof interfaces[0] === "function" ) && ( !isInterface( interfaces[0] ) ) ) )
	            base = interfaces.shift();

	        // If the last argument is not a function, assume it's a prototype definition.
	        proto = popNonFunction( interfaces );
	        // If the second to last argument is not a function, assume it's a static definition.
	        stat = popNonFunction( interfaces );
	    }

	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( true )
	    {
	        // If a base class is passed, validate it too
	        if ( base )
	        {
	            if ( typeof base !== "function" )
	            {
	                throw new TypeError( formatErrorMessage( _definingName, _args, "_base is not a function.\r\n" +
	                        "If you are passing a prototype definition, specify null as second argument." ) );
	            }
	            if ( cls === base )
	                throw new Error( formatErrorMessage( _definingName, _args, "A class cannot extend itself." ) );
	            if ( !( "prototype" in base ) )
	                throw new Error( formatErrorMessage( _definingName, _args, "base doesn't have a prototype property; it is probably a built-in function." ) );
	            if ( hasBase( base, Enum ) )
	                throw new Error( formatErrorMessage( _definingName, _args, "Cannot extend an enum. To create an enum, use declareEnum." ) );
	            if ( hasBase( base, Interface ) )
	            {
	                throw new Error( formatErrorMessage( _definingName, _args,
	                        "Cannot extend an interface.\r\n" +
	                        "To declare implementing interfaces, add them as arguments after _base; passing null as base class.\r\n" +
	                        "To create an interface extending another interface, use declareInterface instead."
	                ) );
	            }
	        }
	    }

	    if ( base === null )
	        base = Object;

	    derive( cls, base, expandDefineProperties( proto, base && base.prototype, toDefineProperty, ( cls.name || "(Class)" ) + ".prototype" ) );
	    setInterfaces( cls, interfaces, base.interfaces );

	    // Apply static definition
	    if ( base !== Object || stat )
	        applyStatic( cls, base, stat );

	    // If not inherited from a base class, add certain utility methods like "is" and "as" to the class.
	    if ( !( "as" in cls.prototype ) )
	        ObjectPolyfill.defineProperties( cls.prototype, classProtoExtension );

	    // If we or our base have any interfaces, and if we're validating
	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( !(false) && _validate && ( cls.interfaces.length > 0 ) )
	    {
	        // If we have a prototype definition ...
	        if ( proto )
	        {
	            // validate immediately.
	            validateInterfacesImplemented( cls );
	        }
	        else
	        {
	            // We can't validate immediately (since methods are expected to be added via
	            // MyClass.prototype.method = function() {}; calls), so we queue validation.

	            _validate.push( cls );
	            if ( !( "timeout" in _validate ) )
	                _validate.timeout = setTimeout( handleValidateQueue, 1 );
	        }
	    }

	    return cls;
	}

	/**
	 * Declare a constructor function to be an abstract class. Allows specifying an optional base class and interfaces implemented.
	 * When reading or writing decl.abstractClass statements, it might help to know it was designed to mimic popular languages
	 * in its format. Here's an example:
	 *
	 *      // With common languages
	 *      abstract class ClassName : BaseClass, Interface1, Interface2 // C#
	 *      abstract class ClassName extends BaseClass implements Interface1, Interface2 // Java
	 *      {
	 *          private String _name;
	 *
	 *          public ClassName( _name )
	 *          {
	 *              super( 42 );
	 *              this._name = _name;
	 *          }
	 *
	 *          public String toString()
	 *          {
	 *              return this._name;
	 *          }
	 *      }
	 *
	 *      // With barejs.decl:
	 *
	 *      function ClassName( _name )
	 *      {
	 *          BaseClass.call( this, 42 );
	 *          this._name = _name;
	 *      }
	 *
	 *      decl.abstractClass( ClassName, BaseClass, Interface1, Interface2,
	 *      {
	 *          // This puts the _name property as null on the prototype,
	 *          // which is purely for clarity (e.g. stating it exists).
	 *          _name: null,
	 *
	 *          toString: function()
	 *          {
	 *              return this._name;
	 *          }
	 *      }
	 *
	 *    - If a base class is provided, decl will ensure _class.prototype is instanceof _base.prototype.
	 *    - For abstract classes, decl will not validate if interface methods are implemented.
	 *    - If a _static argument is specified, it will be applied to the constructor function using {@link module:barejs.decl.defineObject defineObject}.
	 *    - If a _prototype argument is specified, it will be applied to the prototype using {@link module:barejs.decl.defineObject defineObject}.
	 *    - If only 1 object is supplied, it is always interpreted as prototype definition, never as static.
	 *      You must specify null for the prototype object if you only want to specify static members.
	 *
	 * By default, any static members (except `name`, `prototype`, `constructor`, `superclass` and other metadata) will inherit.
	 * A class can make static functions "private" by defining a static `$private` function, accepting a String/Symbol as key.
	 * This function should return `true` for any keys that should *not* inherit. The `$private` function itself will never inherit.
	 *
	 * @param {function} _class The constructor function of the class
	 * @param {function} [_base] Optional: Extended base class
	 * @param {...function} [_interface] Optional: Any number of implemented interfaces
	 * @param {object} [_static] Optional: static definition; properties that will be added to the constructor function.
	 * @param {object} [_prototype] Optional: prototype definition: properties that will be added to the prototype
	 * @returns {function} The constructor function (**_class**), so it can immediately be returned
	 * @memberof module:barejs.decl
	 */
	function abstractClass( _class/*[, _base] [, _interface...] [, _static] [, _prototype] */ )
	{
	    return makeClass( "abstractClass", arguments );
	}

	/**
	 * Declare a constructor function to be a class. Allows specifying an optional base class and interfaces implemented.
	 * When reading or writing decl.declareClass statements, it might help to know it was designed to mimic popular languages
	 * in its format. Here's an example:
	 *
	 *      // With common languages
	 *      class ClassName : BaseClass, Interface1, Interface2 // C#
	 *      class ClassName extends BaseClass implements Interface1, Interface2 // Java
	 *      {
	 *          private String _name;
	 *
	 *          public ClassName( _name )
	 *          {
	 *              super( 42 );
	 *              this._name = _name;
	 *          }
	 *
	 *          public String toString()
	 *          {
	 *              return this._name;
	 *          }
	 *      }
	 *
	 *      // With barejs.decl:
	 *
	 *      function ClassName( _name )
	 *      {
	 *          BaseClass.call( this, 42 );
	 *          this._name = _name;
	 *      }
	 *
	 *      decl.declareClass( ClassName, BaseClass, Interface1, Interface2,
	 *      {
	 *          // This puts the _name property as null on the prototype,
	 *          // which is purely for clarity (e.g. stating it exists).
	 *          _name: null,
	 *
	 *          toString: function()
	 *          {
	 *              return this._name;
	 *          }
	 *      }
	 *
	 *    - If a base class is provided, decl will ensure _class.prototype is instanceof _base.prototype.
	 *    - If interfaces are declared, decl will validate methods are implemented.
	 *    - If a _static argument is specified, it will be applied to the constructor function using {@link module:barejs.decl.defineObject defineObject}.
	 *    - If a _prototype argument is specified, it will be applied to the prototype using {@link module:barejs.decl.defineObject defineObject}.
	 *    - If only 1 object is supplied, it is always interpreted as prototype definition, never as static.
	 *      You must specify null for the prototype object if you only want to specify static members.
	 *
	 * By default, any static members (except `name`, `prototype`, `constructor`, `superclass` and other metadata) will inherit.
	 * A class can make static functions "private" by defining a static `$private` function, accepting a String/Symbol as key.
	 * This function should return `true` for any keys that should *not* inherit. The `$private` function itself will never inherit.
	 *
	 * @param {function} _class The constructor function of the class
	 * @param {function} [_base] Optional: Extended base class
	 * @param {...function} [_interface] Optional: Any number of implemented interfaces
	 * @param {object} [_static] Optional: static definition; properties that will be added to the constructor function.
	 * @param {object} [_prototype] Optional: prototype definition: properties that will be added to the prototype
	 * @returns {function} The constructor function (**_class**), so it can immediately be returned
	 * @memberof module:barejs.decl
	 */
	function declareClass( _class/*[, _base] [, _interface...] [, _static] [, _prototype] */ )
	{
	    return makeClass( "declareClass", arguments, validateQueue );
	}

	/**
	 * Declare an interface. An interface can extend multiple interfaces by passing them as additional parameters.
	 * The constructor function _class will be made to derive from the special internal {@link module:barejs.decl~Interface Interface} type.
	 * It is not meant to be instantiated, and decl will never call the interface's constructor.
	 * @param {function} _class The "constructor" function to declare as an interface.
	 * @param {...function} [_interface] Any number of interfaces to extend.
	 * @param {object} [_static] Optional: static definition; properties that will be added to the constructor function.
	 * @param {object} [_prototype] Optional: prototype to apply
	 * @returns {function} The interface definition (_class).
	 * @memberof module:barejs.decl
	 */
	function declareInterface( _class /*[, _interface...] [, _static] [, _prototype] */ )
	{
	    var interfaces = null,
	        stat = null,
	        proto = null;

	    // Development time validation
	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( true )
	        validateClassArg( _class, "declareInterface", arguments );

	    // If the interface extends other interfaces, set up the inheritance.
	    if ( arguments.length > 1 )
	    {
	        interfaces = slice.call( arguments, 1, arguments.length );

	        // If the last argument is not a function, assume it's a prototype definition.
	        proto = popNonFunction( interfaces );
	        // If the second to last argument is not a function, assume it's a static definition.
	        stat = popNonFunction( interfaces );
	    }

	    // Each interface derives directly from Interface so it is easy to detect interfaces.
	    derive( _class, Interface, expandDefineProperties( proto, Interface.prototype, toDefinePropertyInterface, _class.name || "(Interface)" ) );
	    setInterfaces( _class, interfaces, null );
	    if ( stat )
	        applyStatic( _class, null, stat );

	    // Development time validation
	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( !(false) && validateQueue )
	    {
	        // If we don't have a prototype definition ...
	        if ( proto === null )
	        {
	            // We can't validate immediately (since methods are expected to be added via
	            // MyInterface.prototype.method = function() {}; calls), so we queue validation.

	            // Prepend interfaces so they get validated first
	            validateQueue.unshift( _class );
	            if ( !( "timeout" in validateQueue ) )
	                validateQueue.timeout = setTimeout( handleValidateQueue, 1 );
	        }
	        else
	        {
	            // Otherwise just validate immediately.
	            // Creating the interface metadata will perform validation of the interface.
	            InterfaceMetaData.get( _class );
	        }
	    }

	    return _class;
	}

	/**
	 * Declare an enum. decl will make _class derive from the special internal {@link module:barejs.decl~Enum Enum} type,
	 * and return a new instance of it. Enum values should be set on 'this' in the constructor, utility methods should be
	 * added to the prototype.
	 *
	 *      var SampleEnum = decl.declareEnum( function SampleEnum()
	 *      {
	 *          this.Bit1 = 1;
	 *          this.Bit2 = 2;
	 *          this.Bit3 = 4;
	 *          this.Bit4 = 8;
	 *      },
	 *      // End of constructor, what follows is the prototype definition:
	 *      {
	 *          hasBit: function( _bit, _value )
	 *          {
	 *              // hasValue is provided by the Enum base class
	 *              if ( !this.hasValue( _bit ) )
	 *                  throw new TypeError( "Unknown SampleEnum value: " + _bit );
	 *              return _value & _bit === _bit
	 *          }
	 *      } );
	 *
	 *      // SampleEnum is now instanceof the SampleEnum function passed to decl.
	 *      SampleEnum.hasBit( SampleEnum.Bit2, 3 ); // true
	 *      // And it inherited decl's Enum type members
	 *      SampleEnum.names(); // ["Bit1", "Bit2", "Bit3", "Bit4"]
	 *      SampleEnum instanceof Object; // false
	 *
	 * Note that the prototype property, if specified, is applied using {@link module:barejs.decl.defineObject defineObject}.
	 * @param {function} _class The "constructor" function to declare as an Enum.
	 * @param {object} [_prototype] Optional: things to add to the enum prototype.
	 * @returns {object} The enum instance (instanceof _class).
	 * @memberof module:barejs.decl
	 */
	function declareEnum( _class/*[, _prototype]*/ )
	{
	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( true )
	        validateClassArg( _class, "declareEnum", arguments );

	    // An enum inherits directly from Enum, so they can be easily detected (and receive some helper methods).
	    derive( _class, Enum, expandDefineProperties( arguments[1], Enum.prototype, toDefineProperty, ( _class.name || "(Enum)" ) ) );

	    // jshint -W055
	    // Return an instance for an enum
	    return ObjectPolyfill.freeze( new _class() );
	    // jshint +W055
	}

	/**
	 * defineObject is similar to {@link module:barejs.decl.defineProperties decl.defineProperties}, but it expands the _definition's properties if needed.
	 * It will update values of properties that are not property assigment definitions to be proper property definitions, defaulting to:
	 *
	 *      { configurable: false, writable: true, enumerable: true, value: &lt;value&gt; }
	 *
	 * (Note: enumerable will be `false` if the name starts with _ or is a Symbol).
	 * defineObject will iterate the _definition object and expand properties on it. Please be aware of the following:
	 *  1.  **_destination** will be modified. If that's a problem, use {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign Object.assign} to create a copy first.
	 *  2.  Existing properties are scanned for presence of a **value**, **get** or **set** property. If these are present on a value, you **must** use the full property syntax:
	 *
	 *          decl.defineObject( MyClass,
	 *          {
	 *              // Since the object we want to assign to the MyClass constructor function has properties that make it look like
	 *              // a property definition, we have to wrap it in a property definition as required by Object.defineProperties.
	 *              staticFlags: { enumerable: true, value: { get: true, set: false } }
	 *          } );
	 *
	 *  3.  defineObject will silently ignore getter/setter properties in environments that don't support them, unlike {@link module:barejs.decl.defineProperties}.
	 *  4.  You can reference a getter or setter by name, provided it is also on the definition object:
	 *
	 *          decl.defineObject( {},
	 *          {
	 *              // underlying data Array, not enumerable, configurable or writable
	 *              _values: { value: [] },
	 *              // getSize function that returns the length of the _values
	 *              getSize: function() { return this._values.length; },
	 *              // Size property. Refers to the getSize function for the getter, instead of using an inline function.
	 *              size: { enumerable: true, get: "getSize" }
	 *          } );
	 *
	 * @param {object} _target The target object
	 * @param {object} _definition The definitions to assign to _target. Note that _definition will be modified to contain property definitions(!).
	 * @param {string} [_objectName] Optional: the name of the object. If passed, decl will generate displayName properties on methods for an enhanced debugging experience.
	 * For example: if "decl" is passed as name, and there's an "is" function on _definition, the displayName of the "is" function will be set to "decl.is").
	 * @returns _target The target object, expanded
	 * @memberof module:barejs.decl
	 */
	function defineObject( _target, _definition/*, _objectName*/ )
	{
	    if ( !_definition )
	        throw new Error( "Missing definition" );
	    return ObjectPolyfill.defineProperties( _target, expandDefineProperties( _definition, _target, toDefineProperty, arguments.length > 2 ? String( arguments[2] ) : _target.name ) );
	}

	/**
	 * Interpret `_target` as implementing a Java Functional Interface. A functional interface is an Interface with exactly
	 * 1 function defined. Java allows lambda expressions to be generated for arguments of this type of interface.
	 * This method allows normalizing a function or object to a "Functional Interface Object", so Java behavior can be
	 * emulated.
	 * This function will accept:
	 *   - `null`/`undefined` (then `null` is returned)
	 *   - A function (an 'instance' of _functionalInterface is returned, with this function in place).
	 *   - An object complying with _functionalInterface
	 *
	 * Any other argument will throw a {@link TypeError}.
	 * @param {object|function} _target The target object or function.
	 * @param {function} _functionalInterface The interface to use as functional interface. May only have a single method defined.
	 * @param {boolean} [_strict=false] Optional: set to true to avoid a duck-type check, and only check `decl`
	 * metadata for interfaces implemented.
	 * @returns Either an object compliant with `_functionalInterface`, or `null`.
	 * @throws {TypeError} A TypeError may occur if `_functionalInterface` is not a valid functional interface,
	 * or if _target does not comply with the interface.
	 * @memberof module:barejs.decl
	 */
	function asFunctional( _target, _functionalInterface, _strict )
	{
	    if ( !isInterface( _functionalInterface ) )
	        throw new TypeError( _functionalInterface + " is not an interface" );
	    var meta = InterfaceMetaData.get( _functionalInterface );
	    var fn = meta.members[ 0 ];
	    if ( meta.members.length !== 1 || fn.type !== "function" )
	        throw new TypeError( _functionalInterface.prototype + " is not a functional interface, functional interfaces have a single method" );
	    if ( _target === null || _target === undefined )
	        return null;

	    // If this is a function, return an object that can be used instead.
	    if ( typeof _target === "function" )
	    {
	        var def = {};
	        def[fn.name] = { enumerable: true, value: _target };
	        return Object.create( _functionalInterface.prototype, def );
	    }
	    if ( hasInterface( _target, _functionalInterface, _strict ) )
	        return _target;

	    throw new TypeError( _target + " does not implement " + _functionalInterface.prototype );
	}


	defineObject( exports,
	{
	    // Exports
	    isInterface:        isInterface,
	    isEnum:             isEnum,
	    isProxy:            isProxy,
	    is:                 is,
	    hasBase:            hasBase,
	    hasInterface:       hasInterface,
	    proxy:              proxy,
	    abstractClass:      abstractClass,
	    declareClass:       declareClass,
	    declareInterface:   declareInterface,
	    declareEnum:        declareEnum,
	    defineObject:       defineObject,
	    asFunctional:       asFunctional,
	    // Convenience properties to define interface properties
	    readOnlyProperty:     readOnlyProperty,
	    readWriteProperty:    readWriteProperty,
	    // Allows certain low level classes to disallow casting to them
	    preventCast:          preventCast
	}, "decl" );

	// We do NOT want to add a displayName to methods from other modules, so use a separate defineObject
	defineObject( exports,
	/** @lends module:barejs.decl */
	{
	    // Helper methods/flags for property definitions
	    /**
	     * This convenience property is true if the environment supports property getters and setters.
	     * @member {boolean}
	     */
	    hasPropertySupport: ObjectPolyfill.propertyGetSetSupport,
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty Object.defineProperty}.
	     *
	     * If the native version is not available, a fall-back is used. The fallback supports the same syntax as the original, but falls back to simple assignment
	     * or deprecated constructs like {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__ __defineGetter__}.
	     * Be aware that property getters or setters may not be supported in some environments, which is indicated by {@link module:barejs.decl.hasPropertySupport hasPropertySupport} being false.
	     * @function
	     * @param {object} _target The object to define the property on
	     * @param {string|Symbol} _key The name or {@link module:barejs.Symbol Symbol} to set
	     * @param {object} _definition Object containing either a **value** property, or a **get** and/or **set** property (function).
	     * @param {function} [_definition.get] A getter function, taking no arguments and returning the property value.
	     * @param {function} [_definition.set] A setter function, taking a value as argument.
	     * @param {*} [_definition.value] The value to assign to the property.
	     * @param {boolean} [_definition.writable=false] (Only in combination with value) Whether assigning to the property is allowed.
	     *                      For properties with get/set, the writable is implicit (by absence or presence of a setter function).
	     * @param {boolean} [_definition.configurable=false] Whether the property may be altered via delete or a next defineProperty call.
	     * @param {boolean} [_definition.enumerable=false] Whether the property shows up in object property enumerations.
	     * @returns {object} The object the properties where defined on (_target).
	     */
	    defineProperty: ObjectPolyfill.defineProperty,
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties Object.defineProperties}.
	     *
	     * If the native version is not available, a fall-back is used. The fallback supports the same syntax as the original, and uses the {@link module:barejs.decl.defineProperty defineProperty} fallback.
	     * @function
	     * @param {object} _target The object to define the property on
	     * @param {object} _definitions Object containing properties, each of which have a value that is a definition as passed to defineProperty.
	     * @returns {object} The object the properties where defined on (_target).
	     */
	    defineProperties: ObjectPolyfill.defineProperties,
	    // Helper methods for object strictness (seal/freeze)
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/seal Object.seal}.
	     *
	     * If the native version is not available, a **no-operation** function is used. The object is not altered in any way and simply returned.
	     * @function
	     * @param {object} _target The object to seal.
	     * @returns {object} The object that was passed (_target).
	     */
	    seal: ObjectPolyfill.seal,
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed Object.isSealed}.
	     * A sealed object may not be altered by adding or removing properties. Existing properties may be altered (provided they are writable).
	     *
	     * If the native version is not available, a **no-operation** function is used. The object is not altered by the fallback, and it always returns false (since sealing objects is not supported).
	     *
	     * @function
	     * @param {object} _target The object to evaluate.
	     * @returns {boolean} True if the object (_target) is sealed, false otherwise. The fallback always returns false.
	     */
	    isSealed: ObjectPolyfill.isSealed,
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze Object.freeze}.
	     * A frozen object may not be altered in any way. No properties may be added or removed (like seal), and all values are made read-only.
	     *
	     * If the native version is not available, a **no-operation** function is used. The object is not altered in any way and simply returned.
	     *
	     * @function
	     * @param {object} _target The object to freeze.
	     * @returns {object} The object that was passed (_target).
	     */
	    freeze: ObjectPolyfill.freeze,
	    /**
	     * decl re-exports {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen Object.isFrozen}.
	     *
	     * If the native version is not available, a **no-operation** function is used. The object is not altered by the fallback, and it always returns false (since freezing objects is not supported).
	     * @function
	     * @param {object} _target The object to evaluate.
	     * @returns {boolean} True if the object (_target) is frozen, false otherwise. The fallback always returns false.
	     */
	    isFrozen: ObjectPolyfill.isFrozen
	} /*DO NOT ADD NAME*/ );
	exports.freeze( exports );

	// End of define
	}(
	    Object,
	    Array,
	    String,
	    Error,
	    TypeError,
	    __webpack_require__( 2 ),
	    __webpack_require__( 3 ),
	    __webpack_require__( 6 ),
	    __webpack_require__( 8 ),
	    __webpack_require__( 10 ),
	    // Unreferenced: decl depends on the Array polyfills too.
	    __webpack_require__( 12 )
	) );


/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015, 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( exports, Object )
	{
	"use strict";
	/*global Symbol*/

	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var toString = Object.prototype.toString;
	 // RegExp set up to match BareJS and polyfill.io symbol strings
	 // polyfill uses "__\x01symbol:" and "__\x01symbol@@"
	var reSymbol = /^__\d*\x01?[sS]ymbol/;
	// By default, make members whose name does not start with _ or $ enumerable.
	var reEnumerable = /^[^_\$]/;
	var strUndef = "undefined";

	var NativeSymbol = typeof Symbol !== strUndef ? Symbol : null;
	//jshint -W122
	var symIt = NativeSymbol && ( typeof Symbol.iterator === "symbol" ) ? Symbol.iterator : /*istanbul ignore next*/ null;
	//jshint +W122

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object Object}.
	 * Module that provides implementations for methods missing on Object. Methods that cannot be polyfilled close enough to
	 * the spec (since they rely on Native implementations) are not added to the Object global.
	 * @class module:barejs/polyfill.Object
	 */

	 /** @lends module:barejs/polyfill.Object */
	 var stat = {};

	/**
	 * Shortcut method that only defines a property if it is not already known
	 * @param {object} _target The object to polyfill
	 * @param {object} _members The members to polyfill
	 * @param {object} [_copy] Optional: an object that the definitions will be copied to.
	 * @param {string} [_ownerName] Optional: name of the owner object
	 * @memberof module:barejs/polyfill.Object~
	 * @private
	 */
	function polyMixin( _target, _members, _copy, _ownerName )
	{
	    for ( var name in _members )
	    {
	        /*istanbul ignore else: we're working on clean objects, iterating prototype properties is unexpected*/
	        if ( _members.hasOwnProperty( name ) )
	        {
	            var member = _members[name], isFn = typeof member === "function";
	            if ( isFn && _ownerName )
	                member.displayName = _ownerName + "." + name;
	            if ( _copy )
	                _copy[name] = member;
	            if ( !( name in _target ) )
	                exports.defineProperty( _target, name, { enumerable : false, configurable: isFn, writable: isFn, value: member } );
	        }
	    }
	}

	/**
	 * Helper method that allows to easily apply static and prototype properties to a native object
	 * @param {function} _native The native Object constructor to polyfill
	 * @param {object} _static The static methods to polyfill. Can be null.
	 * @param {object} _proto The instance members to polyfill. Can be null.
	 * @param {object} [_copy] Optional: an object that the definitions will be copied to.
	 * @param {string} [_ownerName] Optional: the name of the owner object.
	 * Allows to add functions to "exports" as well, for unit testing.
	 * @memberof module:barejs/polyfill.Object
	 * @private
	 */
	exports.polyfill = function polyfill( _native, _static, _proto, _copy, _ownerName )
	{
	    if ( _static )
	        polyMixin( _native, _static, _copy, _ownerName );
	    if ( _proto )
	        polyMixin( _native.prototype, _proto, _copy, _ownerName && ( _ownerName + ".prototype" ) );
	    return _native;
	};

	exports.shouldBeEnumerable = function shouldBeEnumerable( _name )
	{
	    return typeof _name === "string" && reEnumerable.test( _name );
	};

	/**
	 * Utility method to check if _target is an Object
	 * @param _arg The argument to check.
	 * @returns {boolean} True if the target is an object, false otherwise
	 */
	function isObject( _arg )
	{
	    switch ( _arg && typeof _arg )
	    {
	        case "object":
	        case "function":
	            return true;

	        default:
	            return false;
	    }
	}
	exports.isObject = isObject;

	/**
	 * Utility method to convert target to an Object (according to Ecmascript standard)
	 * @param _arg The argument to check.
	 * @param _caller The function requesting the cast. If provided, changes the exception message.
	 * @returns {object} The argument, as object
	 * @throws {TypeError} A TypeError if _arg is null or undefined.
	 */
	function toObject( _arg, _caller )
	{
	    switch ( _arg === null ? strUndef : typeof _arg )
	    {
	        case "undefined":
	            throw new TypeError( _caller ? _caller.displayName + " called on null or undefined" : "Cannot convert undefined or null to object" );

	        case "object":
	        case "function":
	            return _arg;

	        default:
	            return Object( _arg );
	    }
	}

	exports.toObject = toObject;

	/**
	 * Check if _arg is callable (i.e. a function).
	 * @param _arg The argument to check.
	 * @returns {boolean} True if _arg is a function, false otherwise.
	 * @memberof module:barejs/polyfill.Object
	 * @private
	 */
	exports.isCallable = function isCallable( _arg )
	{
	    // We can't check the internal [[Call]] property, so we rely on type checking.
	    return ( typeof _arg === "function" ) || ( toString.call( _arg ) === "[object Function]" );
	};

	/**
	 * Convenience method to check if _arg is callable (i.e. a function).
	 * Note: If a second argument is provided, that is returned instead of _arg.
	 * This allows inlining the ensureCallable method in convenient locations.
	 * @param _arg function to check
	 * @returns _arg, or second argument if present
	 * @throws {TypeError} if _arg is not callable.
	 * @memberof module:barejs/polyfill.Object
	 * @private
	 */
	exports.ensureCallable = function ensureCallable( _arg )
	{
	    if ( !exports.isCallable( _arg ) )
	        throw new TypeError( _arg + " is not a function" );

	    return arguments.length > 1 ? arguments[1] : _arg;
	};

	/**
	 * Helper function that will attempt to set the ES6 iterator Symbol for a class.
	 * @param {object} _target The object to define the iterator on.
	 * @param {function} _function The function that will result in the iterator.
	 * @returns {object} `_target`.
	 * @memberof module:barejs/polyfill.Object
	 * @private
	 */
	function setIterator( _target, _function )
	{
	    var def = { configurable: true, value: _function };
	    /*istanbul ignore else: always true in NodeJS*/
	    if ( symIt )
	        exports.defineProperty( _target, symIt, def );
	    // Set @@iterator for compliancy with polyfill libraries like core.js
	    exports.defineProperty( _target, "@@iterator", def );
	    return _target;
	}

	exports.setIterator = setIterator;

	/**
	 * Helper function that will get the ES6 iterator Symbol for a class.
	 * @param {function} _class The constructor function to define the iterator on
	 * @returns {object} The iterator, or null.
	 * @memberof module:barejs/polyfill.Object
	 * @private
	 */
	function getIterator( _target )
	{
	    var result = null;

	    if ( _target )
	    {
	        var obj = Object( _target );
	        if ( symIt && ( symIt in obj ) )
	            result = obj[symIt]();
	        else if ( "@@iterator" in obj )
	            result = obj["@@iterator"]();
	    }

	    return result;
	}

	exports.getIterator = getIterator;

	////////////////////////////////////////////////////////////////////////////////////////////////////
	// Grab some methods that we may have to provide fallbacks for
	////////////////////////////////////////////////////////////////////////////////////////////////////
	var modernPropertySupport = !!Object.defineProperties;
	var legacyPropertySupport = ( ( "__defineGetter__" in Object.prototype ) && ( "__defineSetter__" in Object.prototype ) );
	/*istanbul ignore next: We know we have Object.defineProperties in NodeJS*/
	exports.propertyGetSetSupport = modernPropertySupport || legacyPropertySupport;
	// Take care not to grab IE8's defineProperty that only works on DOM elements.
	/*istanbul ignore else: native in NodeJS*/
	if ( modernPropertySupport )
	{
	    exports.defineProperty      = Object.defineProperty;
	    exports.defineProperties    = Object.defineProperties;
	    exports.getOwnPropertyDescriptor    = Object.getOwnPropertyDescriptor;
	    exports.getOwnPropertyDescriptors   = Object.getOwnPropertyDescriptors;
	}
	exports.getPrototypeOf  = Object.getPrototypeOf;
	exports.freeze          = Object.freeze;
	exports.isFrozen        = Object.isFrozen;
	exports.seal            = Object.seal;
	exports.isSealed        = Object.isSealed;
	// ES6
	exports.getOwnPropertyNames = Object.getOwnPropertyNames;
	exports.getOwnPropertySymbols = Object.getOwnPropertySymbols;

	/*istanbul ignore else: The tests are run with __ES__ set to 3*/
	if ( (6) < 5 )
	{
	    ////////////////////////////////////////////////////////////////////////////////////////////////
	    // ES5 fallback functions
	    ////////////////////////////////////////////////////////////////////////////////////////////////
	    // The following methods are not actually polyfills; these methods cannot be polyfilled.
	    // However, if the fallback behavior provided by the methods is sufficient, these can be used.

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.defineProperty )
	    {
	        /*
	         * Object.defineProperty cannot be emulated on browsers that do not support it.
	         * However, if the intention is to just set a value (no getters/setters), and the loss of
	         * enumerable, writable and configurable flags is acceptable, this method can be used.
	         * Uses the native method where possible
	         *
	         * Note: check for compliance via Object.defineProperties, since IE8 has an Object.defineProperty,
	         * but that only works on DOM elements.
	         */
	        exports.defineProperty = function defineProperty( _object, _name, _definition )
	        {
	            if ( !isObject( _object ) )
	                throw new TypeError( "Object.defineProperty called on non-object" );
	            /*
	             * Fallback to simple assignment or __define[GS]etter__
	             */
	            // Only assign if it actually exists.
	            if ( "value" in _definition )
	            {
	                _object[_name] = _definition.value;
	            }
	            else if ( ( "get" in _definition ) || ( "set" in _definition ) )
	            {
	                if ( !exports.propertyGetSetSupport )
	                    throw new Error( "Property getters and setters are not supported in this environment" );

	                if (  "get" in _definition )
	                    _object.__defineGetter__( _name, _definition.get );
	                if ( "set" in _definition )
	                    _object.__defineSetter__( _name, _definition.set );
	            }

	            return _object;
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.defineProperties )
	    {
	        /*
	         * Uses the possibly emulated defineProperty and behaves like Object.defineProperties.
	         * Can only be used to set values (no getters/setters) in environments that do not support getters/setters.
	         * Uses the native method where possible
	         */
	        exports.defineProperties = function defineProperties( _object, _properties )
	        {
	            if ( !isObject( _object ) )
	                throw new TypeError( "Object.defineProperties called on non-object" );

	            _properties = toObject( _properties );

	            // Assume there is no Object.keys in an environment that requires this polyfill.
	            for ( var i in _properties )
	                if ( hasOwnProperty.call( _properties, i ) && ( !reSymbol.test( i ) ) ) // Ignore Symbols
	                    exports.defineProperty( _object, i, _properties[i] );

	            return _object;
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.getPrototypeOf )
	    {
	        /**
	         * Object.getPrototypeOf cannot be fully emulated on browsers that do not support it.
	         * We attempt to find a __proto__ or constructor.prototype.
	         * Attempt to get an objects prototype, returns null on failure
	         * @param {object} _object The object to get the prototype of
	         * @returns {object} The prototype of _object
	         * @memberof module:barejs/polyfill.Object
	         * @private
	         */
	        exports.getPrototypeOf = function getPrototypeOf( _object )
	        {
	            switch ( _object === null ? strUndef : typeof _object )
	            {
	                case "undefined":
	                    throw new TypeError( "Cannot convert undefined or null to object" );

	                case "boolean":
	                    return Boolean.prototype;

	                case "number":
	                    return Number.prototype;

	                case "string":
	                    return String.prototype;

	                case "function":
	                    return Function.prototype;

	                // case "object", and any other host value
	                default:
	                    // jshint -W103
	                    if ( "__proto__" in _object )
	                        return _object.__proto__;
	                    // jshint +W103

	                    // If the object has the constructor property, this is already a prototype
	                    if ( !hasOwnProperty.call( _object, "constructor" ) )
	                        return _object.constructor.prototype;
	                    // See if a framework set a superclass property
	                    else if ( _object.constructor.superclass )
	                        return _object.constructor.superclass.prototype;

	                    if ( Array.isArray( _object ) )
	                        return Array.prototype;

	                    return null;
	            }
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.freeze )
	    {
	        /*
	         * Object.freeze cannot be emulated. This method is a NOOP if Object.freeze is not supported.
	         */
	        exports.freeze = function freeze( _o ){ return _o; };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.isFrozen )
	    {
	        /*
	         * Object.isFrozen cannot be emulated. This method is a NOOP if Object.isFrozen is not supported.
	         */
	        exports.isFrozen = function isFrozen( _o ){ return false; };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.seal )
	    {
	        /*
	         * Object.seal cannot be emulated. This method is a NOOP if Object.seal is not supported.
	         */
	        exports.seal = function seal( _o ){ return _o; };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.isSealed )
	    {
	        /*
	         * Object.isSealed cannot be emulated. This method is a NOOP if Object.isSealed is not supported.
	         */
	        exports.isSealed = function isSealed( _o ){ return false; };
	    }

	    ////////////////////////////////////////////////////////////////////////////////////////////////
	    // ES5 polyfills
	    ////////////////////////////////////////////////////////////////////////////////////////////////

	    //
	    // ES5 - Object
	    //

	    ( function()
	    {
	        /*global document, ActiveXObject*/
	        var createEmpty;
	        // While we generally prefer named constructors, avoid it here since it adds no value,
	        // and may even be confusing when looking at the prototype chain.
	        var Anonymous = function(){};

	        //jshint -W103
	        /*istanbul ignore else: NodeJS supports the __proto__ property*/
	        if ( ( !( { __proto__: null } instanceof Object ) ) || ( typeof document === strUndef ) )
	        {
	            // We can use the deprecated __proto__ property to create an object with no prototype
	            createEmpty = function()
	            {
	                return { __proto__: null };
	            };
	        }
	        //jshint +W103
	        else
	        {
	            // We grab a foreign Object.prototype so any object created from it has instanceof Object return false,
	            // and we can safely delete all properties from it without breaking regular objects.
	            createEmpty = function()
	            {
	                var shouldUseActiveX = ( function()
	                {
	                    try
	                    {
	                        return !!( document.domain && new ActiveXObject( "htmlfile" ) );
	                    }
	                    catch ( ex )
	                    {
	                        return false;
	                    }
	                }() );

	                function Empty() {}

	                if ( shouldUseActiveX )
	                {
	                    Empty.prototype = ( function( _xDoc )
	                    {
	                        _xDoc.write( "<script><\/script>" );
	                        _xDoc.close();

	                        var empty = _xDoc.parentWindow.Object.prototype;
	                        _xDoc = null;

	                        return empty;
	                    }( new ActiveXObject( "htmlfile" ) ));
	                }
	                else
	                {
	                    Empty.prototype = ( function( _parent, _iframe )
	                    {
	                        _iframe.style.display = "none";
	                        _parent.appendChild( _iframe );
	                        // jshint -W107
	                        _iframe.src = "javascript:";
	                        // jshint +W107

	                        var empty = _iframe.contentWindow.Object.prototype;
	                        _parent.removeChild( _iframe );
	                        _iframe = null;

	                        return empty;
	                    }( document.body || document.documentElement, document.createElement( "iframe" ) ) );
	                }

	                // Now delete all existing definitions on our "empty" object to make it truly empty
	                ( function( _e )
	                {
	                    delete _e.constructor;
	                    delete _e.hasOwnProperty;
	                    delete _e.propertyIsEnumerable;
	                    delete _e.isPrototypeOf;
	                    delete _e.toLocaleString;
	                    delete _e.toString;
	                    delete _e.valueOf;
	                }( Empty.prototype ) );

	                // Shortcut createEmpty for future calls
	                createEmpty = function()
	                {
	                    // This returns an object for which instanceof Object is false
	                    return new Empty();
	                };
	                return createEmpty();
	            };
	        }

	        /**
	         * Create an instance of an object that has another object as its prototype
	         * @param {object} _proto The prototype of the newly created object, or null.
	         * @param {object} _properties
	         * @returns {object} A new object that has the input object as prototype.
	         */
	        stat.create = function create( _proto, _properties )
	        {
	            var result;
	            // _proto has 3 valid values: null or an Object (a function is an Object too)
	            if ( _proto === null )
	            {
	                result = createEmpty();
	            }
	            else
	            {
	                if ( !isObject( _proto ) )
	                    throw new TypeError( "Object prototype may only be an Object or null: " + _proto );
	                Anonymous.prototype = _proto;
	                result = new Anonymous();
	                Anonymous.prototype = null; // Reset prototype so we don't hold a reference to _proto
	            }

	            if ( typeof _properties !== strUndef )
	                exports.defineProperties( result, toObject( _properties ) );

	            return result;
	        };
	    }() );

	    ( function()
	    {
	        var hasDontEnumBug = !( { toString: null } ).propertyIsEnumerable( "toString" ),
	            dontEnums = [
	                "toString",
	                "toLocaleString",
	                "valueOf",
	                "hasOwnProperty",
	                "isPrototypeOf",
	                "propertyIsEnumerable",
	                "constructor"
	            ],
	            dontEnumsLength = dontEnums.length;

	        /**
	         * Return the property names defined directly on object
	         * @param {object} _obj The target object.
	         * @returns {Array} String[] property names.
	         */
	        stat.keys = function keys( _obj )
	        {
	            // Ensure object
	            _obj = toObject( _obj );
	            var result = [];

	            for ( var prop in _obj )
	                if ( hasOwnProperty.call( _obj, prop ) && ( !reSymbol.test( prop ) ) ) // Ignore Symbols
	                    result.push(prop);

	            /*istanbul ignore if: not applicable in NodeJS*/
	            if ( hasDontEnumBug )
	            {
	                for ( var i = 0; i < dontEnumsLength; ++i )
	                    if ( hasOwnProperty.call( _obj, dontEnums[i] ) )
	                        result.push( dontEnums[i] );
	            }
	            return result;
	        };
	    }() );
	}

	/*istanbul ignore else: The tests are run with __ES__ set to 3*/
	if ( (6) < 6 )
	{
	    // Technically most of the methods set on exports are in ES5, but BareJS relies on them so ensure there's a fallback
	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.getOwnPropertyNames )
	    {
	        exports.getOwnPropertyNames = function( _object )
	        {
	            var result = [];

	            if ( _object )
	            {
	                var obj = Object( _object );
	                for ( var key in obj )
	                {
	                    if ( hasOwnProperty.call( obj, key ) && typeof key === "string" )
	                        result.push( key );
	                }
	            }

	            return result;
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.getOwnPropertySymbols )
	    {
	        exports.getOwnPropertySymbols = function getOwnPropertySymbols( _target )
	        {
	            // Ensure object
	            _target = toObject( _target );
	            var result = [];

	            for ( var prop in _target )
	                if ( hasOwnProperty.call( _target, prop ) && ( reSymbol.test( prop ) ) )
	                    result.push(prop);
	            return result;
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.getOwnPropertyDescriptor )
	    {
	        exports.getOwnPropertyDescriptor = function getOwnPropertyDescriptor( _object, _key )
	        {
	            var descriptor;

	            if ( _object )
	            {
	                var obj = Object( _object );
	                if ( hasOwnProperty.call( obj, _key ) )
	                {
	                    descriptor = { configurable: true, enumerable: true };
	                    var getter;
	                    var setter;

	                    if ( legacyPropertySupport )
	                    {
	                        getter = obj.__lookupGetter__( _key );
	                        setter = obj.__lookupSetter__( _key );
	                    }

	                    if ( getter || setter )
	                    {
	                        if ( getter )
	                            descriptor.get = getter;
	                        if ( setter )
	                            descriptor.set = setter;
	                    }
	                    else
	                    {
	                        descriptor.value = obj[_key];
	                    }
	                }
	            }

	            return descriptor;
	        };
	    }

	    /*istanbul ignore if: native in NodeJS*/
	    if ( !exports.getOwnPropertyDescriptors )
	    {
	        exports.getOwnPropertyDescriptors = function( _object )
	        {
	            var descriptors = {};

	            if ( _object )
	            {
	                var names = exports.getOwnPropertyNames( _object );

	                for ( var i = 0, len = names.length; i < len; ++i )
	                    descriptors[names[i]] = exports.getOwnPropertyDescriptor( _object, names[i] );
	            }

	            return descriptors;
	        };
	    }

	    /**
	     * Object.is() determines whether two values are the same value. Two values are the same if one of the following holds:
	     *  - both undefined
	     *  - both null
	     *  - both true or both false
	     *  - both strings of the same length with the same characters
	     *  - both the same object
	     *  - both numbers and
	     *  - both +0
	     *  - both -0
	     *  - both NaN
	     *  - or both non-zero and both not NaN and both have the same value
	     * @param _v1 The first value to compare.
	     * @param _v2 The second value to compare.
	     * @returns {boolean} A new object that has the input object as prototype.
	     */
	    stat.is = function is( _v1, _v2 )
	    {
	        if ( _v1 === _v2 )
	            return ( _v1 !== 0 ) || ( 1 / _v1 === 1 / _v2 ); // Ensure Object.is( +0, -0 ) returns false
	        else
	            return ( _v1 !== _v1 ) && ( _v2 !== _v2 ); // Ensure Object.is( NaN, NaN ) returns true
	    };

	    /**
	     * The Object.assign() method only copies enumerable and own properties from a source object to a target object.
	     * It uses [[Get]] on the source and [[Put]] on the target, so it will invoke getters and setters.
	     * Therefore it assigns properties versus just copying or defining new properties.
	     * This may make it unsuitable for merging new properties into a prototype if the merge sources contain getters.
	     * For copying property definitions, including their enumerability, into prototypes Object.getOwnPropertyDescriptor() and Object.defineProperty() should be used instead.
	     * @param {object} _target The target to assign to.
	     * @param {object} _firstSource The first source object to copy from.
	     * @returns {object} the _target, with properties assigned.
	     */
	    stat.assign = function assign( _target, _firstSource /*assign.length should be 2*/ )
	    {
	        // Ensure object
	        _target = toObject( _target );
	        for ( var arg = 1, argLen = arguments.length, source; arg < argLen; ++arg )
	        {
	            if ( isObject( source = arguments[arg] ) )
	            {
	                for ( var key in source )
	                {
	                    /*istanbul ignore else: clean prototypes assumed*/
	                    if ( hasOwnProperty.call( source, key ) )
	                        _target[key] = source[key];
	                }
	            }
	        }
	        return _target;
	    };
	// End of ES6 polyfill scope
	}

	if ( (6) < 7 )
	{
	    /**
	     * The Object.values() method returns an array of a given object's own enumerable property values,
	     * in the same order as that provided by a for...in loop
	     * (the difference being that a for-in loop enumerates properties in the prototype chain as well).
	     * @param {object} _target The object to enumerate.
	     * @returns {Array} The array of values
	     */
	    stat.values = function values( _target )
	    {
	        // Avoid using Array.map for speed (and perform in-place replacement)
	        for ( var t = toObject( _target ), result = Object.keys( t ), i = 0, len = result.length; i < len; ++i )
	            result[i] = t[result[i]];
	        return result;
	    };

	    /**
	     * The Object.entries() method returns an array of a given object's own enumerable property [key, value] pairs,
	     * in the same order as that provided by a for...in loop
	     * (the difference being that a for-in loop enumerates properties in the prototype chain as well).
	     * @param {object} _target The object to enumerate.
	     * @returns {Array} The array of values
	     */
	    stat.entries = function entries( _target )
	    {
	        // Avoid using Array.map for speed (and perform in-place replacement)
	        for ( var t = toObject( _target ), result = Object.keys( t ), i = 0, len = result.length; i < len; ++i )
	            result[i] = [ result[i], t[result[i]] ];
	        return result;
	    };
	// End of ES7 polyfill scope
	}

	// Apply static members (not using exports.polyfill since we only have static members)
	polyMixin( Object, stat, exports, "Object" );

	//
	// ES6 - ES5 Patching
	//
	/*istanbul ignore else: The tests are run with __ES__ set to 3*/
	if ( (6) < 6 )
	{
	    // It is possible Object.create exists (natively or polyfilled), but does not support the second
	    // argument. In this case, we replace it with a method that will call defineProperties
	    // We define this in the ES6 scope since we assume ES7 browsers will all support the optional second argument.

	    /*istanbul ignore if: NodeJS's Object.create supports the second argument*/
	    if ( Object.create( null, { test: { value: true } } ).test !== true )
	    {
	        Object.create = ( function( _originalCreate )
	        {
	            /**
	             * Object.create wrapper that adds support for an optional second argument.
	             */
	            return function create( _proto, _properties )
	            {
	                var result = _originalCreate.call( Object, _proto ); // Call native Object.create

	                if ( _properties )
	                    exports.defineProperties( result, _properties );

	                return result;
	            };
	        }( Object.create ) );
	    }
	}

	// End of module
	}( exports, Object ) );


/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global Map*/

	module.exports = ( (6) >= 6 ) || ( typeof Map !== "undefined" ) ? Map : /*istanbul ignore next*/ __webpack_require__( 4 );


/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, EntryStore )
	{
	"use strict";
	// Putting this in a var allows uglify to minify the code much more
	var SET_SIZE = !( ( (6) >= 5 ) || ObjectPolyfill.propertyGetSetSupport );

	/**
	 * @classdesc Iterator for the Map polyfill.
	 * @class module:barejs/polyfill.Map~MapIterator
	 * @extends module:barejs/polyfill.EntryStore.Iterator
	 */
	function MapIterator( _kind, _store )
	{
	    EntryStore.Iterator.call( this, _kind, _store );
	}

	MapIterator.prototype = Object.create( EntryStore.Iterator.prototype,
	/** @lends module:barejs/polyfill.Map~MapIterator */
	{
	    constructor: { writable: true, value: MapIterator }
	} );

	/**
	 * @classdesc Mimics the implementation of a native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map Map}.
	 * Has an O(n) lookup time for non String or Number keys, so cannot compete with a native Map (Which is supposed to have an O(1) lookup time).
	 * @class module:barejs/polyfill.Map
	 */
	function Map()
	{
	    ObjectPolyfill.defineProperty( this, "_store", { value: new EntryStore( arguments[0], true ) }  );

	    /*istanbul ignore if: NodeJS has property support*/
	    if ( SET_SIZE )
	        this.size = this._store.size;
	}

	ObjectPolyfill.defineProperties( Map.prototype,
	/** @lends module:barejs/polyfill.Map# */
	{
	    _store: { value: null },

	    /**
	     * The size of the Map, which represents the number of entries currently in the Map.
	     * @member {number}
	     * @readonly
	     */
	    size: ( SET_SIZE ?
	        /*istanbul ignore next*/ { writable: true, value: null } :
	        { "get": function size(){ return this._store && this._store.size; } } ),

	    /**
	     * Set a value for the specified key in the Map.
	     * @function
	     * @param _key The object to use as key.
	     * @param _value The value to add.
	     * @returns {module:barejs/polyfill.Map} The Map (for chaining)
	     */
	    "set": { value: function set( _key, _value )
	    {
	        this._store.set( _key, _value );
	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;

	        return this;
	    } },

	    /**
	     * Get the value for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns The value, or undefined if the key is not known.
	     */
	    "get": { value: function get( _key )
	    {
	        var entry = this._store.entries[this._store.indexOf( _key )];
	        return entry && entry[1];
	    } },

	    /**
	     * Check if the Map has an entry for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns {boolean} True if there is an entry for the key, false otherwise
	     */
	    has: { value: function has( _key )
	    {
	        return this._store.indexOf( _key ) >= 0;
	    } },

	    /**
	     * Remove the value for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns {boolean} True if the entry was deleted, false otherwise
	     */
	    "delete": { value: function _delete( _key )
	    {
	        var removed = this._store.remove( _key );
	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;
	        return removed;
	    } },

	    clear: { value: function clear()
	    {
	        this._store.clear();
	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;
	    } },

	    /**
	     * Iterate the Map
	     * @function
	     * @param {function} _callback The callback function.
	     * @param [_thisArg] Optional: context to call the callback in.
	     */
	    forEach: { value: function forEach( _callback/*, _thisArg*/ )
	    {
	        this._store.forEach( this, _callback, arguments[1] );
	    } },

	    /**
	     * Get a key iterator
	     * @function
	     * @returns {module:barejs/polyfill.Map~MapIterator} A key iterator
	     */
	    keys: { value: function keys()
	    {
	        return new MapIterator( "key", this._store );
	    } },

	    /**
	     * Get a value iterator
	     * @function
	     * @returns {module:barejs/polyfill.Map~MapIterator} A value iterator
	     */
	    values: { value: function values()
	    {
	        return new MapIterator( "value", this._store );
	    } },

	    /**
	     * Get an entry iterator
	     * @function
	     * @returns {module:barejs/polyfill.Map~MapIterator} A entry iterator
	     */
	    entries: { value: function entries()
	    {
	        return new MapIterator( "entry", this._store );
	    } }
	} );

	ObjectPolyfill.setIterator( Map.prototype, Map.prototype.entries );

	return Map;

	}( __webpack_require__( 2 ), __webpack_require__( 5 ) ) );


/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill )
	{
	"use strict";

	/**
	 * EntryStore provides the actual Map (and Set) implementation. Its implementation is shaped by two features:
	 * 1. Attempt to achieve the O(1) lookup time of the native Map and Set types (for String and Number values).
	 * 2. Support iterators according to the spec.
	 *
	 * Since we don't want to track iterators (as that would keep them alive indefinitely if iteration is aborted before end),
	 * the EntryStore never re-uses or changes an entry index.
	 * This allows iterators to keep pointing at a specific entry index, and look at the actual situation during the next call.
	 * @class module:barejs/polyfill.EntryStore
	 * @param {*} [_iterable] Optional: an iterable whose values will be added to the EntryStore.
	 * @param {boolean} [_pair] Optional: if the EntryStore is used for a Map, this should be true
	 * (iterable's values should be interpreted as key-value pairs, not as single values).
	 */
	function EntryStore( _iterable, _pair )
	{
	    this.entries = Object.create( null );
	    // Note: skip index 0 so it is safe to use the entry index in boolean expressions.
	    this.entries.start = this.entries.end = 1;

	    this.clear();

	    if ( _iterable )
	    {
	        // Use Array.from for iteration, as it normalizes iterables for us.
	        // Only downside is that we're creating an array that is thrown away
	        Array.from( _iterable, _pair === true ? this._setPair : this._setValue, this );
	    }
	}

	ObjectPolyfill.polyfill( EntryStore, null,
	/** @lends module:barejs/polyfill.EntryStore# */
	{
	    _setPair: function( _value )
	    {
	        if ( typeof _value !== "object" )
	            throw new TypeError( "Iterator value " + String( _value ) + " is not an entry object" );
	        this.set( _value[0], _value[1] );
	    },

	    _setValue: function( _value )
	    {
	        this.set( _value, _value );
	    },

	    /**
	     * Find the next valid index, starting at _start
	     * @param {number} _start The index to start looking at. If _start is in entries, start is returned.
	     * @returns {number} The next valid index, or -1 if there is no next entry.
	     */
	    _nxt: function( _start )
	    {
	        for ( var i = Math.max( _start || 0, this.entries.start ), end = this.entries.end; i < end; ++i )
	            if ( i in this.entries )
	                return i;
	        return -1;
	    },

	    /**
	     * Find the entry index for a key
	     * @param _key The key to get the entry index for
	     * @param _key The key to get the entry index for
	     * @returns {number} The entry index, or -1
	     */
	    indexOf: function( _key )
	    {
	        switch ( typeof _key )
	        {
	            case "string":
	                return this._stringKeys[ _key ] || -1;
	            case "number":
	                return this._numberKeys[ String( _key ) ] || -1;
	            default:
	                return this._otherKeyIds[ this._otherKeys.indexOf( _key ) ] || -1;
	        }
	    },

	    /**
	     * Set the entry for a key
	     * @param {*} _key The key for the value.
	     * @param {*} _value The value to set.
	     */
	    "set": function( _key, _value )
	    {
	        var idx = this.indexOf( _key );

	        if ( idx < 0 )
	        {
	            idx = this.entries.end++;
	            ++this.size;

	            switch ( typeof _key )
	            {
	                case "string":
	                    this._stringKeys[ _key ] = idx;
	                    break;

	                case "number":
	                    this._numberKeys[ String( _key ) ] = idx;
	                    break;

	                default:
	                    this._otherKeys.push( _key );
	                    this._otherKeyIds.push( idx );
	                    break;
	            }

	            this.entries[idx] = [_key, _value];
	        }
	        else
	        {
	            this.entries[idx][1] = _value;
	        }
	    },

	    /**
	     * Remove _key from the EntryStore
	     * @param {*} _key The key to remove the value for
	     * @returns {boolean} True if the value for _key got removed, false otherwise.
	     */
	    remove: function( _key )
	    {
	        var idx;

	        switch ( typeof _key )
	        {
	            case "string":
	                if ( ( idx = this._stringKeys[ _key ] || -1 ) >= 0 )
	                    delete this._stringKeys[ _key ];
	                break;

	            case "number":
	                if ( ( idx = this._numberKeys[ String( _key ) ] || -1 ) >= 0 )
	                    delete this._numberKeys[ String( _key ) ];
	                break;

	            default:
	                if ( ( idx = this._otherKeys.indexOf( _key ) ) >= 0 )
	                {
	                    // Remove key
	                    this._otherKeys.splice( idx, 1 );
	                    // Remove index mapping, and update idx to the entry index
	                    idx = this._otherKeyIds.splice( idx, 1 )[0];
	                }
	                break;
	        }

	        var remove = idx >= 0;
	        if ( remove )
	        {
	            // We already moved the key mapping, but we still need to drop the entry
	            // (and potentially update the start value)
	            delete this.entries[idx];
	            --this.size;
	            if ( idx === this.entries.start )
	            {
	                // If we removed the "start" value, update it
	                idx = this._nxt( idx + 1 );
	                this.entries.start = idx < 0 ? this.entries.end : idx;
	            }
	        }

	        return remove;
	    },

	    /**
	     * Clear the EntryStore, removing all keys and associated values.
	     */
	    clear: function()
	    {
	        this._numberKeys = Object.create( null );
	        this._stringKeys = Object.create( null );
	        this._otherKeys = [];
	        this._otherKeyIds = [];

	        this.size = 0;

	        // drop all entries
	        for ( var i = this.entries.start, end = this.entries.end; i < end; ++i )
	            delete this.entries[i];
	        // Update start to end
	        this.entries.start = this.entries.end;
	    },

	    /**
	     * Iterate the EntryStore (on behalf of _iterated)
	     * @param {module:barejs/polyfill.EntryStore} _iterated The object to report as being iterated.
	     * Since the EntryStore is an internal object to be used by a Set or Map it has to report the correct object.
	     * @param {function} Callback: the iterator callback to call for every entry. Called with ( &lt;key&gt;, &lt;value&gt;, _iterated ).
	     * @param {object} [_thisArg] Optional: object to use as context for the callback function
	     */
	    forEach: function( _iterated, _callback, _thisArg )
	    {
	        // Do NOT cache end, adding entries during iteration is allowed
	        for ( var o = ObjectPolyfill.ensureCallable( _callback, _thisArg && Object( _thisArg ) ), i = this._nxt(), entry; i >= 0; i = this._nxt( i + 1 ) )
	        {
	            entry = this.entries[i];
	            _callback.call( o, entry[1], entry[0], _iterated );
	        }
	    }
	}, null, "EntryStore" );

	// This is NOT the native Iterator...
	//jshint -W121

	/**
	 * @class module:barejs/polyfill.EntryStore.Iterator
	 * @classdesc Base class Iterator for a class using the EntryStore
	 */
	function Iterator( _kind, _store )
	{
	    this._kind = _kind;
	    this._next = _store._nxt();
	    if ( this._next >= 0 )
	        this._store = _store;
	}

	ObjectPolyfill.polyfill( Iterator, null,
	/** @lends module:barejs/polyfill.EntryStore.Iterator# */
	{
	    /**
	     * Get the next value
	     * @returns {object} An object containing a done and value property.
	     */
	    next: function next()
	    {
	        var entry, // Note: entry is used to get an undefined value (minification optimisation)
	            result = { value: entry, done: this._next < 0 };

	        if ( !result.done )
	        {
	            var store = this._store,
	                // use _nxt to check if there is still an entry at _next
	                next = this._next = store._nxt( this._next );

	            // If we're done iterating, remove the reference to _store
	            if ( next < 0 )
	            {
	                // All entries at next (and possibly afterwards) got removed, mark the iterator done
	                result.done = true;
	                // Clear link to _store since we don't need it anymore
	                this._store = null;
	            }
	            else
	            {
	                entry = store.entries[next];
	                switch ( this._kind )
	                {
	                    case "key":
	                        result.value = entry[0];
	                        break;
	                    case "value":
	                        result.value = entry[1];
	                        break;
	                    default:
	                        // Don't expose our inner array, make a copy
	                        result.value = entry.slice( 0, 2 );
	                        break;
	                }
	                this._next = store._nxt( next + 1 );
	            }
	        }

	        return result;
	    }
	}, null, "Iterator" );

	ObjectPolyfill.defineProperty( EntryStore, "Iterator", { value: Iterator } );

	ObjectPolyfill.setIterator( Iterator.prototype, /*istanbul ignore next*/ function()
	{
	    //jshint validthis:true
	    return this;
	} );

	return EntryStore;

	}( __webpack_require__( 2 ) ) );


/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global Set*/

	module.exports = ( (6) >= 6 ) || ( typeof Set !== "undefined" ) ? Set : /*istanbul ignore next*/ __webpack_require__( 7 );


/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, EntryStore )
	{
	"use strict";
	// Putting this in a var allows uglify to minify the code much more
	var SET_SIZE = !( ( (6) >= 5 ) || ObjectPolyfill.propertyGetSetSupport );

	/**
	 * @classdesc Iterator for the Set polyfill.
	 * @class module:barejs/polyfill.Set~SetIterator
	 * @extends module:barejs/polyfill.EntryStore.Iterator
	 */
	function SetIterator( _kind, _store )
	{
	    EntryStore.Iterator.call( this, _kind, _store );
	}

	SetIterator.prototype = Object.create( EntryStore.Iterator.prototype,
	/** @lends module:barejs/polyfill.Set~SetIterator# */
	{
	    constructor: { writable : true, value : SetIterator }
	} );

	/**
	 * @classdesc Mimics the implementation of a native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set Set}.
	 * Has an O(n) lookup time for non String or Number keys, so cannot compete with a native Map (Which is supposed to have an O(1) lookup time).
	 * @class module:barejs/polyfill.Set
	 */
	function Set()
	{
	    ObjectPolyfill.defineProperty( this, "_store", { value: new EntryStore( arguments[0], false ) }  );

	    /*istanbul ignore if: NodeJS has property support*/
	    if ( SET_SIZE )
	        this.size = this._store.size;
	}

	ObjectPolyfill.defineProperties( Set.prototype,
	/** @lends module:barejs/polyfill.Set# */
	{
	    _store: { value: null },

	    /**
	     * The size of the Set, which represents the number of entries currently in the Map.
	     * @member {number}
	     * @readonly
	     */
	    size: ( SET_SIZE ?
	        /*istanbul ignore next*/ { writable: true, value: null } :
	        { "get": function size(){ return this._store && this._store.size; } } ),

	    /**
	     * Adds a value to a Set object.
	     * @function
	     * @param _value The value to add.
	     * @returns {module:barejs/polyfill.Set} The Set (for chaining)
	     */
	    add: { value: function add( _value )
	    {
	        this._store.set( _value, _value );

	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;

	        return this;
	    } },

	    /**
	     * Check if the Set has a specified value.
	     * @function
	     * @param {object} _value The value to check for.
	     * @returns {boolean} True if there is an entry for the value, false otherwise
	     */
	    has: { value: function has( _value )
	    {
	        return this._store.indexOf( _value ) >= 0;
	    } },

	    /**
	     * Remove a value from the Set
	     * @function
	     * @param {object} _value The value to remove.
	     * @returns {boolean} True if the value was deleted, false otherwise.
	     */
	    "delete": { value: function _delete( _value )
	    {
	        var removed = this._store.remove( _value );

	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;

	        return removed;
	    } },

	    /**
	     * Clear the Set.
	     * @function
	     */
	    clear: { value: function clear()
	    {
	        this._store.clear();

	        /*istanbul ignore if: NodeJS has property support*/
	        if ( SET_SIZE )
	            this.size = this._store.size;
	    } },

	    /**
	     * Iterate the Set
	     * @function
	     * @param {function} _callback The callback function.
	     * @param [_thisArg] Optional: context to call the callback in.
	     */
	    forEach: { value: function forEach( _callback/*, _thisArg*/ )
	    {
	        this._store.forEach( this, _callback, arguments[1] );
	    } },

	    /**
	     * Get a key iterator
	     * @function
	     * @returns {module:barejs/polyfill.Set~SetIterator} A key iterator
	     */
	    keys: { value: function keys()
	    {
	        return new SetIterator( "key", this._store );
	    } },

	    /**
	     * Get a value iterator
	     * @function
	     * @returns {module:barejs/polyfill.Set~SetIterator} A value iterator
	     */
	    values: { value: function values()
	    {
	        return new SetIterator( "value", this._store );
	    } },

	    /**
	     * Get an entry iterator
	     * @function
	     * @returns {module:barejs/polyfill.Set~SetIterator} A entry iterator
	     */
	    entries: { value: function entries()
	    {
	        return new SetIterator( "entry", this._store );
	    } }
	} );

	ObjectPolyfill.setIterator( Set.prototype, Set.prototype.values );

	return Set;

	}( __webpack_require__( 2 ), __webpack_require__( 5 ) ) );


/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global Symbol*/

	module.exports = ( (6) >= 6 ) || ( typeof Symbol !== "undefined" ) ? Symbol : /*istanbul ignore next*/ __webpack_require__( 9 );


/***/ }),
/* 9 */
/***/ (function(module, exports) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function()
	{
	"use strict";
	var next = 0;

	/**
	 * Create a "{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol Symbol}" which is
	 * actually just a string (so it works "like" a Symbol in older environments).
	 * Symbol is never used with new, it is meant to be invoked as a creator function:
	 *
	 *      var key = Symbol( "description" );
	 *      var obj = {};
	 *      obj[key] = "value";
	 *
	 * @class module:barejs/polyfill.Symbol
	 * @throws {TypeError} Throws a TypeError if used as a constructor (with new).
	 * @param {string} [_description] Optional: a description of the Symbol that will provide a hint of what the
	 * Symbol is for. Only for debug, does not affect the actual Symbol in any way.
	 */
	return function Symbol( _description )
	{
	    if ( this instanceof Symbol )
	        throw new TypeError( "Symbol is not a constructor" );

	    return "__" + ( ++next ) + "\x01Symbol(" + ( _description || "" ) + ")";
	};

	}() );


/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global WeakMap*/

	module.exports = ( (6) >= 6 ) || ( typeof WeakMap !== "undefined" ) ? WeakMap : /*istanbul ignore next*/ __webpack_require__( 11 );


/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, Symbol )
	{
	"use strict";

	// The property set by the first keymap that takes an object as key.
	// All WeakMaps look at the same property
	var KEY_PROP = Symbol( "WeakMap" );
	var hOP = Object.prototype.hasOwnProperty;
	var nextId = 0;

	/**
	 * Mimics the implementation of a native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap WeakMap}.
	 * The only way to achieve this is by putting a property on the key object.
	 * @class module:barejs/polyfill.WeakMap
	 * @param {any} [_iterable=null] Optional: an iterable whose values will be added to the WeakSet.
	 */
	function WeakMap( _iterable )
	{
	    // Ensure map has no prototype chain (so we can safely use the in operator instead of hasOwnProperty)
	    ObjectPolyfill.defineProperty( this, "_map", { value: Object.create( null ) } );

	    if ( _iterable )
	    {
	        for ( var i = 0; i < _iterable.length; ++i )
	            this.set( _iterable[i][0], _iterable[i][1] );
	    }
	}

	return ( ObjectPolyfill.defineProperties( WeakMap.prototype,
	/** @lends module:barejs/polyfill.WeakMap# */
	{
	    _map: { value: null },

	    /**
	     * Adds a new element with a specified key and value to a WeakMap object.
	     * @function
	     * @param {object} _key The object to use as key.
	     * @param _value The value to add.
	     * @returns {module:barejs/polyfill.WeakMap} The WeakMap (for chaining)
	     */
	    "set": { value: function set( _key, _value )
	    {
	        if ( !ObjectPolyfill.isObject( _key ) )
	            throw new TypeError( "Invalid value used as weak map key" );

	        if ( !hOP.call( _key, KEY_PROP ) )
	            ObjectPolyfill.defineProperty( _key, KEY_PROP, { value: ++nextId } );

	        this._map[ _key[KEY_PROP] ] = _value;
	        return this;
	    } },

	    /**
	     * Get the value for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns The value, or undefined if the key is not known.
	     */
	    "get": { value: function get( _key )
	    {
	        return this.has( _key ) ? this._map[ _key[KEY_PROP] ] : undefined;
	    } },

	    /**
	     * Check if the WeakMap has an entry for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns {boolean} True if there is an entry for the key, false otherwise
	     */
	    has: { value: function has( _key )
	    {
	        // If there is no WeakMap key property on the object, it has never been used as key for a WeakMap
	        return ObjectPolyfill.isObject( _key ) && hOP.call( _key, KEY_PROP ) && ( _key[KEY_PROP] in this._map );
	    } },

	    /**
	     * Remove the value for the specified key
	     * @function
	     * @param {object} _key The object to use as key.
	     * @returns {boolean} True if the entry was deleted, false otherwise
	     */
	    "delete": { value: function _delete( _key )
	    {
	        // Remove the entry from our map (will be a NOOP if there is no property for the key value)
	        // Note: delete is not called if this.has( _key ) returns false. If the delete statement
	        // (incorrectly) returns false, we force it to return true using "|| true".
	        return this.has( _key ) && ( ( delete this._map[_key[KEY_PROP]] ) || true );
	    } }
	} ), WeakMap );

	}( __webpack_require__( 2 ), __webpack_require__( 8 ) ) );


/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015, 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Array, ObjectPolyfill, NMap, NSet )
	{
	"use strict";

	// This module uses bitwise operators to enforce unsigned ints or perform other optimizations.
	/*jshint bitwise:false*/

	var toObject = ObjectPolyfill.toObject,
	    isCallable = ObjectPolyfill.isCallable,
	    ensureCallable = ObjectPolyfill.ensureCallable;
	// Store reference to Object.prototype.toString for convenience and to (hopefully) grab the original before modification.
	var toString = Object.prototype.toString;

	/** @lends module:barejs/polyfill.Array */
	var stat = {},
	/** @lends module:barejs/polyfill.Array# */
	    proto = {};


	/**
	 * Method that performs the actual iteration
	 * @memberof module:barejs/polyfill.Array~
	 * @private
	 */
	function iterate( _arrayLike, _callback, _thisArg, _logic )
	{
	    var asString = ( "charAt" in _arrayLike ) && ( "substr" in _arrayLike );
	    for ( var i = 0, len = _arrayLike.length >>> 0, value, result; i < len; ++i )
	    {
	        if ( asString || ( i in _arrayLike ) )
	        {
	            result = _callback.call( _thisArg, value = asString ? _arrayLike.charAt( i ) : _arrayLike[i], i, _arrayLike );
	            if ( _logic( value, i, result ) === true )
	                break;
	        }
	    }
	}

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array Array}.
	 * @class module:barejs/polyfill.Array
	 */

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 5 )
	{
	    /**
	     * Enumerate all values in the array
	     * @this {Array}
	     * @param {function} _callback The callback to call for each value
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     */
	    proto.forEach = function forEach( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        iterate( toObject( this, forEach ), ensureCallable( _callback ), arguments[1], function() {/*no logic*/} );
	    };

	    /**
	     * Check if callback returns true for every element
	     * @this {Array}
	     * @param {function} _callback The callback to test each value
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns {boolean} True if the callback returns true for each element, false otherwise.
	     */
	    proto.every = function every( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var result = true;
	        iterate( toObject( this, every ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            // If the callback returned a falsey value
	            if ( !_r )
	            {
	                // The every statement doesn't hold true
	                result = false;
	                // Break execution
	                return true;
	            }
	        } );
	        return result;
	    };

	    /**
	     * Check if callback returns true for any element
	     * @this {Array}
	     * @param {function} _callback The callback to test each value
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns {boolean} True if the callback returns true for at least one element, false otherwise.
	     */
	    proto.some = function some( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var result = false;
	        iterate( toObject( this, some ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            // If the callback returned a thruthy value, the some statement is true (shortcuted to return true for breaking)
	            if ( _r )
	                return ( result = true );
	        } );
	        return result;
	    };

	    /**
	     * Creates a new array with only the elements matching the provided function.
	     * @this {Array}
	     * @param {function} _callback The callback to test each value.
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns {Array} A new array containing the result of callback per element.
	     */
	    proto.filter = function filter( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var result = [];
	        iterate( toObject( this, filter ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            // If the callback returned a thruthy value, add the value to the result
	            if ( _r )
	                result.push( _v );
	        } );
	        return result;
	    };

	    /**
	     * Creates a new array with the results of calling a provided function on every element in this array.
	     * @this {Array}
	     * @param {function} _callback The callback to test each value
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns {Array} A new array containing the result of callback per element.
	     */
	    proto.map = function map( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var o = toObject( this, map ), result = new Array( o.length >>> 0 );
	        iterate( o, ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            result[_i] = _r;
	        } );
	        return result;
	    };

	    /**
	     * Returns the first index at which a given element can be found in the array, or -1 if it is not present.
	     * @this {Array}
	     * @param {object} _searchElement Element to locate in the array.
	     * @param {number} [_fromIndex=0] Optional: The index to start the search at. Default: 0
	     *      If the index is greater than or equal to the array's length, -1 is returned, which means
	     *      the array will not be searched. If the provided index value is a negative number, it is
	     *      taken as the offset from the end of the array. Note: if the provided index is negative,
	     *      the array is still searched from front to back. If the calculated index is less than 0,
	     *      then the whole array will be searched.
	     * @returns {number} The first index at which a given element can be found in the array, or -1 if it is not present.
	     */
	    proto.indexOf = function indexOf( _searchElement/*, _fromIndex*/ )
	    {
	        var t = toObject( this, indexOf ), len = t.length >>> 0, i = 0;

	        if ( len < 1 )
	            return -1;

	        if ( arguments.length >= 2 )
	        {
	            if ( ( i = arguments[1] >> 0 ) < 0 )
	                i = Math.max( 0, len + i );
	        }

	        for ( ; i < len; ++i )
	            if ( ( i in t ) && ( t[i] === _searchElement ) )
	                return i;

	        return -1;
	    };

	    /**
	     * Returns the last index at which a given element can be found in the array, or -1 if it is not present.
	     * The array is searched backwards, starting at fromIndex.
	     * @this {Array}
	     * @param {object} _searchElement Element to locate in the array.
	     * @param {number} [_fromIndex=-1] Optional: The index at which to start searching backwards.
	     *      Defaults to the array's length - 1, i.e. the whole array will be searched. If the index is
	     *      greater than or equal to the length of the array, the whole array will be searched.
	     *      If negative, it is taken as the offset from the end of the array. Note that even when
	     *      the index is negative, the array is still searched from back to front. If the calculated
	     *      index is less than 0, -1 is returned, i.e. the array will not be searched.
	     * @returns {number} The last index at which a given element can be found in the array, or -1 if it is not present.
	     */
	    proto.lastIndexOf = function lastIndexOf( _searchElement/*, _fromIndex*/ )
	    {
	        var t = toObject( this, lastIndexOf ), len = t.length >>> 0, i = len - 1;

	        if ( len < 1 )
	            return -1;

	        if ( arguments.length >= 2 )
	        {
	            if ( ( i = Math.min( i, arguments[1] >> 0 ) ) < 0 )
	                i += len;
	        }

	        for ( ; i >= 0; --i )
	            if ( ( i in this ) && ( this[i] === _searchElement ) )
	                return i;

	        return -1;
	    };

	    /**
	     * The reduce() method applies a function against an accumulator and each value of the
	     * array (from left-to-right) has to reduce it to a single value.
	     * @this {Array}
	     * @param {function} _callback The callback to call for each value, taking 4 arguments:
	     *              previousValue
	     *                  The value previously returned in the last invocation of the callback, or initialValue, if supplied. (See below.)
	     *              currentValue
	     *                  The current element being processed in the array.
	     *              index
	     *                  The index of the current element being processed in the array.
	     *              array
	     *                  The array reduce was called upon.
	     * @param {object} [_initialValue] Optional: a value to pass to the first callback.
	     */
	    proto.reduce = function reduce( _callback/*, _initialValue*/ )
	    {
	        var t = toObject( this, reduce ), len = t.length >>> 0, i = ensureCallable( _callback, 0 ), value;

	        if ( arguments.length >= 2 )
	        {
	            value = arguments[1];
	        }
	        else
	        {
	            while ( ( i < len ) && !( i in t ) )
	                ++i;

	            if ( i >= len )
	                throw new TypeError( "Reduce of empty array with no initial value" );
	            value = t[i++];
	        }
	        for (; i < len; ++i)
	        {
	            if ( i in t )
	                value = _callback( value, t[i], i, t );
	        }
	        return value;
	    };

	    /**
	     * The reduceRight() method applies a function against an accumulator and each value of the
	     * array (from right-to-left) has to reduce it to a single value.
	     * @this {Array}
	     * @param {function} _callback The callback to call for each value, taking 4 arguments:
	     *              previousValue
	     *                  The value previously returned in the last invocation of the callback, or initialValue, if supplied. (See below.)
	     *              currentValue
	     *                  The current element being processed in the array.
	     *              index
	     *                  The index of the current element being processed in the array.
	     *              array
	     *                  The array reduce was called upon.
	     * @param {object} [_initialValue] Optional: a value to pass to the first callback.
	     */
	    proto.reduceRight = function reduceRight( _callback/*, _initialValue*/ )
	    {
	        var t = toObject( this, reduceRight ), len = t.length >>> 0, i = ensureCallable( _callback, len - 1 ), value;

	        if ( arguments.length >= 2 )
	        {
	            value = arguments[1];
	        }
	        else
	        {
	            while ( ( i >= 0 ) && !( i in t ) )
	                --i;

	            if ( i < 0 )
	                throw new TypeError( "Reduce of empty array with no initial value" );
	            value = t[i--];
	        }
	        for (; i >= 0; --i)
	        {
	            if ( i in t )
	                value = _callback( value, t[i], i, t );
	        }
	        return value;
	    };

	    /**
	     * Check if an object is an array.
	     * @param _arg The object to check.
	     * @returns {boolean} true if an object is an array, false if it is not.
	     */
	    stat.isArray = function isArray( _arg )
	    {
	        return toString.call( _arg ) === "[object Array]";
	    };
	// End of ES5 polyfill scope
	}

	/*istanbul ignore else: We test with __ES__ set to 3 */
	if ( (6) < 6 )
	{
	    /**
	     * Find a value in the array
	     * @param {function} _callback The callback to test each value in the array. If the value matches, it should return true.
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns the found value or undefined if not found.
	     */
	    proto.find = function find( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var result = void undefined;
	        iterate( toObject( this, find ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            // If the callback returned a thruthy value, the result is found
	            if ( _r )
	            {
	                result = _v;
	                // Break the loop
	                return true;
	            }
	        } );
	        return result;
	    };

	    /**
	     * Find a value in the array
	     * @param {function} _callback The callback to test each value in the array. If the value matches, it should return true.
	     * @param {object} [_thisArg] Optional: the context in which the callback should be invoked
	     * @returns {number} the found index or -1 if not found.
	     */
	    proto.findIndex = function findIndex( _callback/*, _thisArg (method has length 1)*/ )
	    {
	        var result = -1;
	        iterate( toObject( this, findIndex ), ensureCallable( _callback ), arguments[1], function( _v, _i, _r )
	        {
	            // If the callback returned a thruthy value, the result is found
	            if ( _r )
	            {
	                result = _i;
	                // Break the loop
	                return true;
	            }
	        } );
	        return result;
	    };

	    /**
	     * The fill() method fills all the elements of an array from a start index to an end index with a static value.
	     * @param _value The value to set to each index
	     * @param {number} [_start=0] Optional: the index to start filling (inclusive)
	     * If _start is negative, it is treated as length + _start.
	     * @param {number} [_end] Optional: the index at which to stop filling (exclusive)
	     * If _end is negative, it is treated as length + _end.
	     */
	    proto.fill = function fill( _value/*, _start, _end*/ )
	    {
	        var t = toObject( this, fill ), len = t.length >>> 0, i = arguments[1] >> 0, end = arguments[2];

	        if ( i < 0 )
	            i = Math.max( 0, i + len );
	        if ( end === undefined )
	            end = len;
	        else if ( end < 0 )
	            end = Math.max( 0, end + len );

	        for ( ; i < end; ++i )
	            t[i] = _value;

	        return t;
	    };

	    /**
	     * The Array.of() method creates a new Array instance with a variable number of arguments,
	     * regardless of number or type of the arguments.
	     * @param {...any} _value Any number of values that will be the content of the array.
	     * @returns {Array} The created Array.
	     */
	    stat.of = function of()
	    {
	        var C = this;
	        var args = arguments;
	        var len = args.length;
	        var result = isCallable( C ) ? Object( new C( len ) ) : new Array( len );
	        for ( var  i = 0; i < len; ++i )
	            result[i] = args[i];
	        return result;
	    };

	    /**
	     * The Array.from() method creates a new Array instance from an array-like or iterable object.
	     * @param {object} _arrayLike An array-like or iterable object to convert to an array.
	     * @param {function} [_mapFn] Optional. Map function to call on every element of the array.
	     * @param {object} [_thisArg] Optional. Value to use as this when executing mapFn.
	     * @returns {Array} The created Array.
	     */
	    stat.from = function from( _arrayLike/*, _mapFn, _thisArg*/ )
	    {
	        var C = this;
	        var items = toObject( _arrayLike );
	        var mapFn = typeof arguments[1] !== "undefined" ? ensureCallable( arguments[1] ) : null;
	        var thisArg = arguments[2];
	        // Iterators can't be emulated, but add specific logic for Map and Set so those are supported
	        // Note: check both for a potential global and the polyfill separately:
	        // NMap and Map MAY point to the same function, but don't have to in every environment (!).
	        var isMap = items instanceof NMap;
	        // Normalize to an Array, source. Chances are high we can just return this Array, or map it in place.
	        var source;
	        var i, len;

	        if ( mapFn )
	        {
	            if ( thisArg === undefined )
	                thisArg = null;
	            else if ( thisArg !== null )
	                thisArg = Object( thisArg );
	        }

	        var it = isCallable( items.next ) ? items : ObjectPolyfill.getIterator( items );
	        if ( it )
	        {
	            source = [];
	            for ( var cur = it.next(); !cur.done; cur = it.next() )
	                source.push( cur.value );
	            len = source.length;
	        }
	        // IE11's native map and set support forEach, but not iterators. Emulate using forEach.
	        else if ( ( isMap || ( items instanceof NSet ) ) && isCallable( items.forEach ) )
	        {
	            i = 0;
	            len = Math.floor( items.size ) || 0;
	            source = new Array( len );
	            items.forEach( function( _value, _key )
	            {
	                var entry;
	                if ( isMap )
	                {
	                    entry = new Array( 2 );
	                    entry[0] = _key;
	                    entry[1] = _value;
	                }
	                else
	                {
	                    entry = _value;
	                }
	                source[ i++ ] = entry;
	            } );
	        }
	        if ( !source )
	        {
	            var asString = ( "charAt" in items ) && ( "substr" in items );
	            len = Math.floor( items.length ) || 0;
	            source = new Array( len );

	            for ( i = 0; i < len; ++i )
	                source[i] = asString ? items.charAt( i ) : items[i];
	        }

	        // We already have an Array (source), only create a new Object if we have a Constructor as context
	        var result = isCallable( C ) && C !== Array ? Object( new C( len ) ) : source;

	        if ( mapFn || result !== source )
	        {
	            for ( i = 0; i < len; ++i )
	                result[i] = mapFn ? mapFn.call( thisArg, source[i], i ) : source[i];
	        }

	        return result;
	    };
	// End of ES6 polyfill scope
	}

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 7 )
	{
	    /**
	     * The includes() method determines whether an array includes a certain element, returning true or false as appropriate.
	     * The array is searched forwards, starting at fromIndex (defaults to 0).
	     * @param {object} _searchElement Element to locate in the array.
	     * @param {object} [_fromIndex=0] Optional: The index to start the search at. Default: 0
	     *      If the index is greater than or equal to the array's length, -1 is returned, which means
	     *      the array will not be searched. If the provided index value is a negative number, it is
	     *      taken as the offset from the end of the array. Note: if the provided index is negative,
	     *      the array is still searched from front to back. If the calculated index is less than 0,
	     *      then the whole array will be searched.
	     * @returns {boolean} True if the element was found, false otherwise.
	     */
	    proto.includes = function includes( _searchElement/*, _fromIndex*/ )
	    {
	        var t = toObject( this, includes ), len = t.length >>> 0, i = 0;

	        if ( len < 1 )
	            return false;

	        if ( arguments.length > 1 )
	        {
	            if ( ( i = arguments[1] >> 0 ) < 0 )
	                i = Math.max( 0, len + i );
	        }

	        for ( ; i < len; ++i )
	            if ( ( t[i] === _searchElement ) || ( _searchElement !== _searchElement && t[i] !== t[i] ) )
	                return true;

	        return false;
	    };
	// End of ES7 polyfill scope
	}

	ObjectPolyfill.polyfill( Array, stat, proto, exports, "Array" );

	// End of module
	}( Array, __webpack_require__( 2 ), __webpack_require__( 3 ), __webpack_require__( 6 ) ) );


/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015, 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function(
	        ObjectPolyfill,
	        decl,
	        WeakMap,
	        WeakSet
	    )
	{
	"use strict";

	/*jshint latedef:false*/

	var DestroyableKey = null;

	// Try to use an ES6 symbol and be very protective of the destroyed flag.
	var DestroyedObjects = new WeakSet();

	// grab Array.prototype.map
	var map = Array.prototype.map;

	/**
	 * Takes a _target and attempts to resolve it to a Destroyable, even if it is an interface proxy.
	 * @memberof module:barejs.Destroyable~
	 * @private
	 */
	function resolveTarget( _target )
	{
	    return decl.isProxy( _target ) && _target.is( Destroyable ) ? _target.as( DestroyableKey ) : Object( _target );
	}

	/**
	 * Check if _target is destroyed.
	 * @param {module:barejs.Destroyable~Destroyable} _target The destroyable to check
	 * @returns {boolean} True if the target has been destroyed, false otherwise.
	 * @memberof module:barejs.Destroyable
	 */
	function isDestroyed( _target )
	{
	    return !!_target && DestroyedObjects.has( resolveTarget( _target ) );
	}

	/**
	 * @class module:barejs.Destroyable~MetaData
	 * @private
	 */
	function MetaData()
	{
	    this.listeners = [];
	    this.references = [];
	    this.referenceHandlers = [];
	}

	decl.declareClass( MetaData,
	/** @lends module:barejs.Destroyable~MetaData */
	{
	    listeners: null,
	    references: null,
	    referenceHandlers: null
	} );

	/**
	 * Anonymous function closure to keep the WeakMap protected. By using a WeakMap MetaData objects
	 * have no explicit link back to the Destroyable objects.
	 * @param {WeakMap} _map WeakMap to store the MetaData objects in.
	 * @ignore
	 */
	( function( _map )
	{
	    /**
	     * Get MetaData for a Destroyable
	     * @param {module:barejs.Destroyable} _destroyable The Destroyable instance
	     * @param {boolean} _create Set to true to create the metadata if it doesn't exist.
	     * @returns {module:barejs.Destroyable~MetaData} The meta data, or null (if create is false and there is none)
	     */
	    MetaData.get = function( _destroyable, _create )
	    {
	        var meta = _map.get( _destroyable ) || null;

	        if ( ( !meta ) && ( _create === true ) )
	            _map.set( _destroyable, meta = new MetaData() );

	        return meta;
	    };

	    /**
	     * Remove MetaData for a Destroyable.
	     * @param {module:barejs.Destroyable} _destroyable The Destroyable instance
	     * @returns {module:barejs.Destroyable~MetaData} The removed meta data, or null
	     */
	    MetaData.remove = function( _destroyable )
	    {
	        var meta = _map.get( _destroyable ) || null;

	        if ( meta )
	            _map["delete"]( _destroyable );

	        return meta;
	    };
	}( new WeakMap() ) );

	/**
	 * function that can be applied to an array to remove an item
	 * @this {Array}
	 * @memberof module:barejs.Destroyable~
	 * @private
	 */
	function Array_remove( _item )
	{
	    /*jshint validthis:true*/
	    var idx = this.indexOf( _item );
	    /*istanbul ignore else: the if statement is purely a sanity check*/
	    if ( idx >= 0 )
	        this.splice( idx, 1 );
	    return idx >= 0;
	}

	/**
	 * Helper function that will destroy _target, if it is not null/undefined.
	 * @param {module:barejs.Destroyable} _target The target to destroy.
	 * @memberof module:barejs.Destroyable~
	 * @private
	 */
	function destroyTarget( _target/*, _index*/ )
	{
	    if ( !_target )
	        return;

	    _target = Object( _target );

	    if ( "destroy" in _target )
	        _target.destroy();
	    // Compatibility with dojo handles
	    else if ( "remove" in _target )
	        _target.remove();
	}

	/**
	 * @class module:barejs.Destroyable~OwnedHandle
	 * @private
	 * @classdesc Tracks an ownership and destroys links when needed
	 */
	function OwnedHandle( _owner, _target )
	{
	    this.owner = _owner;
	    this.target = _target;

	    _owner.addDestroyListener( this._owner_destroyed = this._owner_destroyed.bind( this ) );

	    if ( this.target instanceof Destroyable )
	        this.target.addDestroyListener( this._target_destroyed = this._target_destroyed.bind( this ) );
	}

	decl.declareClass( OwnedHandle,
	/** @lends module:barejs.Destroyable~OwnedHandle# */
	{
	    owner: null,
	    target: null,

	    _owner_destroyed: function()
	    {
	        /*istanbul ignore next: We actively remove listeners on destroy, so we don't expect to hit this safety guard*/
	        if ( !this.target )
	            return;

	        // Destroyable::ref will take care of deleting any reference to this object

	        // By deleting the owner before calling destroy, we are sure _target_destroyed will not
	        // perform any logic
	        delete this.owner;
	        // We are about to call destroy, so there's no point in getting the notification
	        if ( this.target instanceof Destroyable )
	            this.target.removeDestroyListener( this._target_destroyed );

	        destroyTarget( this.target );

	        delete this._owner_destroyed;
	        delete this._target_destroyed;
	        delete this.target;
	    },

	    _target_destroyed: function()
	    {
	        /*istanbul ignore next: We actively remove listeners on destroy, so we don't expect to hit this safety guard*/
	        if ( !this.owner )
	            return;

	        this.owner.removeDestroyListener( this._owner_destroyed );

	        delete this._owner_destroyed;
	        delete this._target_destroyed;
	        delete this.owner;
	        delete this.target;
	    }
	} );


	/**
	 * @class module:barejs.Destroyable
	 * @classdesc Class that adds lifetime management to JavaScript objects. Destroyable provides a few features to ensure
	 * the JavaScript garbage collector can recollect memory as soon as possible.
	 *
	 * A Destroyable instance can own other objects. The ownership in this case implies: if this instance is destroyed,
	 * the instance I own should also be destroyed. Destroyable can own any object having either a destroy or remove method.
	 *
	 * A Destroyable instance can also ref other objects. The reference is automatically cleared on destroy. If the ref-ed
	 * object is a Destroyable, the reference is also cleared if the target gets destroyed.
	 *
	 * Owned objects are also destroyed if this Destroyable is destroyed.
	 * Referenced objects are automatically unlinked if this object is destroyed, and even if the referenced
	 * is destroyed (in case the referenced object is Destroyable).
	 */
	function Destroyable()
	{
	    /*istanbul ignore else: We always test in DEBUG*/
	    if ( true )
	        Destroyable.alive.add( this );
	}

	DestroyableKey = decl.preventCast( Destroyable );

	// Protected hidden functions of Destroyable

	/**
	 * Code that actually ties a target to an owner
	 * @param {module:barejs.Destroyable} _target The target to own
	 * @this {module:barejs.Destroyable}
	 * @memberof module:barejs.Destroyable~
	 * @private
	 */
	function __own( _target/*used as iterator callback*/ )
	{
	    // jshint validthis:true

	    var actualTarget = resolveTarget( _target );

	    if ( !actualTarget || !( ( "destroy" in actualTarget ) || ( "remove" in actualTarget ) ) )
	        throw new TypeError( "Cannot own; invalid value" );
	    else if ( actualTarget === this )
	        throw new Error( "An object cannot own itself" );

	    // Note the use of the comma operator; we don't need to store a reference to the OwnedHandle instance,
	    // it just needs to be created. Using the comma operator avoid jshint warnings about using new for side-effects.
	    return new OwnedHandle( this, actualTarget ), _target;
	}

	// Static array to track created Destroyable objects that haven't been destroyed yet
	/*istanbul ignore else: We always test in DEBUG*/
	if ( true )
	    decl.defineProperty( Destroyable, "alive", { value: new WeakSet() } );

	// All methods of Destroyable are non-enumerable and protected from modification
	return decl.declareClass( Destroyable,
	/** @lends module:barejs.Destroyable */
	{
	    // Don't inherit static alive/isDestroyed values
	    $private:
	    {
	        value: function( _key )
	        {
	            return _key === "isDestroyed" || _key === "alive";
	        }
	    },

	    // Protect isDestroyed method from tampering. We're not exposing this on instance level since it's
	    // not a common operation.
	    isDestroyed: { value: isDestroyed }
	},
	/** @lends module:barejs.Destroyable# */
	{
	    /**
	     * Destroy method that will notify registered listeners and clean up references.
	     * @function
	     */
	    destroy:
	    {
	        // Subclasses must be able to add custom destroy logic, so allow writing destroy
	        writable: true,
	        value: function destroy()
	        {
	            if ( isDestroyed( this ) )
	                return;

	            var meta = MetaData.remove( this ), i, len;
	            if ( meta )
	            {
	                // Invoke listeners before clearing references, in case listeners need to look at them
	                if ( meta.listeners.length > 0 )
	                {
	                    for ( i = 0, len = meta.listeners.length; i < len; ++i )
	                        meta.listeners[i]( this );
	                    // Also explicitly clear the array to drop references to listeners
	                    meta.listeners.length = 0;
	                }
	                // Clear references
	                if ( meta.references.length > 0 )
	                {
	                    // Don't call unref since it will mutate the references array
	                    for ( i = 0, len = meta.references.length; i < len; ++i )
	                    {
	                        if ( meta.referenceHandlers[i] )
	                            resolveTarget( this[ meta.references[i] ] ).removeDestroyListener( meta.referenceHandlers[i] );
	                        delete this[ meta.references[i] ];
	                    }
	                    // Clear the arrays
	                    meta.references.length = 0;
	                    meta.referenceHandlers.length = 0;
	                }
	            }

	            /*istanbul ignore else: We always test in DEBUG*/
	            if ( true )
	                Destroyable.alive["delete"]( this );

	            DestroyedObjects.add( this );
	        }
	    },

	    /**
	     * Register a destroy listener for this Destroyable object.
	     * @function
	     * @param {module:barejs.Destroyable~DestroyListener} _listener The listener function to add.
	     * @returns {function} the listener
	     */
	    addDestroyListener:
	    {
	        value: function addDestroyListener( _listener )
	        {
	            var meta = MetaData.get( this, true );
	            meta.listeners.push( ObjectPolyfill.ensureCallable( _listener ) );

	            return _listener;
	        }
	    },

	    /**
	     * Unregister a destroy listener for this Destroyable object.
	     * @function
	     * @param {module:barejs.Destroyable~DestroyListener} _listener The listener function to remove.
	     */
	    removeDestroyListener:
	    {
	        value: function removeDestroyListener( _listener )
	        {
	            var meta = MetaData.get( this, false );
	            return ( !!meta ) && Array_remove.call( meta.listeners, _listener );
	        }
	    },

	    /**
	     * Own a number of handles. Returns an array of the owned handles.
	     * @function
	     * @returns {Array} The owned handles.
	     */
	    own:
	    {
	        value: function own( /*...*/ )
	        {
	            return map.call( arguments, __own, this );
	        }
	    },

	    /**
	     * Reference a target as a member property that will be unlinked on destroy.
	     * If the referenced target is also Destroyable, the ref is also cleared if the target is destroyed.
	     * @function
	     * @param {string} _name The name to reference.
	     * @param {object} _target The object to assign to the reference.
	     * @returns The value of this[_name].
	     */
	    ref:
	    {
	        value: function ref( _name, _target )
	        {
	            if ( typeof _name !== "string" )
	                throw new TypeError( "Name must be a string" );

	            // typeof null === "object", but we don't want to allow it
	            switch ( _target === null ? "undefined" : typeof _target )
	            {
	                // Functions can create a circular reference via closures (or being bound to this).
	                case "function":
	                // Referencing objects might cause circular references
	                case "object":
	                    // So we allow referencing them
	                    break;

	                case "undefined":
	                    throw new TypeError( "_target cannot be " + _target + ". Use unref to clear a reference." );

	                default:
	                    throw new TypeError( "_target cannot be " + ( typeof _target ) + ". Only objects or functions can be referenced." );
	            }

	            var meta = MetaData.get( this, true ),
	                idx = meta.references.indexOf( _name ),
	                actualTarget;

	            if ( idx < 0 ) // Add reference
	            {
	                idx = meta.references.push( _name ) - 1;
	                meta.referenceHandlers.push( null );
	            }
	            else if ( meta.referenceHandlers[idx] ) // Update/change reference
	            {
	                actualTarget = resolveTarget( this[_name] );
	                if ( actualTarget instanceof Destroyable )
	                    actualTarget.removeDestroyListener( meta.referenceHandlers[idx] );
	                meta.referenceHandlers[idx] = null;
	            }

	            decl.defineProperty( this, _name,
	            {
	                configurable: true,
	                enumerable: ObjectPolyfill.shouldBeEnumerable( _name ),
	                value: _target
	            } );

	            actualTarget = resolveTarget( _target );

	            // If the thing we are referencing is a Destroyable, ensure it is unref-ed if the target gets destroyed.
	            if ( actualTarget instanceof Destroyable )
	                actualTarget.addDestroyListener( meta.referenceHandlers[idx] = this.unref.bind( this, _name ) );

	            return _target;
	        }
	    },

	    /**
	     * Remove a reference (by name). If the name was given to ownMember, the member is NOT
	     * removed from the list of owned targets.
	     * Does NOT destroy the value currently referenced.
	     * @function
	     * @param {string} _name the name to remove the reference to
	     * @param {object|function} [_value] If a value is provided (and is not null), unref will only clear the reference if _value equals whatever is currently ref-ed.
	     */
	    unref:
	    {
	        value: function unref( _name )
	        {
	            if ( typeof _name !== "string" )
	                throw new TypeError( "_name must be a string" );

	            var result/* = undefined*/, value = arguments[1], meta, idx, handler;
	            if ( ( meta = MetaData.get( this, false ) ) && ( ( idx = meta.references.indexOf( _name ) ) >= 0 ) )
	            {
	                result = this[ meta.references[idx] ];
	                // If a second argument is supplied, we validate it equals the value to unref
	                if ( value && !decl.is( result, value ) )
	                {
	                    result = undefined; // value did not match
	                }
	                else
	                {
	                    delete this[ meta.references.splice( idx, 1 )[0] ];
	                    // Since we splice the name, we need to splice the handlers too; otherwise the references and handlers will go out of sync.
	                    // If a "target" is provided, assume we got called as a destroy listener; in that case we don't unregister since we got here from that listener.
	                    if ( ( handler = meta.referenceHandlers.splice( idx, 1 )[0] ) && ( !value ) )
	                        resolveTarget( result ).removeDestroyListener( handler );
	                }
	            }

	            return result;
	        }
	    },

	    /**
	     * The ownMember function combines ref and own into 1 call. The target is owned and then ref-ed as _name.
	     * @function
	     * @param {string} _name The name of the member.
	     * @param {module:barejs.Destroyable} _target The target to own.
	     * @returns The owned _target
	     */
	    ownMember:
	    {
	        value: function ownMember( _name, _target )
	        {
	            // use __own directly since it avoids the overhead of Array.prototype.map
	            // Also, call __own before ref, since it does some stricter validation.
	            return this.ref( _name, __own.call( this, _target ) );
	        }
	    },

	    /**
	     * Utility method that will iterate a collection and destroy all items in it.
	     * @function
	     * @param {object} _collection An object with a forEach method or length property (e.g. an Array).
	     */
	    destroyAll:
	    {
	        value: function destroyAll( _collection )
	        {
	            var c = Object( _collection );

	            if ( "forEach" in c )
	                c.forEach( destroyTarget, null );
	            else if ( "length" in c )
	                Array.prototype.forEach.call( c, destroyTarget, null );
	            else
	                throw new TypeError( "_collection must either have a forEach method or a length property." );
	        }
	    }
	} );

	/**
	 * Destroy listeners are called with one argument; the Destroyed object.
	 * @callback module:barejs.Destroyable~DestroyListener
	 * @param {module:barejs.Destroyable} _destroyed The Destroyable that got destroyed.
	 */

	// End of module
	}(
	    __webpack_require__( 2 ),
	    __webpack_require__( 1 ),
	    __webpack_require__( 10 ),
	    __webpack_require__( 14 )
	) );


/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global WeakSet*/

	module.exports = ( (6) >= 6 ) || ( typeof WeakSet !== "undefined" ) ? WeakSet : /*istanbul ignore next*/ __webpack_require__( 15 );


/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, Symbol )
	{
	"use strict";

	// The property set by the first WeakSet that takes an object as key.
	// All WeakSets look at the same property
	var KEY_PROP = Symbol( "WeakSet" );
	var hOP = Object.prototype.hasOwnProperty;
	var nextId = 0;

	/**
	 * Mimics the implementation of a native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet WeakSet}.
	 * The only way to achieve this is by putting a property on the added value.
	 * @class module:barejs/polyfill.WeakSet
	 * @param {*} [_iterable]: Optional: an iterable whose values will be added to the WeakSet.
	 */
	function WeakSet( _iterable )
	{
	    if ( _iterable )
	    {
	        for ( var i = 0; i < _iterable.length; ++i )
	            this.add( _iterable[i] );
	    }

	    ObjectPolyfill.defineProperty( this, "_values", { value: [] } );
	}

	return ( ObjectPolyfill.defineProperties( WeakSet.prototype,
	/** @lends module:barejs/polyfill.WeakSet# */
	{
	    _values: { value: null },

	    /**
	     * Adds a value to a WeakSet.
	     * @function
	     * @param _value The value to add.
	     * @returns {module:barejs/polyfill.WeakSet} The WeakSet (for chaining)
	     */
	    add: { value: function add( _value )
	    {
	        if ( !ObjectPolyfill.isObject( _value ) )
	            throw new TypeError( "Invalid value used as WeakSet value" );

	        if ( !hOP.call( _value, KEY_PROP ) )
	            ObjectPolyfill.defineProperty( _value, KEY_PROP, { value: ++nextId } );

	        if ( this._values.indexOf( _value[KEY_PROP] ) < 0 )
	            this._values.push( _value[KEY_PROP] );

	        return this;
	    } },

	    /**
	     * Check if the WeakSet has an entry for the specified _value.
	     * @function
	     * @param {object} _value The object to check.
	     * @returns {boolean} True if the WeakSet contains _value, false otherwise.
	     */
	    has: { value: function has( _value )
	    {
	        // If there is no WeakSet key property on the object, it has never been used as key for a WeakSet
	        return ObjectPolyfill.isObject( _value ) && hOP.call( _value, KEY_PROP ) && ( this._values.indexOf( _value[KEY_PROP] ) >= 0 );
	    } },

	    /**
	     * Remove the value from the WeakSet
	     * @function
	     * @param {object} _value The value to remove.
	     * @returns {boolean} True if the value was deleted, false otherwise
	     */
	    "delete": { value: function _delete( _value )
	    {
	        var idx = -1;

	        if ( ObjectPolyfill.isObject( _value ) && hOP.call( _value, KEY_PROP ) )
	            idx = this._values.indexOf( _value[KEY_PROP] );

	        if ( idx < 0 )
	            return false;

	        this._values.splice( idx, 1 );

	        return true;
	    } }
	} ), WeakSet );

	}( __webpack_require__( 2 ), __webpack_require__( 8 ) ) );


/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function(
	        Error,
	        ObjectPolyfill,
	        decl,
	        Destroyable,
	        EventArgs,
	        WeakMap
	    )
	{
	"use strict";

	/*global console*/

	var DEFAULT_ARGS = decl.freeze( new EventArgs() );
	// listenersRef is used by Evented to register and unregister itself.
	var g_listenersRef = new WeakMap();
	// Using a WeakMap prevents circular references and hides the listeners from the object.
	var g_eventHandles = new WeakMap();

	var ensureCallable = ObjectPolyfill.ensureCallable;

	/**
	 * Create a new EventedHandle.
	 * @class module:barejs.Evented~EventedHandle
	 * @classdesc EventedHandle is the handle returned by {@link module:barejs.Evented#on Evented::on} and  {@link module:barejs.Evented#once Evented::once}.
	 */
	function EventedHandle( _listeners, _eventName, _listener )
	{
	    Destroyable.call( this );

	    g_listenersRef.set( this, _listeners );
	    decl.defineProperties( this,
	    {
	        eventName: { enumerable: true, value: _eventName },
	        listener: { configurable: true, enumerable: true, value: _listener },
	        _attached: { writable: true, value: false }
	    } );

	    this.attach();
	}

	decl.declareClass( EventedHandle, Destroyable,
	/** @lends module:barejs.Evented~EventedHandle# */
	{
	    eventName: null,
	    listener: null,
	    _attached: null,

	    /**
	     * Destroy the handle.
	     */
	    destroy: function destroy()
	    {
	        this.remove();

	        delete this.listener;
	        g_listenersRef["delete"]( this );

	        Destroyable.prototype.destroy.call( this );
	    },

	    /**
	     * Remove the handle. A removed handle can be re-attached using {@link module:barejs.Evented~EventedHandle#attach attach}.
	     * @returns {boolean} True if the handle got detached.
	     */
	    remove: function remove()
	    {
	        var listeners;
	        if ( this._attached && this.listener && ( listeners = g_listenersRef.get( this ) ) )
	        {
	            // Look up event listeners backwards, since destroy iterates backwards
	            var idx = listeners.lastIndexOf( this );

	            // If the last listener is removed, use pop, since it doesn't return an Array.
	            if ( idx >= ( listeners.length - 1 ) )
	                listeners.pop();
	            /*istanbul ignore else: this is purely a sanity check, else path should never occur*/
	            else if ( idx >= 0 )
	                listeners.splice( idx, 1 );


	            this._attached = false;
	            return true;
	        }

	        return false;
	    },

	    /**
	     * Attach the handle. A handle is attached by default, this method should only be used after the handle has been detached
	     * using {@link module:barejs.Evented~EventedHandle#remove remove}.
	     * @returns {boolean} True if the handle is attached.
	     */
	    attach: function attach()
	    {
	        var listeners;
	        if ( !this._attached && this.listener && ( listeners = g_listenersRef.get( this ) ) )
	        {
	            listeners.push( this );
	            this._attached = true;
	        }

	        return this._attached;
	    },

	    /**
	     * Check if the handle is attached.
	     * @returns {boolean} True if the handle is attached.
	     */
	    isAttached: function isAttached()
	    {
	        return this._attached;
	    }
	} );

	/**
	 * The evented constructor will invoke the Destroyable constructor to ensure the object is initialized correctly.
	 * @class module:barejs.Evented
	 * @extends module:barejs.Destroyable
	 * @classdesc Evented is a base class that adds Eventing to JavaScript Objects.
	 * Extends Destroyable to automatically remove listeners if the object is destroyed.
	 * If handles given to the listener are {@link module:barejs.Destroyable#own own}ed (or manually destroyed at the appropiate time),
	 * the event link between Evented and its listener will be removed as soon as either party is destroyed.
	 */
	function Evented()
	{
	    Destroyable.call( this );
	}

	decl.preventCast( Evented );

	return decl.declareClass( Evented, Destroyable,
	/** @lends module:barejs.Evented# */
	{
	    /**
	     * Destroy the Evented object. This will clean up the object, removing any links to listeners.
	     */
	    destroy: function destroy()
	    {
	        var handles = g_eventHandles.get( this ) || null;

	        if ( handles )
	        {
	            g_eventHandles["delete"]( this );

	            // Note: handles remove themselves from the array, so iterate backwards.
	            // Do NOT use Destroyable.destroyAll for this!
	            for ( var i = handles.length - 1; i >= 0; --i )
	                handles[i].destroy();
	        }

	        Destroyable.prototype.destroy.call( this );
	    },

	    /**
	     * Listen to an event. To stop listening, call destroy the returned handle. Listeners should {@link module:barejs.Destroyable#own own}
	     * the handle returned by this method, so it is automatically disconnected when the listener is destroyed.
	     * @param {string} _eventName The event to listen to.
	     * @param {module:barejs.Evented~EventListener} _listener The callback to call if the event occurs.
	     * @returns {module:barejs.Evented~EventedHandle}
	     */
	    on: function on( _eventName, _listener )
	    {
	        var handlers;

	        // Note: inline check to see _listener is callable is performed first.
	        if ( Destroyable.isDestroyed( ensureCallable( _listener, this )) )
	            throw new Error( "The target object has been destroyed, cannot attach an event listener to it" );

	        if ( !( ( "on" + _eventName ) in this ) )
	            throw new Error( "The target object does not have a(n) " + _eventName + " event" );

	        if ( !( handlers = g_eventHandles.get( this ) ) )
	            g_eventHandles.set( this, handlers = [] );

	        // No need to own the handle; handles are automatically destroyed
	        return new EventedHandle( handlers, _eventName, _listener );
	    },

	    /**
	     * Listen for an event, automatically detaching after one invocation of the listener.
	     * @param {string} _eventName The event to listen to.
	     * @param {module:barejs.Evented~EventListener} _listener The callback to call (once) if the event occurs.
	     * @returns {module:barejs.Evented~EventedHandle}
	     */
	    once: function once( _eventName, _listener )
	    {
	        // Inline validation of _listener
	        var handle = ensureCallable( _listener, null );

	        return ( handle = this.on( _eventName, function()
	        {
	            /*istanbul ignore else: this is purely a sanity check, else path should never occur*/
	            if ( handle )
	            {
	                handle.destroy();
	                handle = null;
	            }

	            // Forward call
	            return _listener.apply( this, arguments );
	        } ) );
	    },

	    /**
	     * Emit the event with _eventName.
	     * @param {string} _eventName The name of the event to emit.
	     * @param {module:barejs.EventArgs} _eventArgs the event args to emit.
	     * @returns {module:barejs.EventArgs} _eventArgs (or null if not specified).
	     */
	    emit: function emit( _eventName, _eventArgs )
	    {
	        if ( Destroyable.isDestroyed( this ) )
	            throw new Error( "The target object has been destroyed, cannot emit an event from it" );

	        var args = _eventArgs || DEFAULT_ARGS,
	            evtDef = "on" + _eventName,
	            handles;

	        if ( !( evtDef in this ) )
	            throw new Error( "The " + _eventName + " event being emitted is not defined. Is this class missing an " + evtDef + " event definition?" );
	        if ( !(false) && !( args instanceof EventArgs ) && ( typeof console !== "undefined" ) )
	            console.warn( ( this.constructor.name || "Evented" ) + " is emitting the \"" + _eventName + "\" event with arguments that are not EventArgs" );

	        // First, call the local method (event definition)
	        this[evtDef]( args, this );

	        // If there are no handles, there are no listeners, so bail out
	        if ( ( handles = g_eventHandles.get( this ) ) && ( handles.length > 0 ) )
	        {
	            // Get the listeners for this event; using filter gives us a temporary array which is protected
	            // from the handles array being modified as a side effect of handler execution.
	            var listeners = handles.filter( function( _handle )
	            {
	                return _handle.eventName === _eventName;
	            } );

	            // Invoke the event handlers
	            for ( var idx = 0, len = listeners.length, handle; idx < len; idx++ )
	            {
	                // It is possible a handle got removed as a side effect of a previous handler; if so, ignore it.
	                if ( ( handle = listeners[idx] )._attached && handle.listener )
	                    handle.listener( args, this );
	            }
	        }

	        return _eventArgs || null;
	    },

	    /**
	     * Check if there is at least one listener for _eventName. It is highly recommended to just
	     * emit an event instead of checking if there are listeners. This method is provided for edge
	     * cases where building the event metadata is an expensive process, which should be avoided if
	     * there are no listeners.
	     * @param {string} _eventName The name of the event to check.
	     * @returns {Boolean} True if there is at least one listener, false otherwise.
	     */
	    hasListener: function( _eventName )
	    {
	        var handles = g_eventHandles.get( this );

	        return ( !!handles ) && handles.some( function( _handle )
	        {
	            return _handle.eventName === _eventName;
	        } );
	    }
	} );

	/**
	 * Event listeners are called with two arguments; the EventArgs and the sender.
	 * @callback module:barejs.Evented~EventListener
	 * @param {module:barejs.EventArgs} _eventArgs The EventArgs to the event.
	 * @param {module:barejs.Evented} _sender The Evented object that emitted the event.
	 */

	// End of module
	}(
	    Error,
	    __webpack_require__( 2 ),
	    __webpack_require__( 1 ),
	    __webpack_require__( 13 ),
	    __webpack_require__( 17 ),
	    __webpack_require__( 10 )
	) );


/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( decl )
	{
	"use strict";

	/**
	 * Create new EventArgs. Allows specifying a cancelable parameter as optional argument, which defaults to false.
	 * @class module:barejs.EventArgs
	 * @param {boolean} [_cancelable] Optional: provide a boolean to set whether this event is cancelable (default: prototype value, which is false for EventArgs).
	 * @classdesc Base class for event arguments. Mimics html events cancelable behavior for events that have default behavior that can be canceled.
	 * Subclasses can set the cancelable flag on their prototype, or use EventArgs.call( this, true ) to propagate the cancelable flag.
	 */
	function EventArgs( /*cancelable*/ )
	{
	    decl.defineProperties( this,
	    {
	        // Fixate the cancelable property for this object, either to argument 0 or the prototype value
	        cancelable: { enumerable: true, value: ( typeof arguments[0] === "boolean" ? arguments[0] : this.cancelable === true ) },
	        // Set defaultPrevented to false
	        defaultPrevented: { configurable: true, enumerable: true, value: false }
	    } );
	}

	return decl.declareClass( EventArgs,
	/** @lends module:barejs.EventArgs# */
	{
	    /**
	     * This value is true if the event got canceled (preventDefault was called, and cancelable is true).
	     * @member {boolean}
	     * @readonly
	     */
	    defaultPrevented: { enumerable: true, value: null },

	    /**
	     * The cancelable flag determines whether this event has behavior that can be canceled.
	     * @member {boolean}
	     * @readonly
	     */
	    cancelable: { enumerable: true, writable: true, value: false },

	    /**
	     * The preventDefault method will flag the EventArgs as defaultPrevented, if cancelable is true.
	     * @function
	     */
	    preventDefault:
	    {
	        enumerable: true,
	        value: function preventDefault()
	        {
	            if ( ( this.cancelable === true ) && !this.defaultPrevented )
	                decl.defineProperty( this, "defaultPrevented", { enumerable: true, value: true } );
	        }
	    }
	} );

	// End of define
	}( __webpack_require__( 1 ) ) );


/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/**
	 * The BareJS module is the entry point for accessing BareJS's classes and polyfills.
	 * @module barejs
	 */

	// Start by loading "Built-in object" polyfills, and apply them to barejs
	Object.assign( exports, __webpack_require__( 19 ),
	/** @lends module:barejs */
	{
	    // Load BareJS code
	    decl        : __webpack_require__( 1 ),
	    Destroyable : __webpack_require__( 13 ),
	    EventArgs   : __webpack_require__( 17 ),
	    Evented     : __webpack_require__( 16 ),
	    Exception   : __webpack_require__( 35 ),

	    /**
	     * The BareJS module contains an AMD loader plugin to reference specific parts of BareJS directly.
	     * For example, this allows to require "{@link module:barejs.decl barejs!decl}", "{@link module:barejs.Promise barejs!Promise}",
	     * "{@link module:barejs.NMap barejs!NMap}" or "{@link module:barejs.Map barejs!Map}"
	     */
	    load: function( _name, _req, _load )
	    {
	        "use strict";
	        if ( !( _name in exports ) )
	            throw new Error( "invalid path: " + _name );
	        _load( exports[_name] );
	    },

	    /**
	     * While we want to provide the plugin shortcut to objects, we don't want to build this into a layer.
	     */
	    write: function()
	    {
	        "use strict";
	        // Don't write anything
	    }
	} );


/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2016
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	// Native objects available since the beginning; may contain polyfills for multiple levels of ES compliance.
	// No need to expose these on "polyfill" since they are always available
	__webpack_require__( 12 );
	__webpack_require__( 20 );
	__webpack_require__( 21 );
	__webpack_require__( 22 );
	__webpack_require__( 23 );
	__webpack_require__( 2 );
	__webpack_require__( 24 );

	/**
	 * The polyfill module contains polyfills for objects in the ECMAScript specification.
	 * @module barejs/polyfill
	 */
	Object.assign( exports,
	// Note: although we define this module to be barejs/polyfill, its properties are actually added to barejs, so tell jsdoc about that.
	/** @lends module:barejs */
	{
	    /**
	     * NMap - Version of Map that prefers the native implementation over the polyfill, even if it doesn't have
	     * iterator support (like in Internet Explorer 11). If Iterator support is required, use
	     * {@link module:barejs.Map Map} instead.
	     * @member {function}
	     */
	    NMap: __webpack_require__( 3 ),

	    /**
	     * NSet - Version of Set that prefers the native implementation over the polyfill, even if it doesn't have
	     * iterator support (like in Internet Explorer 11). If Iterator support is required, use
	     * {@link module:barejs.Set Set} instead.
	     * @member {function}
	     */
	    NSet: __webpack_require__( 6 ),

	    // New built-in objects that will be polyfilled (but not globally)

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl}
	     * or the {@link module:barejs/polyfill.Intl fallback} provided by BareJS. Note that BareJS's fallback just provides a similar API,
	     * it has not actual localization features. It's main purpose is to gracefully fallback to very limited formatting on
	     * environments that don't support Intl. For proper support, load a full Intl polyfill.
	     * @member {function}
	     */
	    Intl: __webpack_require__( 25 ),

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map Map}
	     * or the {@link module:barejs/polyfill.Map polyfill} provided by BareJS. This implementation is ensured to have iterator support (using the polyfill), if no
	     * iterator support is required it is better to use {@link module:barejs.NMap NMap} instead.
	     * @member {function}
	     */
	    Map: __webpack_require__( 31 ),

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap WeakMap}
	     * or the {@link module:barejs/polyfill.WeakMap polyfill} provided by BareJS.
	     * @member {function}
	     */
	    WeakMap: __webpack_require__( 10 ),

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set Set}
	     * or the {@link module:barejs/polyfill.Set polyfill} provided by BareJS. This implementation is ensured to have iterator support (using the polyfill), if no
	     * iterator support is required it is better to use {@link module:barejs.NSet NSet} instead.
	     * @member {function}
	     */
	    Set: __webpack_require__( 32 ),
	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet WeakSet}
	     * or the {@link module:barejs/polyfill.WeakSet polyfill} provided by BareJS.
	     * @member {function}
	     */
	    WeakSet: __webpack_require__( 14 ),

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol Symbol}
	     * or the {@link module:barejs/polyfill.Symbol polyfill} provided by BareJS.
	     * @member {function}
	     */
	    Symbol: __webpack_require__( 8 ),

	    /**
	     * This is either the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise Promise}
	     * or the {@link module:barejs/polyfill.Promise polyfill} provided by BareJS.
	     * @member {function}
	     */
	    Promise: __webpack_require__( 33 )
	} );


/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Date, ObjectPolyfill )
	{
	"use strict";

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date Date}.
	 * @class module:barejs/polyfill.Date
	 */

	/** @lends module:barejs/polyfill.Date */
	var stat = {};
	/** @lends module:barejs/polyfill.Date# */
	var proto = {};

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 5 )
	{
	    /**
	     * The Date.now() method returns the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
	     * @returns {number} The number of milliseconds.
	     */
	    stat.now = function now()
	    {
	        return new Date().getTime();
	    };

	    ( function()
	    {
	        /**
	         * Ensure the number is _length characters wide.
	         * @param {number} _value The number to pad.
	         * @param {number} _length The length to pad to. Note: values > 4 are not supported
	         * @returns {string} The number, optionally padded with leading zeros
	         */
	        function padZero( _value, _length )
	        {
	            var nr = String( _value );
	            if ( nr.length < _length )
	                nr = "0000".substr( 0, _length - nr.length ) + nr;
	            return nr;
	        }

	        /**
	         * The toISOString() method returns a string in simplified extended ISO format (ISO 8601), which
	         * is always 24 characters long: YYYY-MM-DDTHH:mm:ss.sssZ. The timezone is always zero UTC
	         * offset, as denoted by the suffix "Z".
	         * @returns {string} The date formatted as (zero UTC) ISO 8601.
	         */
	        proto.toISOString = function toISOString()
	        {
	            // jshint validthis:true
	            return    padZero( this.getUTCFullYear(),   4 ) +
	                "-" + padZero( this.getUTCMonth() + 1,  2 ) +
	                "-" + padZero( this.getUTCDate(),       2 ) +
	                "T" + padZero( this.getUTCHours(),      2 ) +
	                ":" + padZero( this.getUTCMinutes(),    2 ) +
	                ":" + padZero( this.getUTCSeconds(),    2 ) +
	                "." + ( this.getUTCMilliseconds() / 1000 ).toFixed( 3 ).slice( 2, 5 ) +
	                "Z";
	        };
	    }() );
	// End of ES5 polyfill scope
	}

	ObjectPolyfill.polyfill( Date, stat, proto, exports, "Date" );

	// End of module
	}( Date, __webpack_require__( 2 ) ) );


/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Object, Function, ObjectPolyfill )
	{
	"use strict";

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function Function}.
	 * @class module:barejs/polyfill.Function
	 */

	/** @lends module:barejs/polyfill.Function# */
	var proto = {};

	var fnProto = Function.prototype;

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 5 )
	{
	    var slice = Array.prototype.slice;

	    /**
	     * Bind a function to a specific context. Allows for additional prefix arguments to be specified.
	     * @param {object} _thisArg The context to bind this method to.
	     * @returns {function} A function that will invoke the original function in the specified context,
	     *                     optionally with additional parameters prefixed.
	     */
	    proto.bind = function bind( _thisArg /*, ... */ )
	    {
	        if ( !ObjectPolyfill.isCallable( this ) )
	            throw new TypeError( "Bind must be called on a function" );

	        var bound, fn = this, args = null, Anonymous = function(){};

	        if ( arguments.length > 1 )
	            args = slice.call( arguments, 1, arguments.length );

	        // Apply almost the same trick as Object.create, so if the bound method is used as a
	        // constructor, we do not change the context and the prototype chain is correct.
	        // We can't use Object.create since we need the Anonymous type for the instanceof check
	        // Prototype is undefined for native functions, so check it first.
	        Anonymous.prototype = fn.prototype /*istanbul ignore next*/|| Object.prototype;

	        // Only do parameter mangling if required. This optimization provides a significant speed boost
	        if ( args && args.length )
	        {
	            bound = function()
	            {
	                var len = arguments.length;
	                // Only concat the arguments if there are arguments during invocation (to avoid concat)
	                // If this bound method is used as a constructor, don't change the context
	                return fn.apply( this instanceof Anonymous ? this : _thisArg, len ? args.concat( slice.call( arguments, 0, len ) ) : args );
	            };
	        }
	        else
	        {
	            bound = function()
	            {
	                // If this bound method is used as a constructor, don't change the context
	                return fn.apply( this instanceof Anonymous ? this : _thisArg, arguments );
	            };
	        }
	        bound.prototype = new Anonymous();

	        // technically the bound function should have the same length as the function bound, but we can't emulate that
	        return bound;
	    };
	}

	( function()
	{
	    var toString = fnProto.toString;

	    /*istanbul ignore next: not invoked since NodeJS has a name property on Function.prototype*/
	    function name()
	    {
	        //jshint validthis:true
	        if ( this === fnProto )
	            return "";

	        var match = toString.call( this ).match( /function\s*([a-zA-Z0-9_$]*)\s*\(/ );

	        Object.defineProperty( this, "name", { configurable: true, value: ( match && match[1] ) || "" } );

	        return this.name;
	    }

	    // See if the name property isn't exposed, but we can expose it (and it works)
	    /*istanbul ignore next: NodeJS has a name property on functions*/
	    if ( !name.name && Object.defineProperties && ( name.call( name ) === "name" ) )
	        Object.defineProperty( fnProto, "name", { configurable: true, "get": name } );
	}() );

	ObjectPolyfill.polyfill( Function, null, proto, exports, "Function" );

	// End of module
	}( Object, Function, __webpack_require__( 2 ) ) );


/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Math, ObjectPolyfill )
	{
	"use strict";

	// This module polyfills bitwise operations.
	/*jshint bitwise:false*/

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math Math}.
	 * @class module:barejs/polyfill.Math
	 */

	/** @lends module:barejs/polyfill.Math */
	var stat = {};

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 6 )
	{
	    /**
	     * The Math.cbrt() function returns the cube root of a number.
	     * @param {number} _x The number to get the cube root of.
	     * @returns {number} The cube root of the number
	     */
	    stat.cbrt = function cbrt( _x )
	    {
	        var y = Math.pow( Math.abs( _x ), 1/3 );
	        return _x < 0 ? -y : y;
	    };

	    /**
	     * The Math.expm1() function returns e^x - 1, where x is the argument, and e the base of the natural logarithms.
	     * @param {number} _x The number.
	     * @returns {number} A number representing e^x - 1, where e is Euler's number and x is the argument.
	     */
	    stat.expm1 = function expm1( _x )
	    {
	        return Math.exp( _x ) - 1;
	    };

	    /**
	     * The Math.hypot() function returns the square root of the sum of squares of its arguments.
	     * @returns {number} The square root of the sum of squares of its arguments.
	     */
	    stat.hypot = function hypot( _a, _b/*, ...*/ )
	    {
	        for ( var i = 0, len = arguments.length, y = 0, v; i < len; ++i )
	        {
	            v = Math.abs( arguments[i] );
	            if ( v === Infinity )
	                return v;
	            y += v * v;
	        }
	        return Math.sqrt( y );
	    };

	    /**
	     * The Math.imul() function returns the result of the C-like 32-bit multiplication of the two parameters.
	     * @param {number} _a Operand A.
	     * @param {number} _b Operand B.
	     * @returns {number} The result of the multiplication.
	     */
	    stat.imul = function imul( _a, _b )
	    {
	        var ah = ( _a >>> 16 ) & 0xffff;
	        var al = _a & 0xffff;
	        var bh = ( _b >>> 16 ) & 0xffff;
	        var bl = _b & 0xffff;
	        // the shift by 0 fixes the sign on the high part
	        // the final |0 converts the unsigned value into a signed value
	        return ( ( al * bl ) + ( ( ( ah * bl + al * bh ) << 16 ) >>> 0 ) | 0 );
	    };

	    ( function()
	    {
	        var table = [
	              32, 31,  0,         16,  0, 30,  3,  0, 15,  0,  0,  0, 29, 10,  2,  0,
	               0,  0, 12,         14, 21,  0, 19,  0,  0, 28,  0, 25,  0,  9,  1,  0,
	              17,  0,  4,  undefined,  0,  0, 11,  0, 13, 22, 20,  0, 26,  0,  0, 18,
	               5,  0,  0,         23,  0, 27,  0,  6,  0, 24,  7,  0,  8,  0,  0,  0];

	        /**
	         * The Math.clz32() function returns the number of leading zero bits in the 32-bit binary representation of a number.
	         * "clz32" is short for CountLeadingZeroes32.
	         * @param {number} _x
	         * @returns {number}
	         */
	        stat.clz32 = function clz32( _x )
	        {
	            var v = _x >>> 0; // convert to unsigned integer

	            v |= v >>> 1;
	            v |= v >>> 2;
	            v |= v >>> 4;
	            v |= v >>> 8;
	            v |= v >>> 16;

	            return table[ Math.imul( v, 0x06EB14F9 ) >>> 26 ];
	        };
	    }() );

	    /**
	     * The Math.log1p() function returns the natural logarithm (base e) of 1 + a number.
	     * @param {number} _x The value to get the logarithm of.
	     * @returns {number} The logarithm of 1 + _x.
	     */
	    stat.log1p = function log1p( _x )
	    {
	        return Math.log( 1 + _x );
	    };

	    /**
	     * The Math.log2() function returns the base 2 logarithm of a number.
	     * @param {number} _x The value to get the base 2 logarithm of.
	     * @returns {number} The base 2 logarithm of _x.
	     */
	    stat.log2 = function log2( _x )
	    {
	        return Math.log( _x ) / Math.LN2;
	    };

	    /**
	     * The Math.log10() function returns the base 10 logarithm of a number.
	     * Note that this polyfill is subject to rounding errors.
	     * @param {number} _x The value to get the base 10 logarithm of.
	     * @returns {number} The base 10 logarithm of _x.
	     */
	    stat.log10 = function log10( _x )
	    {
	        return Math.log( _x ) / Math.LN10;
	    };

	    /**
	     * The Math.cosh() function returns the hyperbolic cosine of a number.
	     * @param {number} _x The value to calculate the cosine of.
	     * @returns {number} The hyperbolic cosine.
	     */
	    stat.cosh = function cosh( _x )
	    {
	        var y = Math.exp( _x );
	        return ( y + 1 / y ) / 2;
	    };

	    /**
	     * The Math.acosh() function returns the hyperbolic arc-cosine of a number.
	     * @param {number} _x The value to calculate the arc-cosine of.
	     * @returns {number} The hyperbolic arc-cosine.
	     */
	    stat.acosh = function acosh( _x )
	    {
	        return Math.log( _x + Math.sqrt( _x * _x - 1 ) );
	    };

	    /**
	     * The Math.sinh() function returns the hyperbolic sine of a number.
	     * @param {number} _x The value to calculate the sine of.
	     * @returns {number} The hyperbolic sine.
	     */
	    stat.sinh = function sinh( _x )
	    {
	        var y = Math.exp( _x );
	        return ( y - 1 / y ) / 2;
	    };

	    /**
	     * The Math.asinh() function returns the hyperbolic arcsine of a number.
	     * @param {number} _x The value to calculate the arcsine of.
	     * @returns {number} The hyperbolic arcsine.
	     */
	    stat.asinh = function asinh( _x )
	    {
	        if ( _x === -Infinity )
	            return _x;
	        else
	            return Math.log( _x + Math.sqrt( _x * _x + 1 ) );
	    };

	    /**
	     * The Math.tanh() function returns the hyperbolic tangent of a number.
	     * @param {number} _x The value to calculate the tangent of.
	     * @returns {number} The hyperbolic tangent.
	     */
	    stat.tanh = function tanh( _x )
	    {
	        var y;

	        if ( _x === Infinity )
	            return 1;
	        else if ( _x === -Infinity )
	            return -1;
	        else
	            return ( ( y = Math.exp( 2 * _x ) ) - 1) / ( y + 1 );
	    };

	    /**
	     * The Math.atanh() function returns the hyperbolic arctangent of a number.
	     * @param {number} _x The value to calculate the arctangent of.
	     * @returns {number} The hyperbolic arctangent.
	     */
	    stat.atanh = function atanh( _x )
	    {
	        return Math.log( ( 1 + _x ) / ( 1 - _x ) ) / 2;
	    };

	    /**
	     * The Math.sign() function returns the sign of a number, indicating whether the number is positive, negative or zero.
	     * @param {number} _x The number to check
	     * @returns {number} This function has 5 kinds of return values, 1, -1, 0, -0, NaN, which represent
	     *                  "positive number", "negative number", "positive zero", "negative zero" and NaN respectively.
	     */
	    stat.sign = function sign( _x )
	    {
	        _x = +_x; // convert to a number
	        if ( _x === 0 || isNaN( _x ) )
	            return _x;
	        return _x > 0 ? 1 : -1;
	    };

	    /**
	     * Unlike other three Math methods: Math.floor(), Math.ceil() and Math.round(), the way
	     * Math.trunc() works is very simple and straightforward, just truncate the dot and the digits
	     * behind it, no matter whether the argument is a positive number or a negative number.
	     * @param {number} _x The number to truncate.
	     * @returns {number} The truncated number
	     */
	    stat.trunc = function trunc( _x )
	    {
	        return _x < 0 ? Math.ceil( _x ) : Math.floor( _x );
	    };
	// End of ES6 polyfill scope
	}

	ObjectPolyfill.polyfill( Math, stat, null, exports, "Math" );

	// End of module
	}( Math, __webpack_require__( 2 ) ) );


/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Number, ObjectPolyfill )
	{
	"use strict";

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number Number}.
	 * @class module:barejs/polyfill.Number
	 */

	/** @lends module:barejs/polyfill.Number */
	var stat = {};

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 6 )
	{
	    stat.parseInt   = parseInt;    // ES6 defines this global should be on Number
	    stat.parseFloat = parseFloat;  // ES6 defines this global should be on Number

	    /**
	     * The Number.MAX_SAFE_INTEGER constant represents the maximum safe integer in JavaScript (2<sup>53</sup> - 1).
	     * @member {number}
	     * @readonly
	     */
	    stat.MAX_SAFE_INTEGER = 9007199254740991 /*0x1fffffffffffff*/;
	    /**
	     * The Number.MIN_SAFE_INTEGER constant represents the minimum safe integer in JavaScript (-(2<sup>53</sup> - 1)).
	     * @member {number}
	     * @readonly
	     */
	    stat.MIN_SAFE_INTEGER = -stat.MAX_SAFE_INTEGER;
	    /**
	     * The Number.EPSILON property represents the difference between `1` and the smallest floating point number greater than `1`.
	     * @member {number}
	     * @readonly
	     */
	    stat.EPSILON = Math.pow( 2, -52 );

	    // Closure to protect the isFinite name
	    ( function( _isFinite )
	    {
	        /**
	         * Check if a number is finite. Differs from global isFinite by not coercing types.
	         * @param _value the value to check.
	         * @returns {boolean} True if _value is a finite number
	         */
	        stat.isFinite = function isFinite( _value )
	        {
	            return typeof _value === "number" && _isFinite( _value );
	        };
	    }( isFinite /* Grab the global isFinite */ ) );

	    /**
	     * The Number.isInteger() method determines whether the passed value is an integer.
	     * @param _value the value to check.
	     * @returns {boolean} True if _value is an integer.
	     */
	    stat.isInteger = function isInteger( _value )
	    {
	        return Number.isFinite( _value ) && Math.floor( _value ) === _value;
	    };

	    /**
	     * The Number.isSafeInteger() method determines whether the provided value is a number that is a safe integer.
	     * A safe integer is an integer that
	     *  - can be exactly represented as an IEEE-754 double precision number, and
	     *  - whose IEEE-754 representation cannot be the result of rounding any other integer to fit the IEEE-754 representation.
	     * For example, 2<sup>53</sup> - 1 is a safe integer: it can be exactly represented, and no other integer rounds to it under any IEEE-754 rounding mode.
	     * In contrast, 2<sup>53</sup> is not a safe integer: it can be exactly represented in IEEE-754, but the integer 2<sup>53</sup> + 1 can't be directly represented in IEEE-754
	     * but instead rounds to 2<sup>53</sup> under round-to-nearest and round-to-zero rounding.
	     * The safe integers consist of all integers from -(2<sup>53</sup> - 1) inclusive to 2<sup>53</sup> - 1 inclusive.
	     * @param {number} _value The value to test
	     * @returns {boolean} True if _value is a Number and a safe integer value.
	     */
	    stat.isSafeInteger = function isSafeInteger( _value )
	    {
	        return Number.isInteger( _value ) && ( _value >= Number.MIN_SAFE_INTEGER ) && ( _value <= Number.MAX_SAFE_INTEGER );
	    };

	    // Closure to protect the isNaN name
	    ( function( _isNaN )
	    {
	        /**
	         * Check if _value is the special NaN value. Differs from global isNaN by not coercing types.
	         * @param _value the value to check.
	         * @returns {boolean} True if _value is the NaN value number
	         */
	        stat.isNaN = function isNaN( _value )
	        {
	            return typeof _value === "number" && _isNaN( _value );
	        };
	    }( isNaN /* Grab the global isNaN */ ) );
	// End of ES6 polyfill scope
	}

	ObjectPolyfill.polyfill( Number, stat, null, exports, "Number" );

	// End of module
	}( Number, __webpack_require__( 2 ) ) );


/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( Math, RegExp, String, ObjectPolyfill )
	{
	"use strict";
	var strUndef = "undefined";

	/**
	 * Polyfills for {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String String}.
	 * @class module:barejs/polyfill.String
	 */

	/** @lends module:barejs/polyfill.String */
	var stat = {},
	/** @lends module:barejs/polyfill.String# */
	    proto = {};
	/*jshint bitwise:false*/

	function stringContext( _context, _name )
	{
	    if ( ( typeof _context === strUndef ) || ( _context === null ) )
	        throw new TypeError( "String.prototype." + _name + " called on null or undefined" );

	    return String( _context );
	}

	function toSearch( _search, _name )
	{
	    if ( _search instanceof RegExp )
	        throw new TypeError( "First argument to String.prototype." + _name + " must not be a regular expression" );
	    return String( _search );
	}

	function toNumber( _value, _min, _default, _max )
	{
	    if ( isNaN( _value = Math.trunc( _value ) ) )
	        return _default;
	    return _value < _min ? _min : ( _value > _max ? _max : _value );
	}

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 6 )
	{
	    /**
	     * Check if the string starts with the other string
	     * @param {string} _search The part to search for
	     * @param {number} [_start=0] Optional: The position in this string at which to begin searching for _search; defaults to 0.
	     * @returns {boolean} True if the string starts with search, false otherwise.
	     */
	    proto.startsWith = function startsWith( _search/*, _start*/ )
	    {
	        var str = stringContext( this, "startsWith" ),
	            pos = toNumber( arguments[1], 0, 0, str.length );
	        // Using lastIndexOf ensures we don't search the whole string for _search, just at the requested pos index going back.
	        return str.lastIndexOf( toSearch( _search, "startsWith" ), pos ) === pos;
	    };

	    /**
	     * Check if the string ends with the other string
	     * @param {string} _search The part to search for
	     * @param {number} [_limit] Optional: Search within this string as if this string were only this long;
	     * defaults to this string's actual length, clamped within the range established by this string's length.
	     * @returns {boolean} True if the string ends with search, false otherwise.
	     */
	    proto.endsWith = function endsWith( _search/*, _limit*/ )
	    {
	        var str = stringContext( this, "endsWith" ),
	            // We need to start matching at this position
	            pos = toNumber( arguments[1], 0, str.length, str.length ) - ( _search = toSearch( _search, "endsWith" ) ).length;
	        // Using indexOf ensures we don't search the whole string for _search, just at the requested end index going forward.
	        return ( pos >= 0 ) && str.indexOf( _search, pos ) === pos;
	    };

	    ( function( _whitespace )
	    {
	        var reTrim = /^\s+|\s+$/g;
	        var reTrimStart = /^\s+/;
	        var reTrimEnd = /\s+$/;

	        /*
	         * Attempt to sniff out regular expression engines that do not have all whitespace under the \s character class.
	         * If so, build the same regex as above, but with our expanded whitespace class.
	         */
	        /*istanbul ignore if: This check only fails in very old IE versions (<IE6)*/
	        if ( _whitespace.match( /[^\s]/ ) )
	        {
	            reTrim = new RegExp( "^[\\s" + _whitespace + "]+|[\\s" + _whitespace + "]+$", "g" );
	            reTrimStart = new RegExp( "^[\\s" + _whitespace + "]+" );
	            reTrimEnd = new RegExp( "[\\s" + _whitespace + "]+$" );
	        }

	        /**
	         * The trim() method removes whitespace from both ends of a string. Whitespace in this context is
	         * all the whitespace characters (space, tab, no-break space, etc.) and all the line terminator
	         * characters (LF, CR, etc.).
	         * @returns {string} The trimmed string.
	         */
	        proto.trim = function trim()
	        {
	            // jshint validthis:true
	            return stringContext( this, "trim" ).replace( reTrim, "" );
	        };

	        /**
	         * The trimStart() method removes whitespace from the beginning of a string. Whitespace in this context is
	         * all the whitespace characters (space, tab, no-break space, etc.) and all the line terminator
	         * characters (LF, CR, etc.).
	         * @returns {string} The trimmed string.
	         */
	        proto.trimStart = proto.trimLeft = function trimStart()
	        {
	            // jshint validthis:true
	            return stringContext( this, "trimStart" ).replace( reTrimStart, "" );
	        };

	        /**
	         * The trimEnd() method removes whitespace from the end of a string. Whitespace in this context is
	         * all the whitespace characters (space, tab, no-break space, etc.) and all the line terminator
	         * characters (LF, CR, etc.).
	         * @returns {string} The trimmed string.
	         */
	        proto.trimEnd = proto.trimRight = function trimEnd()
	        {
	            // jshint validthis:true
	            return stringContext( this, "trimEnd" ).replace( reTrimEnd, "" );
	        };
	    }( String.fromCharCode(
	        // \u00A0, NO-BREAK SPACE
	        160,
	        // \u1680, OGHAM SPACE MARK
	        5760,
	        // \u2000..\u200A, EN QUAD..HAIR SPACE
	        8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202,
	        // \u2028, LINE SEPARATOR
	        8232,
	        // \u2029, PARAGRAPH SEPARATOR
	        8233,
	        // \u202F, NARROW NO-BREAK SPACE
	        8239,
	        // \u205F, MEDIUM MATHEMATICAL SPACE
	        8287,
	        // \u3000, IDEOGRAPHIC SPACE
	        12288
	    ) ) );

	    ( function()
	    {
	        // Ensuring count is a 31-bit integer allows us to heavily optimise the main part of the method.
	        // Besides that, browsers that will need this polyfill can't handle strings 1 << 28 chars or longer.
	        var LIMIT = 1 << 28;

	        /**
	         * The repeat() method constructs and returns a new string which contains the specified number
	         * of copies of the string on which it was called, concatenated together.
	         * @param {number} _count The amount of times to repeat the number.
	         * @returns {string} The string, repeated.
	         */
	        proto.repeat = function repeat( _count )
	        {
	            // jshint validthis:true
	            var rpt = "",
	                str = stringContext( this, "repeat" ),
	                count = Math.floor( _count ) || 0;

	            if ( count < 0 )
	                throw new RangeError( "repeat count must be non-negative" );
	            if ( count === Infinity )
	                throw new RangeError( "repeat count must be less than infinity" );

	            // If either string.length or count is 0, we'll get length 0
	            var len = str.length * count;

	            if ( len >= LIMIT )
	                throw new RangeError( "repeat count must not overflow maximum string size" );

	            if ( len > 0 )
	            {
	                // Optimised: concatenates str instead of rpt, to perform the operation with the least
	                // amount of string concatenations possible.
	                for (;;)
	                {
	                    if ( ( count & 1 ) === 1 )
	                        rpt += str;
	                    count >>>= 1;
	                    if ( count === 0 )
	                        break;
	                    str += str;
	                }
	            }

	            return rpt;
	        };
	    }() );

	    /**
	     * The codePointAt() method returns a non-negative integer that is the UTF-16 encoded code point value.
	     * @param {number} _position The index at which the code point should be read
	     * @returns {number} The code point value, or undefined if _position is out of range.
	     */
	    proto.codePointAt = function codePointAt( _position )
	    {
	        var str = stringContext( this, "codePointAt" ),
	            len = str.length,
	            // `ToInteger`
	            i = Math.floor( _position ) || 0,
	            result;

	        // Account for out-of-bounds indices:
	        if ( i >= 0 && i < len )
	        {
	            // Get the first code unit; increment index afterwards
	            result = str.charCodeAt( i++ );
	            // check if it’s the start of a surrogate pair
	            // high surrogate && there is a next code unit
	            if ( ( result >= 0xD800 ) && ( result <= 0xDBFF ) && ( i < len ) )
	            {
	                var pair = str.charCodeAt( i );
	                if ( ( pair >= 0xDC00 ) && ( pair <= 0xDFFF ) ) // low surrogate
	                    result = ( result - 0xD800 ) * 0x400 + pair - 0xDC00 + 0x10000;
	            }
	        }

	        return result;
	    };

	    /**
	     * Create a String from any number of codepoint values
	     * @returns {string} The created string
	     */
	    stat.fromCodePoint = function fromCodePoint( _firstCodePoint )
	    {
	        var codeUnits = [],
	            result = "";

	        for ( var i = 0, len = arguments.length; i < len; ++i )
	        {
	            var codePoint = +( arguments[i] );
	            if (
	                    ( !isFinite( codePoint ) ) ||                       // `NaN`, `+Infinity`, or `-Infinity`
	                    ( codePoint < 0 ) || ( codePoint > 0x10FFFF ) ||    // not a valid Unicode code point
	                    ( Math.floor( codePoint ) !== codePoint )           // not an integer
	                )
	            {
	                throw new RangeError( "Invalid code point: " + codePoint );
	            }
	            if ( codePoint <= 0xFFFF )
	            {
	                // BMP code point
	                codeUnits.push( codePoint );
	            }
	            else
	            {
	                // Astral code point; split in surrogate halves
	                codePoint -= 0x10000;
	                var highSurrogate = ( codePoint >> 10 ) + 0xD800;
	                var lowSurrogate = ( codePoint % 0x400 ) + 0xDC00;
	                codeUnits.push( highSurrogate, lowSurrogate );
	            }
	            if ( ( i + 1 === len ) || ( codeUnits.length > 0x4000 ) )
	            {
	                result += String.fromCharCode.apply( String, codeUnits );
	                codeUnits.length = 0;
	            }
	        }
	        return result;
	    };

	    /**
	     * Check if the string includes the other string
	     * @param {string} _search The part to search for
	     * @param {number} [_position=0] Optional: The index to start searching at. Defaults to 0.
	     * @returns {boolean} True if the string includes search, false otherwise.
	     */
	    proto.includes = function includes( _search/*, _position*/ )
	    {
	        var str = stringContext( this, "includes" ),
	            pos = toNumber( arguments[1], 0, 0, str.length );
	        return str.indexOf( toSearch( _search, "includes" ), pos ) >= 0;
	    };

	// End of ES6 polyfill scope
	}

	/*istanbul ignore else: We test with __ES__ set to 3*/
	if ( (6) < 7 )
	{
	    /**
	     * The padStart() method pads the current string with a given string (eventually repeated) so that the resulting string reaches a given length.
	     * The pad is applied from the start (left) of the current string.
	     * @param {number} _targetLength The length of the resulting string once the current string has been padded.
	     *      If this parameter is smaller than the current string's length, the current string will be returned as it is.
	     * @param {string} [_padString=" "] The string to pad the current string with.
	     *      If this string is too long, it will be truncated and the left-most part will be applied.
	     *      The default value for this parameter is " " (U+0020).
	     */
	    proto.padStart = function padStart( _targetLength/*, _padString*/ )
	    {
	        var str = stringContext( this, "padStart" ),
	            pad = arguments[1],
	            len = Math.trunc( _targetLength ) || 0,
	            add = len - str.length,
	            pLen,
	            pre;

	        pad = typeof pad === strUndef ? " " : String( pad );
	        pLen = pad.length;

	        if ( ( add > 0 ) && ( pLen > 0 ) )
	        {
	            pre = pad.repeat( Math.floor( add / pLen ) );
	            add %= pLen;
	            if ( add > 0 )
	                pre += pad.substr( 0, add );
	            str = pre + str;
	        }
	        return str;
	    };

	    /**
	     * The padEnd() method pads the current string with a given string (eventually repeated) so that the resulting string reaches a given length.
	     * The pad is applied from the end (right) of the current string.
	     * @param {number} _targetLength The length of the resulting string once the current string has been padded.
	     *      If this parameter is smaller than the current string's length, the current string will be returned as it is.
	     * @param {string} [_padString=" "] The string to pad the current string with.
	     *      If this string is too long, it will be truncated and the left-most part will be applied.
	     *      The default value for this parameter is " " (U+0020).
	     */
	    proto.padEnd = function padEnd( _targetLength/*, _padString*/ )
	    {
	        var str = stringContext( this, "padEnd" ),
	            pad = arguments[1],
	            len = Math.trunc( _targetLength ) || 0,
	            add = len - str.length,
	            pLen,
	            post;

	        pad = typeof pad === strUndef ? " " : String( pad );
	        pLen = pad.length;

	        if ( ( add > 0 ) && ( pLen > 0 ) )
	        {
	            post = pad.repeat( Math.floor( add / pLen ) );
	            add %= pLen;
	            if ( add > 0 )
	                post += pad.substr( 0, add );
	            str += post;
	        }
	        return str;
	    };
	}

	ObjectPolyfill.polyfill( String, stat, proto, exports, "String" );

	// End of module
	}( Math, RegExp, String, __webpack_require__( 2 ) ) );


/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global Intl*/

	module.exports = ( function( Intl, IntlPolyfill )
	{
	"use strict";

	// Check if the native Intl should be merged with some polyfills on it. Only call if Intl != null.
	function shouldMerge( _name )
	{
	    return !Intl[ _name ] || IntlPolyfill[ _name ];
	}

	// APIs expected on the Intl object
	var APIs = [ "Collator", "DateTimeformat", "NumberFormat", "PluralRules", "getCanonicalLocales" ];
	var result = Intl || IntlPolyfill;

	// If there is a native Intl, see if some parts should be merged
	if ( Intl && APIs.some( shouldMerge ) )
	{
	    // Create a merged Intl object taking as much from the native object as possible.
	    // Although prototype inheritance is used, set all expected value as local properties so hasOwnProperty behaves as expected.
	    result = Object.create( Intl, APIs.reduce( function( _propDef, _name )
	    {
	        var value = Intl[ _name ] || IntlPolyfill[ _name ];
	        if ( value )
	            _propDef[ _name ] = { value: value };
	        return _propDef;
	    }, {} ) );
	}

	return result;

	}( typeof Intl !== "undefined" ? Intl : null, __webpack_require__( 26 ) ) );


/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, DateTimeFormat, NumberFormat, bcp47 )
	{
	"use strict";

	/**
	 * @module barejs/polyfill/Intl
	 */

	function Intl()
	{
	    ObjectPolyfill.defineProperties( this,
	    {
	        DateTimeFormat: { value: DateTimeFormat },
	        NumberFormat: { value: NumberFormat },
	        getCanonicalLocales: { value: bcp47.getCanonicalLocales }
	    } );
	}

	return new Intl();

	}( __webpack_require__( 2 ), __webpack_require__( 27 ), __webpack_require__( 30 ), __webpack_require__( 29 ) ) );


/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, Format )
	{
	"use strict";
	/**
	 * These classes are NOT a polyfill, and are not meant to be!
	 * They provide a poor man's fallback for the Intl formatters, for non-compliant environments.
	 */

	var NAME        = [ "short", "long" ];
	var DATE_NUMBER = [ "numeric", "2-digit" ];
	var DATE_TEXT   = [ "narrow" ].concat( NAME );
	var DATE_BOTH   = DATE_NUMBER.concat( DATE_TEXT );
	var BOOLEAN     = [ true, false ];

	var padStart = Function.prototype.call.bind( String.prototype.padStart );
	// This regex will match a sequence of possible formatter items
	var reReplace   = /A+|a+|D+|d+|E+|e+|F+|G+|g+|H+|h+|K+|k+|M+|m+|S+|s+|u+|W+|w+|Y+|y+|Z+|z+/g;
	// This date is re-used for processing
	var d1 = new Date();

	/**
	 * Object that parses an Options object and normalizes it to options.
	 * @class module:barejs/polyfill/Intl.DateTimeFormat~DateTimeFormatOptions
	 */
	function DateTimeFormatOptions( _options )
	{
	    // Date
	    this._conditionalSet( _options, "year",         DATE_NUMBER );
	    this._conditionalSet( _options, "month",        DATE_BOTH );
	    this._conditionalSet( _options, "day",          DATE_NUMBER );
	    this._conditionalSet( _options, "weekday",      DATE_TEXT );

	    // Time
	    this._conditionalSet( _options, "hour",         DATE_NUMBER );
	    this._conditionalSet( _options, "minute",       DATE_NUMBER );
	    this._conditionalSet( _options, "second",       DATE_NUMBER );

	    this._conditionalSet( _options, "weekday",      DATE_TEXT );
	    this._conditionalSet( _options, "hour12",       BOOLEAN );
	    this._conditionalSet( _options, "timeZoneName", NAME );
	}

	ObjectPolyfill.defineProperties( DateTimeFormatOptions.prototype,
	/** @lends module:barejs/polyfill/Intl.DateTimeFormat~DateTimeFormatOptions# */
	{
	    localeMatcher: { writable: true, value: null },
	    timeZone: { writable: true, value: null },
	    hour12: { writable: true, value: null },
	    formatMatcher: { writable: true, value: null },
	    weekday: { writable: true, value: null },
	    era: { writable: true, value: null },
	    year: { writable: true, value: null },
	    month: { writable: true, value: null },
	    day: { writable: true, value: null },
	    hour: { writable: true, value: null },
	    minute: { writable: true, value: null },
	    second: { writable: true, value: null },
	    timeZoneName: { writable: true, value: null },

	    /**
	     * Helper function. If _property is present on _options, will assign the value to this (with the
	     * same _property name), and validate the value against _validValues while doing so.
	     * @param _options {Object} The options to validate
	     * @param _property {String} The name of the property
	     * @param _validValues {Array} The list of valid values
	     */
	    _conditionalSet:
	    {
	        value: function( _options, _property, _validValues )
	        {
	            if ( typeof _options[ _property ] !== "undefined" )
	            {
	                if ( !_validValues.includes( this[ _property ] = _options[ _property ] ) )
	                    throw new RangeError( "Invalid value for " + _property + ": " + _options[ _property ] );
	            }
	        }
	    }
	} );

	/**
	 * Supports NUMERICAL formatting of dates, according to the formatting patterns described on
	 * http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns
	 * Warning: does NOT support formats like MMMM which should be localized. This method should only
	 * be used to produce a fixed date format. It also doesn't support identifiers that require
	 * knowledge of a specific calendar system, like "day of the week" or "era".
	 * @param _date {Date} The date to format
	 * @param _formatString {String} The formatString to use.
	 * @param _utc {Boolean} Optional: set to true to use the UTC time zone instead of local.
	 * @returns {String} _date formatted as String using _pattern.
	 * @memberof module:barejs/polyfill/Intl.DateTimeFormat~
	 */
	function formatDateTime( _date, _formatString, _utc )
	{
	    // Always assign to d1 so we convert a number to a date, and can safely modify the
	    // date object to adjust for the time zone
	    d1.setTime( _date || Date.now() );
	    _utc = _utc === true; // ensure boolean

	    return String( _formatString ).replace( reReplace, function( _match )
	    {
	        var v; // value; used by most format specifiers
	        var c = _match.charAt( 0 ); // The first (and every) character of the matched pattern
	        var l = _match.length; // short alias for _match.length.

	        // First, grab values. Some values early out by returning immediately or throwing an error.
	        switch ( c )
	        {
	            //
	            // Values
	            //
	            case "y": // Year
	                v = _utc ? d1.getUTCFullYear() : d1.getFullYear();
	                // So two-digit years are a stupid idea (where's the cut-off point?!).
	                // As a formatter, we just take the last two digits and don't care about a cut-off.
	                // This does mean that 1894 and 1994 will both produce 94, which can't be distinguished.
	                // The alternative would be a configurable cut-off year, but the best alternative
	                // would be for people to stop chopping away significant digits.
	                if ( l === 2 )
	                    v %= 100;
	                break;
	            case "M": // Month
	                v = ( _utc ? d1.getUTCMonth() : d1.getMonth() ) + 1; // compensate for 0 based
	                break;
	            case "d": // Day in month
	                v = _utc ? d1.getUTCDate() : d1.getDate();
	                break;
	            case "D": // Day of year
	                // Start by making v a new UTC date on January 1st of the same year.
	                // Using UTC will avoid DST differences.
	                v = new Date( Date.UTC( d1.getUTCFullYear(), 0, 1, d1.getUTCHours(), d1.getUTCMinutes(), d1.getUTCSeconds(), d1.getUTCMilliseconds() ) );
	                // Calculate the number of days and make the value 1 based.
	                // Although we expect an integer result (due to the usage of UTC), round the result
	                // in case the browser included leap seconds, or some other unforeseen difference.
	                v = Math.round( ( d1.getTime() - v.getTime() ) / 86400000 ) + 1;
	                break;
	            case "E": // Day of week - Sunday is always day 1
	                v = ( _utc ? d1.getUTCDay() : d1.getDay() ) + 1;
	                break;
	            case "H": // Hour [0-23]
	            case "h": // Hour [1-12]
	            case "K": // Hour [0-11]
	            case "k": // Hour [1-24]
	                v = _utc ? d1.getUTCHours() : d1.getHours();
	                // v is now [0-23]
	                switch ( c )
	                {
	                    case 'h':
	                        v = ( v % 12 ) || 12; // translate to [1-12]
	                        break;
	                    case 'K':
	                        v = ( v % 12 );       // translate to [0-11]
	                        break;
	                    case 'k':
	                        v = v || 24;          // translate to [1-24]
	                        break;
	                }
	                break;
	            case "m": // Minute
	                v = _utc ? d1.getUTCMinutes() : d1.getMinutes();
	                break;
	            case "s": // Second
	                v = _utc ? d1.getUTCSeconds() : d1.getSeconds();
	                break;
	            case "S": // Fractional Second - rounds to the count of letters
	                v = Math.round( ( _utc ? d1.getUTCMilliseconds() : d1.getMilliseconds() ) * Math.pow( 10, l - 3 ) );
	                break;

	            //
	            // Instant return
	            //
	            case "a": // AM or PM
	                if ( l > 1 )
	                    throw new RangeError( "Invalid pattern: " + _match + ", a maximum of 1 character is allowed" );
	                // Note: am/pm this should actually be localised. However, we're allowing this
	                // since the 12 hour format would be useless otherwise.
	                v = _utc ? d1.getUTCHours() : d1.getHours();
	                return v < 12 ? "am" : "pm";
	            case "Z": // Time zone. 1: GMT format, 2: RFC 822
	                if ( l > 2 )
	                    throw new RangeError( "Invalid pattern: " + _match + ", a maximum of 2 characters is allowed" );
	                if ( _utc && ( l === 2 ) )
	                    return "Z";
	                v = _utc ? 0 : -d1.getTimezoneOffset();
	                // Translate v to +-00:00 syntax
	                v = ( v < 0 ? "-" : "+" ) +
	                    padStart( Math.floor( v / 60 ), 2, "0" ) +
	                    ":" + padStart( v % 60, 2, "0" );
	                // And immediately return
	                return ( l === 1 ? "GMT" + v : v );

	            //
	            // Unsupported
	            //
	            /*
	            case "A": // Milliseconds in day
	            case "e": // Day of week - Local (calendar based)
	            case "F": // Day of Week in Month.
	            case "G": // Era
	            case "g": // Modified Julian day.
	            case "u": // Extended year
	            case "W": // Week of month
	            case "w": // Week of year
	            case "Y": // Year (of "Week of Year"), used in ISO year-week calendar. May differ from calendar year.
	            case "z": // Timezone. 1: short wall (generic), 2: long wall, 3: short time zone (i.e. PST) 4: full name (Pacific Standard Time).
	            */
	            default:
	                throw new Error( "format identifier " + _match.charAt( 0 ) + "is not supported by this method" );
	        }

	        // Process values
	        switch ( c )
	        {
	            // Two digit maximum, more is invalid
	            case "H": // Hour [0-23]
	            case "h": // Hour [1-12]
	            case "K": // Hour [0-11]
	            case "k": // Hour [1-24]
	            case "m": // Minute
	            case "s": // Second
	                if ( l > 2 )
	                    throw new RangeError( "Invalid pattern: " + _match + ", a maximum of 2 characters is allowed" );
	                break;

	            // Three digit maximum, more is invalid
	            case "D": // Day of year
	                if ( l > 3 )
	                    throw new RangeError( "Invalid pattern: " + _match + ", a maximum of 3 characters is allowed" );
	                break;

	            // Five digit maximum, but only two digits are not localised.
	            case "M": // Month
	            case "d": // Day in month
	            case "E": // Day of week - Sunday is always day 1
	                if ( l > 5 )
	                    throw new RangeError( "Invalid pattern: " + _match + ", a maximum of 5 characters is allowed" );
	                if ( l > 2 )
	                    throw new RangeError( "Pattern: " + _match + ", requires localisation, which is not supported by format" );
	                break;

	            // Unlimited repeat allowed (no validation needed)
	            /*
	            case "y": // Year
	            case "S": // Fractional Second
	                break;
	            */
	        }

	        /*
	        if ( ( maxLen > 0 ) && ( l > maxLen ) )
	            throw new RangeError( "Invalid pattern: " + _match + ", a maximum of " + maxLen + " characters is allowed" );
	        */

	        // If we get here, we can just return value (possibly padding it to length).
	        return l > 1 ? padStart( v, l, "0" ) : v;
	    } );
	}

	/**
	 * Provides Date/Time formatting
	 * @class module:barejs/polyfill/Intl.DateTimeFormat
	 * @extends module:barejs/polyfill/Intl~Format
	 */
	function DateTimeFormat( _locales, _options )
	{
	    Format.call( this, _locales, new DateTimeFormatOptions( Object( _options ) ) );
	}

	DateTimeFormat.prototype = Object.create( Format.prototype,
	/** @lends module:barejs/polyfill/Intl.DateTimeFormat# */
	{
	    format:
	    {
	        enumerable: true,
	        value: function format( _value )
	        {
	            var parts = []; // used to build the date and/or time part
	            var fmt = []; // used to build the end format

	            switch ( this._options.year )
	            {
	                case "2-digit":
	                    parts.push( "yy" );
	                    break;
	                case "numeric":
	                    parts.push( "yyyy" );
	                    break;
	            }

	            switch ( this._options.month )
	            {
	                case "narrow":
	                case "short":
	                case "long":
	                    // No actual implementation, default to 2-digit
	                case "2-digit":
	                    parts.push( "MM" );
	                    break;
	                case "numeric":
	                    parts.push( "M" );
	                    break;
	            }

	            switch ( this._options.day )
	            {
	                case "2-digit":
	                    parts.push( "dd" );
	                    break;
	                case "numeric":
	                    parts.push( "d" );
	                    break;
	            }

	            if ( parts.length > 0 )
	            {
	                fmt.push( parts.join( "-" ) );
	                parts.length = 0; // reset for time part
	            }

	            switch ( this._options.hour )
	            {
	                case "2-digit":
	                    parts.push( "HH" );
	                    break;
	                case "numeric":
	                    parts.push( "H" );
	                    break;
	            }

	            switch ( this._options.minute )
	            {
	                case "2-digit":
	                    parts.push( "mm" );
	                    break;
	                case "numeric":
	                    parts.push( "m" );
	                    break;
	            }

	            switch ( this._options.second )
	            {
	                case "2-digit":
	                    parts.push( "ss" );
	                    break;
	                case "numeric":
	                    parts.push( "s" );
	                    break;
	            }

	            if ( parts.length > 0 )
	                fmt.push( parts.join( ":" ) );

	            // DateTimeFormat defaults to formatting year/month/day if no options where specified.
	            if ( fmt.length < 1 )
	                fmt.push( "yyyy-MM-dd" );

	            return formatDateTime( _value, fmt.join( " " ) );
	        }
	    }
	} );

	return DateTimeFormat;

	}( __webpack_require__( 2 ), __webpack_require__( 28 ) ) );


/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( ObjectPolyfill, bcp47 )
	{
	"use strict";
	/*global navigator*/

	/**
	 * These classes are NOT a polyfill, and are not meant to be!
	 * They provide a poor man's fallback for the Intl formatters, for non-compliant environments.
	 */

	var LOCALE = ( function( navigator )
	{
	    try
	    {
	        return bcp47.getCanonicalLocales( ( navigator && ( navigator.language || navigator.userLanguage ) ) || "en-US" )[ 0 ];
	    }
	    catch ( ex )
	    {
	        return "en-US";
	    }
	}( typeof navigator !== "undefined" ? navigator : null ) );


	/**
	 * Base class for objects that perform formatting based on locale and options
	 * @class module:barejs/polyfill/Intl~Format
	 * @param _locales
	 * @param _options
	 */
	function Format( _locales, _options )
	{
	    // We can't accept custom locales since we don't polyfill any culture data.
	    // Always format using the environment locale(!)
	    ObjectPolyfill.defineProperties( this,
	    {
	        _locale: { value: LOCALE },
	        _options: { value: _options }
	    } );
	}

	ObjectPolyfill.defineProperties( Format.prototype,
	/** @lends module:barejs/polyfill/Intl~Format# */
	{
	    _locale: { value: null },
	    _options: { value: null },

	    /**
	     * Get the resolvedOptions
	     * @function
	     * @return {Object} The options
	     */
	    resolvedOptions:
	    {
	        value: function resolvedOptions()
	        {
	            // Create a new object with a locale on it, and copy the options to it.
	            return Object.assign( { locale: this._locale }, this._options );
	        }
	    },

	    /**
	     * Format a value
	     * @param {any} _value
	     * @return {String} The formatted value.
	     */
	    format:
	    {
	        enumerable: true,
	        value: function( _value )
	        {
	            return _value ? _value.toLocaleString() : "";
	        }
	    }
	} );

	return ObjectPolyfill.defineProperty( Format, "envLocale", { value: LOCALE } );

	}( __webpack_require__( 2 ), __webpack_require__( 29 ) ) );


/***/ }),
/* 29 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	( function( exports, ObjectPolyfill )
	{
	"use strict";

	// Instead of fully validating the tag, we match any string that starts with two or three [a-z] characters,
	// followed by any number of -[a-z0-9] suffixes.
	var reTag = /^(i|[a-zA-Z]{2,3})((?:\-[a-zA-Z0-9]+)*)$/;

	var reFormat = /^[a-zA-Z]+|\-\w+/g;

	function bcp47Replace( _match, _offset )
	{
	    /*
	     * Formatting follows simple rules:
	     *  > if NOT the first entry
	     *      > Length 2: UPPER case
	     *      > Length 4: Title case
	     *  > lower case
	     * For any match that is not the first (_offset is 0), take into account '-' is in the match
	     */
	    var len = _offset ? _match.length : 0;
	    return len === 3 ? // +1 for '-'
	        _match.toUpperCase() :
	        len === 5 ? // +1 for '-'
	            _match.substr( 0, 2 ).toUpperCase() + _match.substr( 2 ).toLowerCase() :
	            _match.toLowerCase();
	}

	function isStructurallyValidLanguageTag( _tag )
	{
	    // With the current implementation, the type check for string is unnecessary.
	    return /*typeof _tag === "string" &&*/ reTag.test( _tag );
	}

	function canonicalizeLanguageTag( _tag )
	{
	    // Officially this validation should be performed before calling this function,
	    // but with this limited implementation it's more convenient to perform it here.
	    var tag = String( _tag );
	    if ( !isStructurallyValidLanguageTag( tag ) )
	        throw new RangeError( "Invalid language tag: " + tag );
	    return tag.replace( reFormat, bcp47Replace );
	}

	/**
	 * @memberof module:barejs/polyfill/Intl
	 * @param {String|Array} _locales
	 * @return {String[]} List of canonical locale tags.
	 */
	exports.getCanonicalLocales = function getCanonicalLocales( _locales )
	{
	    var seen;

	    if ( _locales === undefined )
	    {
	        seen = new Array( 0 );
	    }
	    else if ( typeof _locales === "string" )
	    {
	        seen = new Array( 1 );
	        seen[ 0 ] = canonicalizeLanguageTag( _locales );
	    }
	    else
	    {
	        seen = [];
	        var locales = ObjectPolyfill.toObject( _locales );
	        var len = locales.length || 0;
	        for ( var i = 0; i < len; ++i )
	        {
	            var tag = canonicalizeLanguageTag( locales[ i ] );
	            if ( seen.indexOf( tag ) < 0 )
	                seen.push( tag );
	        }
	    }

	    return seen;
	};

	}( module.exports, __webpack_require__( 2 ) ) );


/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2018
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function( Format )
	{
	"use strict";
	/**
	 * These classes are NOT a polyfill, and are not meant to be!
	 * They provide a poor man's fallback for the Intl formatters, for non-compliant environments.
	 */

	var reCurrencyCode = /^[A-Z]{3}$/;
	var nbsp = String.fromCharCode( 160 );

	/**
	 * Object that parses an Options object and normalizes it to options.
	 * @class module:barejs/polyfill/Intl.NumberFormat~NumberFormatOptions
	 */
	function NumberFormatOptions( _options )
	{
	    // MinimumFractionDigits is usually 0
	    this.minimumFractionDigits = 0;
	    this.maximumFractionDigits = 3;
	    this.minimumIntegerDigits = 1;
	    this.numberingSystem = "latn";
	    this.useGrouping = true;

	    switch ( "style" in _options ? _options.style : "decimal" )
	    {
	        case "percent":
	            this.style = "percent";
	            this.maximumFractionDigits = Math.max( 0, this.minimumFractionDigits );
	            break;
	        case "currency":
	            this.style = "currency";
	            if ( !_options.currency )
	                throw new TypeError( "Currency code is required with currency style." );
	            if ( ( typeof _options.currency !== "string" ) || !reCurrencyCode.test( _options.currency ) )
	                throw new TypeError( "Invalid currency code:" + _options.currency );
	            this.currency = _options.currency;
	            this.currencyDisplay = "code"; // This is all the fallback supports!
	            this.maximumFractionDigits = Math.max( 2, this.minimumFractionDigits );
	            break;
	        case "decimal":
	            this.style = "decimal";
	            break;

	        default:
	            throw new RangeError( "Value " + _options.style + " out of range for numberformat options property style" );
	    }
	}


	/**
	 * Provides number formatting
	 * @class module:barejs/polyfill/Intl.NumberFormat
	 * @extends module:barejs/polyfill/Intl~Format
	 */
	function NumberFormat( _locales, _options )
	{
	    Format.call( this, _locales, new NumberFormatOptions( Object( _options ) ) );
	}

	NumberFormat.prototype = Object.create( Format.prototype,
	/** @lends module:barejs/polyfill/Intl.NumberFormat# */
	{
	    constructor: { writable: true, value: NumberFormat },

	    format:
	    {
	        enumerable: true,
	        value: function format( _value )
	        {
	            if ( _value === null || typeof _value === "undefined" )
	                return "";
	            var value = +_value;
	            var prefix = "";
	            var suffix = "";

	            if ( isNaN( value ) )
	                return "NaN";

	            switch( this._options.style )
	            {
	                case "percent":
	                    value *= 100;
	                    suffix = "%";
	                    break;

	                case "currency":
	                    prefix = this._options.currency + nbsp;
	                    break;
	            }

	            // We're currently ignoring min/max decimal places (which is bad).
	            return prefix + value.toLocaleString() + suffix;
	        }
	    }
	} );

	return NumberFormat;

	}( __webpack_require__( 28 ) ) );


/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	var NMap = __webpack_require__( 3 );
	// Check for iterator support
	module.exports = ( (6) >= 6 ) || ( "entries" in NMap.prototype ) ? NMap : /*istanbul ignore next*/ __webpack_require__( 4 );


/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	var NSet = __webpack_require__( 6 );
	// Check for iterator support
	module.exports = ( (6) >= 6 ) || ( "entries" in NSet.prototype ) ? NSet : /*istanbul ignore next*/ __webpack_require__( 7 );


/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	/*global Promise*/

	module.exports = ( (6) >= 6 ) || ( typeof Promise !== "undefined" ) ? Promise : /*istanbul ignore next*/ __webpack_require__( 34 );


/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

	module.exports = ( function(
	        ObjectPolyfill,
	        setImmediate
	    )
	{
	    "use strict";

	    /*jshint latedef:false*/

	    /**
	     * Helper method that turns an _iterable into an array of promises
	     * @memberof module:barejs/polyfill.Promise~
	     * @private
	     */
	    function iterableToPromiseArray( _iterable )
	    {
	        var promises;
	        var it;
	        var value;

	        if ( _iterable.length || _iterable.length === 0 )
	        {
	            promises = new Array( _iterable.length );
	            for ( var i = 0, len = _iterable.length; i < len; ++i )
	            {
	                value = _iterable[i];
	                if ( ( !value ) || ( typeof value.then !== "function" ) )
	                    value = Promise.resolve( value );
	                promises[i] = value;
	            }
	        }
	        else if ( ( it = ObjectPolyfill.getIterator( _iterable ) ) )
	        {
	            promises = [];
	            for( value = it.next(); !value.done; value = it.next() )
	            {
	                if ( ( !value.value ) || ( typeof value.value.then !== "function" ) )
	                    promises.push( Promise.resolve( value.value ) );
	                else
	                    promises.push( value.value );
	            }
	        }
	        else
	        {
	            throw new Error( "Invalid iterable" );
	        }

	        return promises;
	    }

	    /**
	     * Handler for a promise
	     * @class module:barejs/polyfill.Promise~Handler
	     * @private
	     */
	    function Handler( _onFulfilled, _onRejected, _promise )
	    {
	        this.onFulfilled = typeof _onFulfilled === "function" ? _onFulfilled : null;
	        this.onRejected = typeof _onRejected === "function" ? _onRejected : null;
	        this.promise = _promise;
	    }

	    /**
	     * No-operation function
	     */
	    function noop() {}

	    // States:
	    //
	    // 0 - pending
	    // 1 - fulfilled with _value
	    // 2 - rejected with _value
	    // 3 - adopted the state of another promise, _value
	    //
	    // once the state is no longer pending (0) it is immutable

	    // All `_` prefixed properties will be reduced to `_{random number}`
	    // at build time to obfuscate them and discourage their use.
	    // We don't use symbols or Object.defineProperty to fully hide them
	    // because the performance isn't good enough.

	    // to avoid using try/catch inside critical functions, we
	    // extract them to here.
	    var LAST_ERROR = null;
	    var IS_ERROR = {};

	    /**
	     * Safely request the then function from an object
	     */
	    function getThen( _obj )
	    {
	        try
	        {
	            return _obj.then;
	        }
	        catch ( ex )
	        {
	            LAST_ERROR = ex;
	            return IS_ERROR;
	        }
	    }

	    function tryCallOne( _fn, _a )
	    {
	        try
	        {
	            return _fn( _a );
	        }
	        catch ( ex )
	        {
	            LAST_ERROR = ex;
	            return IS_ERROR;
	        }
	    }
	    function tryCallTwo( _fn, _a, _b )
	    {
	        try
	        {
	            _fn( _a, _b );
	        }
	        catch ( ex )
	        {
	            LAST_ERROR = ex;
	            return IS_ERROR;
	        }
	    }

	    /**
	     * Create a new Promise
	     * @class module:barejs/polyfill.Promise
	     * @param {function} _resolver The resolver function that will be called with two callbacks:
	     * _resolve (call on succes) and _reject (call on failure).
	     */
	    function Promise( _resolver )
	    {
	        if ( typeof this !== "object" )
	            throw new TypeError( "Promises must be constructed via new" );

	        this._state = 0;
	        this._value = null;
	        this._deferreds = [];
	        if ( ObjectPolyfill.ensureCallable( _resolver ) === noop )
	            return;
	        doResolve( _resolver, this );
	    }

	    function safeThen( _self, _onFulfilled, _onRejected )
	    {
	        return new _self.constructor( function( resolve, reject )
	        {
	            var res = new Promise( noop );
	            res.then( resolve, reject );
	            handle( _self, new Handler( _onFulfilled, _onRejected, res ) );
	        } );
	    }

	    function handle( _self, _deferred )
	    {
	        while ( _self._state === 3 )
	        {
	            _self = _self._value;
	        }
	        if ( _self._state === 0 )
	        {
	            _self._deferreds.push( _deferred );
	            return;
	        }

	        setImmediate( function()
	        {
	            var cb = _self._state === 1 ? _deferred.onFulfilled : _deferred.onRejected;
	            if ( cb === null )
	            {
	                if ( _self._state === 1 )
	                {
	                    resolve( _deferred.promise, _self._value );
	                }
	                else
	                {
	                    reject( _deferred.promise, _self._value );
	                }
	                return;
	            }
	            var ret = tryCallOne( cb, _self._value );
	            if ( ret === IS_ERROR )
	            {
	                reject( _deferred.promise, LAST_ERROR );
	            }
	            else
	            {
	                resolve( _deferred.promise, ret );
	            }
	        } );
	    }

	    function resolve( _self, _newValue )
	    {
	        // Promise Resolution Procedure:
	        // https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
	        if ( _newValue === _self )
	        {
	            return reject( _self, new TypeError( 'A promise cannot be resolved with itself.' ) );
	        }
	        if ( _newValue && (typeof _newValue === "object" || typeof _newValue === "function") )
	        {
	            var then = getThen( _newValue );
	            if ( then === IS_ERROR )
	            {
	                return reject( _self, LAST_ERROR );
	            }
	            if ( then === _self.then && ( _newValue instanceof Promise ) )
	            {
	                _self._state = 3;
	                _self._value = _newValue;
	                finale( _self );
	                return;
	            }
	            else if ( typeof then === "function" )
	            {
	                doResolve( then.bind( _newValue ), _self );
	                return;
	            }
	        }
	        _self._state = 1;
	        _self._value = _newValue;
	        finale( _self );
	    }

	    function reject( _self, _newValue )
	    {
	        _self._state = 2;
	        _self._value = _newValue;
	        finale( _self );
	    }

	    function finale( _self )
	    {
	        for ( var i = 0; i < _self._deferreds.length; ++i )
	            handle( _self, _self._deferreds[ i ] );

	        _self._deferreds = null;
	    }

	    /**
	     * Take a potentially misbehaving resolver function and make sure onFulfilled and onRejected
	     * are only called once.
	     *
	     * Makes no guarantees about asynchrony.
	     * @memberof module:barejs/polyfill.Promise~
	     * @private
	     */
	    function doResolve( _resolver, _promise )
	    {
	        var done = false;
	        var res = tryCallTwo( _resolver, function( value )
	        {
	            if ( done )
	                return;
	            done = true;
	            resolve( _promise, value );
	        }, function( reason )
	        {
	            if ( done )
	                return;
	            done = true;
	            reject( _promise, reason );
	        } );
	        if ( !done && res === IS_ERROR )
	        {
	            done = true;
	            reject( _promise, LAST_ERROR );
	        }
	    }

	    return ObjectPolyfill.polyfill( Promise,
	    /** @lends module:barejs/polyfill.Promise */
	    {
	        _noop: noop,

	        /**
	         * The Promise.resolve( _value ) method returns a Promise object that is resolved with the given value.
	         * If the value is a thenable (i.e. has a then method), the returned promise will "follow" that thenable,
	         * adopting its eventual state; otherwise the returned promise will be fulfilled with the value.
	         * @param {*} _value The value to resolve with.
	         * @returns {module:barejs/polyfill.Promise} A Promise that is resolved with _value.
	         */
	        resolve: function resolve( _value )
	        {
	            return new Promise( function( _resolve, _reject )
	            {
	                _resolve( _value );
	            } );
	        },

	        /**
	         * The Promise.reject( _reason ) method returns a Promise object that is rejected with the given reason.
	         * @param {*} _reason The rejection reason (passed as rejection argument).
	         * @returns {module:barejs/polyfill.Promise} A Promise that is rejected with _reason.
	         */
	        reject: function reject( _reason )
	        {
	            return new Promise( function( _resolve, _reject )
	            {
	                _reject( _reason );
	            } );
	        },

	        /**
	         * The Promise.all( _iterable ) method returns a promise that resolves when all of the promises
	         * in the iterable argument have resolved. If any of the passed in promises rejects, the all
	         * Promise immediately rejects with the value of the promise that rejected, discarding all the
	         * other promises whether or not they have resolved.
	         * @param _iterable {Object} Array that can be iterated.
	         * @returns {module:barejs/polyfill.Promise} A promise that will resolve with an array of values corresponding to all Promises in _iterable, after every Promise is resolved.
	         */
	        all: function all( _iterable )
	        {
	            var promises = iterableToPromiseArray( _iterable );

	            if ( promises.length < 1 )
	                return Promise.resolve( promises );

	            return new Promise( function( _resolve, _reject )
	            {
	                var values = new Array( promises.length );
	                var resolveCount = 0;

	                function rejected( _reason )
	                {
	                    if ( values )
	                    {
	                        _reject( _reason );
	                        values = null;
	                    }
	                }

	                function resolved( _index, _value )
	                {
	                    if ( values )
	                    {
	                        // Promises should never resolve twice, so we don't perform any sanity checking
	                        // to see if values.hasOwnProperty( _index )...
	                        values[_index] = _value;
	                        if ( ++resolveCount >= values.length )
	                        {
	                            _resolve( values );
	                            values = null;
	                        }
	                    }
	                }

	                for ( var i = 0, len = promises.length; i < len; ++i )
	                    promises[i].then( resolved.bind( null, i ), rejected );
	            } );
	        },

	        /**
	         * The Promise.race( _iterable ) method returns a promise that resolves or rejects as soon as one
	         * of the promises in the iterable resolves or rejects, with the value or reason from that promise.
	         * @returns {module:barejs/polyfill.Promise} A promise that will resolve with the value of the first Promise to resolve.
	         */
	        race: function race( _iterable )
	        {
	            var promises = iterableToPromiseArray( _iterable );

	            return new Promise( function( _resolve, _reject )
	            {
	                var isResolved = false;

	                function rejected( _reason )
	                {
	                    if ( !isResolved )
	                    {
	                        _reject( _reason );
	                        isResolved = true;
	                    }
	                }

	                function resolved( _value )
	                {
	                    if ( !isResolved )
	                    {
	                        _resolve( _value );
	                        isResolved = true;
	                    }
	                }

	                for ( var i = 0, len = promises.length; i < len; ++i )
	                    promises[i].then( resolved, rejected );
	            } );
	        }
	    },
	    /** @lends module:barejs/polyfill.Promise# */
	    {
	        /**
	         * Register either a resolve or reject callback, or both.
	         * @returns {module:barejs/polyfill.Promise} A promise that will resolve or reject with the value returned by (or thrown from) _onFulfilled or _onRejected.
	         */
	        then: function( _onFulfilled, _onRejected )
	        {
	            if ( this.constructor !== Promise )
	                return safeThen( this, _onFulfilled, _onRejected );

	            var res = new Promise( noop );
	            handle( this, new Handler( _onFulfilled, _onRejected, res ) );
	            return res;
	        },

	        /**
	         * Register a rejection callback (shortcut for then( null, _onRejected ) ).
	         * @returns {module:barejs/polyfill.Promise} A promise that will resolve or reject with the value returned by (or thrown from) _onRejected.
	         */
	        "catch": function( _onRejected )
	        {
	            return this.then( null, _onRejected );
	        }
	    }, null, "Promise" );
	}(
	    __webpack_require__( 2 ),
	    /* global setImmediate, setTimeout */
	    typeof setImmediate !== "undefined" ? setImmediate : setTimeout
	) );


/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

	// Licensed Materials - Property of IBM
	//
	// IBM Watson Analytics
	//
	// (C) Copyright IBM Corp. 2015
	//
	// US Government Users Restricted Rights - Use, duplication or
	// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
	module.exports = ( function( Error, decl )
	{
	"use strict";

	/**
	 * Interprets a line of a stack trace and tries to extract information from it.
	 * @param {string} _line The line to interpret
	 * @memberof module:barejs.Exception~
	 * @private
	 */
	/*istanbul ignore next: NodeJS has the Error.captureStackTrace method natively so this function will not be hit*/
	function splitStackLine( _line )
	{
	    /*
	    Expected input looks like:
	        myFunction@http://my.domain.com:8080/my/site/script.js:120:8    (Firefox, Safari)
	        @http://my.domain.com:8080/my/site/script.js:120:8              (Firefox)
	        http://my.domain.com:8080/my/site/script.js:120:8               (Safari)
	    */

	    if ( !_line )
	        return null;

	    var line = String( _line );
	    var result = new Array( 4 );

	    // Try to find a name (can be empty string)
	    var match = line.match( /^([^@]*)@/ );

	    result[0] = null;
	    if ( match )
	    {
	        result[0] = match[1] || null;
	        // Chop off the <functionName>@ part
	        line = line.substr( match[0].length );
	    }

	    // Try to find line and column number
	    match = line.match( /(:[0-9]+)?:([0-9]+)$/ );
	    if ( match )
	    {
	        if ( match[1] )
	        {
	            result[2] = parseInt( match[1].substr( 1 ), 10 );
	            result[3] = parseInt( match[2], 10 ) - 1;
	        }
	        else
	        {
	            result[2] = parseInt( match[2], 10 );
	            result[3] = null;
	        }

	        // Chop off the :LineNumber:ColumnNumber part
	        line = line.substr( 0, line.length - match[0].length );
	    }

	    // The result should be the filename
	    result[1] = line;

	    return result;
	}

	/*istanbul ignore next: NodeJS has the Error.captureStackTrace method natively so this function will not be hit*/
	function processStack( _obj, _ctor, _err )
	{
	    var fileName, lineNumber, columnNumber; // Additional metadata
	    var line, match; // used to parse the stack entries

	    var stack = _err.stack.split( "\n" ); // Split version of _err.stack

	    // Initialize fileName etc. to null
	    fileName = lineNumber = columnNumber = null;

	    if ( _ctor.name )
	    {
	        for ( line = 0; line < stack.length; ++line )
	        {
	            if ( stack[line].startsWith( _ctor.name + "@" ) )
	                break;
	        }
	        // Never remove the last entry
	        if ( line >= ( stack.length - 1 ) )
	            line = -1;
	    }
	    else
	    {
	        // We know for a fact the lowest entry can be ignored, unless it's the only entry
	        line = ( stack.length === 1 ) ? -1 : 0;
	    }

	    // If we get here and line >= 0, we can remove those entries
	    if ( line >= 0 )
	    {
	        stack = stack.slice( line + 1 );

	        match = splitStackLine( stack[0] );
	        if ( match )
	        {
	            fileName        = match[1];
	            lineNumber      = match[2];
	            columnNumber    = match[3];
	        }
	    }

	    decl.defineProperty( _obj, "stack", { configurable: true, value: stack.join( "\n" ) } );

	    if ( fileName )
	    {
	        decl.defineProperties( _obj,
	        {
	            fileName:       { configurable: true, value: fileName },
	            lineNumber:     { configurable: true, value: lineNumber },
	            columnNumber:   { configurable: true, value: columnNumber }
	        } );
	    }
	}

	/*istanbul ignore next: NodeJS has the Error.captureStackTrace method natively so this function will not be hit*/
	function captureStackTrace( _obj, _ctor, _err )
	{
	    if ( "stack" in _err )
	        processStack( _obj, _ctor, _err );
	    // if ( "opera#sourceLoc" in _err ) // Opera support?
	}

	/**
	 * The Exception constructor will set up the exception with a name and stack property. You can pass the "creator function"
	 * as second argument, this is the topmost function that will be ignored from the stack. It defaults to the constructed
	 * object's constructor, which ensures the "Exception" and parent constructors never show up in the stack.
	 * @class module:barejs.Exception
	 * @param {string} _message The message that describes the exception.
	 * @param {function} [_creatorFn] Optional: function to exclude from the call stack.
	 *                       Defaults to the this.constructor function.
	 *
	 * @classdesc Exception creates a normalized base class for creating custom Error (Exception) classes to throw.
	 * It handles determining the stack trace for the created exception in a cross browser way.
	 * This class relies on the constructor property being set correctly, otherwise sub-class constructors
	 * may show up in the stack trace. Using {@link module:barejs.decl#declareClass decl.declareClass}
	 * to define base classes ensures the constructor property is set correctly.
	 *
	 * Sub classes should also set the name property on the prototype to the name of the exception, for example:
	 *
	 *      function MyCustomError( _message, _myAdditionalData )
	 *      {
	 *          Exception.call( this, _message );
	 *
	 *          this.myAdditionalData = _myAdditionalData;
	 *      }
	 *
	 *      decl.declareClass( MyCustomError, Exception,
	 *      {
	 *          // Setting the name ensures our custom error looks and behaves as expected
	 *          // Avoid using MyCustomError.name (named function name) as the name may get
	 *          // mangled by a minifier/uglifier.
	 *          name: "MyCustomError",
	 *
	 *          myAdditionalData: null
	 *      } );
	 *
	 */
	function Exception( _message/*, _creatorFn*/ )
	{
	    if ( !this || !( this instanceof Exception ) )
	        throw new TypeError( "Invalid context for Exception. Did you forget the new keyword?" );

	    var fn = arguments[1] || this.constructor;
	    if ( typeof fn !== "function" )
	        throw new TypeError( "_creatorFn must be omitted, null or a function." );

	    /*istanbul ignore else: NodeJS has the Error.captureStackTrace method natively*/
	    if ( Error.captureStackTrace )
	        Error.captureStackTrace( this, fn );
	    else
	        captureStackTrace( this, fn, new Error() );

	    decl.defineProperty( this, "message", { configurable: true, writable: true, value: _message } );
	}

	return decl.declareClass( Exception, Error,
	/** @lends module:barejs.Exception# */
	{
	    /**
	     * The name of the Exception type. Base classes are supposed to set the correct name on the prototype too.
	     * It is recommended not to use the constructor function's name for this, as that might get obfuscated by
	     * a minifier, or the name property may not be supported at all.
	     * @member {string}
	     */
	    name: { configurable: true, writable: true, value: "Exception" }
	} );

	// End of module
	}( Error, __webpack_require__( 1 ) ) );


/***/ })
/******/ ]);