working on it ...

Filters

Explore Public Snippets

Sort by

Found 8 snippets

    public by rosskevin  280  0  3  0

    material-ui NotificationCenter

    material-ui NotificationCenter: NotificationCenter.js
    // @flow
    
    import Queue from 'es-collections/Queue'
    import Snackbar from '@alienfast/material-ui/Snackbar'
    import PropTypes from 'prop-types'
    import React, {Component} from 'react'
    import Logger from './util/Logger'
    import Performance from './util/Performance'
    import Button from './Button'
    
    // if test, shorten duration for multiple messages - saves ~9 seconds on reset_password.feature
    const DefaultDuration = __TEST__ ? 750 : 3000
    
    type Props = {}
    
    type State = {
      queueSize: number,
      status: 'queueSizeChanged' | 'exited'
    }
    
    type Notification = {
      message: string,
      duration?: number,
      delay?: number,
      action?: string,
      onAction?: Function
    }
    
    const EmptyNotification = {
      message: ''
    }
    
    class NotificationCenter extends Component<void, Props, State> {
      static contextTypes = {
        eventBus: PropTypes.object.isRequired
      }
      props: Props
      state: State = {
        queueSize: 0,
        status: 'exited'
      }
      subscriptions: Array<EmitterSubscription>
      queue: Queue
      notification: ?Notification = EmptyNotification
    
      componentWillMount () {
        log.debug('componentWillMount')
        this.queue = new Queue()
        const { eventBus } = this.context
        // eventBus.registerEvent('NotificationCenter', 'notification')
        this.subscriptions = eventBus.subscribe('notification', this.handleNotification)
      }
    
      componentWillUnmount () {
        log.debug('componentWillUnmount')
        const { eventBus } = this.context
        eventBus.unsubscribe(this.subscriptions)
      }
    
      shouldComponentUpdate (nextProps: Props, nextState: State, nextContext: any) {
        //log.debug('shouldComponentUpdate', this.queue.size)
    
        // check to see if we are still showing the current notification
        const peek = this.queue.peek()
        //log.debug('compare notifications', this.notification === peek, this.notification, peek)
        if (this.notification === peek) {
          return false
        }
    
        return Performance.shouldComponentUpdate(this, nextProps, nextState, nextContext, true)
      }
    
      updateQueueSize () {
        this.setState({
          queueSize: this.queue.size,
          status: 'queueSizeChanged'
        })
      }
    
      handleNotification = (notification: Notification) => {
        const { delay } = notification
        const enqueue = () => {
          this.queue.enqueue(notification)
          log.debug('handleNotification', this.queue.size, notification)
          this.updateQueueSize()
        }
    
        if (delay) {
          setTimeout(enqueue, delay)
        } else {
          enqueue()
        }
      }
    
      handleRequestClose = (event: ?SyntheticUIEvent, reason: string, onAction?: Function) => {
        log.debug('handleRequestClose', reason, onAction, this.notification)
        const { duration } = (this.notification ? this.notification : {}) // wacky flow maybe type
        if (reason === 'clickaway' && !duration === 0) {  // allow clickaway on duration 0
          log.debug(reason)
        } else {
          if (onAction) {
            onAction()
          }
          this.queue.dequeue()
          this.updateQueueSize()
        }
      }
    
      handleExited = () => {
        log.debug('handleExited', this.notification)
        this.setState({ status: 'exited' })
      }
    
      render () {
        const { status } = this.state
        const size = this.queue.size
        let open
        let shownNotification: ?Notification
    
        if (size === 0) {
          // We must render the snackbar with an empty notification and close it so
          //  that we still achieve the ease out effect.
          shownNotification = this.notification
          this.notification = EmptyNotification
          open = false
        } else if (status === 'queueSizeChanged' && this.notification !== EmptyNotification) {
          // allow this message to exit
          shownNotification = this.notification
          open = false
        } else {
          // ready to display a new message from the queue
          shownNotification = this.notification = this.queue.peek()
          open = true
        }
    
        const { message, action: actionString, duration, onAction } = (shownNotification || {})
    
        // from the action string, create a button to trigger the action and dismiss the snackbar
        let action
        if (actionString) {
          action = [
            <Button
              key={actionString}
              color='accent'
              dense
              onClick={() => onAction ? onAction() : null}
            >
              {actionString}
            </Button>
          ]
        }
    
        const snackbarProps = {
          open,
          autoHideDuration: (duration === undefined ? DefaultDuration : duration)
        }
        log.debug('render Queue size:', size, ' status: ', status, message, snackbarProps)
    
        return (
          <Snackbar
            key={message}
            {...snackbarProps}
            action={action}
            onRequestClose={this.handleRequestClose}
            onExited={this.handleExited}
            SnackbarContentProps={{
              'aria-describedby': 'message-id'
            }}
            message={<span id='message-id'>{message}</span>}
          />
        )
      }
    }
    
    const log = Logger.get('NotificationCenter')
    
    log.debug('DefaultDuration', DefaultDuration, __TEST__)
    export default NotificationCenter
    
    
    

    public by rosskevin  242  0  3  0

    flow libdef for relay modern 1.2. This is in a _works for me_ state. Someone please export these properly from relay or create a proper flow-typed libdef.

    flow libdef for relay modern 1.2. This is in a _works for me_ state. Someone please export these properly from relay or create a proper flow-typed libdef.: relay.js
    // @flow
    
    declare module 'react-relay' {
      declare export type RecordState = 'EXISTENT' | 'NONEXISTENT' | 'UNKNOWN';
    
      declare export type onCompleted = (response: ?Object, errors: ?Array<PayloadError>) => void
      declare export type onError = (error: Error) => void
    
      declare export type CommitOptions = {
        onCompleted: onCompleted,
        onError: onError
      }
    
      /**
       * Ideally this would be a union of Field/Fragment/Mutation/Query/Subscription,
       * but that causes lots of Flow errors.
       */
      declare export type ConcreteBatchCallVariable = {
        jsonPath: string,
        kind: 'BatchCallVariable',
        sourceQueryID: string,
      }
      declare export type ConcreteCall = {
        kind: 'Call',
        metadata: {
          type?: ?string,
        },
        name: string,
        value: ?ConcreteValue,
      }
      declare export type ConcreteCallValue = {
        callValue: mixed,
        kind: 'CallValue',
      }
      declare export type ConcreteCallVariable = {
        callVariableName: string,
        kind: 'CallVariable',
      }
      declare export type ConcreteDirective = {
        args: Array<ConcreteDirectiveArgument>,
        kind: 'Directive',
        name: string,
      }
      declare export type ConcreteDirectiveArgument = {
        name: string,
        value: ?ConcreteDirectiveValue,
      }
      declare export type ConcreteDirectiveValue =
        | ConcreteCallValue
        | ConcreteCallVariable
        | Array<ConcreteCallValue | ConcreteCallVariable>
      declare export type ConcreteFieldMetadata = {
        canHaveSubselections?: ?boolean,
        inferredPrimaryKey?: ?string,
        inferredRootCallName?: ?string,
        isAbstract?: boolean,
        isConnection?: boolean,
        isConnectionWithoutNodeID?: boolean,
        isFindable?: boolean,
        isGenerated?: boolean,
        isPlural?: boolean,
        isRequisite?: boolean,
      }
      declare export type ConcreteFragmentMetadata = {
        isAbstract?: boolean,
        pattern?: boolean,
        plural?: boolean,
      }
      declare export type ConcreteMutation = {
        calls: Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        kind: 'Mutation',
        metadata: {
          inputType?: ?string,
        },
        name: string,
        responseType: string,
      };
      declare export type ConcreteOperationMetadata = {
        inputType?: ?string,
      }
      declare export type ConcreteQuery = {
        calls?: ?Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        fieldName: string,
        isDeferred?: boolean,
        kind: 'Query',
        metadata: {
          identifyingArgName?: ?string,
          identifyingArgType?: ?string,
          isAbstract?: ?boolean,
          isPlural?: ?boolean,
        },
        name: string,
        type: string,
      }
      declare export type ConcreteQueryMetadata = {
        identifyingArgName: ?string,
        identifyingArgType: ?string,
        isAbstract: ?boolean,
        isDeferred: ?boolean,
        isPlural: ?boolean,
      }
      declare export type ConcreteSubscription = {
        calls: Array<ConcreteCall>,
        children?: ?Array<?ConcreteSelection>,
        directives?: ?Array<ConcreteDirective>,
        kind: 'Subscription',
        name: string,
        responseType: string,
        metadata: {
          inputType?: ?string,
        },
      }
      declare export type ConcreteValue =
        | ConcreteBatchCallVariable
        | ConcreteCallValue
        | ConcreteCallVariable
        | Array<ConcreteCallValue | ConcreteCallVariable>
    
      /**
       * The output of a graphql-tagged fragment definition.
       */
      declare export type ConcreteFragmentDefinition = {
        kind: 'FragmentDefinition',
        argumentDefinitions: Array<ConcreteArgumentDefinition>,
        node: ConcreteFragment,
      }
    
      declare export type ConcreteLocalArgumentDefinition = {
        kind: 'LocalArgument',
        name: string,
        defaultValue: mixed,
      }
    
      declare export type ConcreteRootArgumentDefinition = {
        kind: 'RootArgument',
        name: string,
      }
    
      /**
       * The output of a graphql-tagged operation definition.
       */
      declare export type ConcreteOperationDefinition = {
        kind: 'OperationDefinition',
        argumentDefinitions: Array<ConcreteLocalArgumentDefinition>,
        name: string,
        operation: 'mutation' | 'query' | 'subscription',
        node: ConcreteFragment | ConcreteMutation | ConcreteSubscription,
      }
    
      declare export type ConcreteArgument = ConcreteLiteral | ConcreteVariable
      declare export type ConcreteArgumentDefinition =
        | ConcreteLocalArgument
        | ConcreteRootArgument
      /**
       * Represents a single ConcreteRoot along with metadata for processing it at
       * runtime. The persisted `id` (or `text`) can be used to fetch the query,
       * the `fragment` can be used to read the root data (masking data from child
       * fragments), and the `query` can be used to normalize server responses.
       *
       * NOTE: The use of "batch" in the name is intentional, as this wrapper around
       * the ConcreteRoot will provide a place to store multiple concrete nodes that
       * are part of the same batch, e.g. in the case of deferred nodes or
       * for streaming connections that are represented as distinct concrete roots but
       * are still conceptually tied to one source query.
       */
      declare export type ConcreteBatch = {
        kind: 'Batch',
        fragment: ConcreteFragment,
        id: ?string,
        metadata: { [key: string]: mixed },
        name: string,
        query: ConcreteRoot,
        text: ?string,
      }
      declare export type ConcreteCondition = {
        kind: 'Condition',
        passingValue: boolean,
        condition: string,
        selections: Array<ConcreteSelection>,
      }
      declare export type ConcreteField = ConcreteScalarField | ConcreteLinkedField
      declare export type ConcreteFragment = {
        argumentDefinitions: Array<ConcreteArgumentDefinition>,
        kind: 'Fragment',
        metadata: ?{ [key: string]: mixed },
        name: string,
        selections: Array<ConcreteSelection>,
        type: string,
      }
      declare export type ConcreteFragmentSpread = {
        args: ?Array<ConcreteArgument>,
        kind: 'FragmentSpread',
        name: string,
      }
      declare export type ConcreteHandle = ConcreteScalarHandle | ConcreteLinkedHandle
      declare export type ConcreteRootArgument = {
        kind: 'RootArgument',
        name: string,
        type: ?string,
      }
      declare export type ConcreteInlineFragment = {
        kind: 'InlineFragment',
        selections: Array<ConcreteSelection>,
        type: string,
      }
      declare export type ConcreteLinkedField = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        concreteType: ?string,
        kind: 'LinkedField',
        name: string,
        plural: boolean,
        selections: Array<ConcreteSelection>,
        storageKey: ?string,
      }
      declare export type ConcreteLinkedHandle = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'LinkedHandle',
        name: string,
        handle: string,
        key: string,
        filters: ?Array<string>,
      }
      declare export type ConcreteLiteral = {
        kind: 'Literal',
        name: string,
        type: ?string,
        value: mixed,
      }
      declare export type ConcreteLocalArgument = {
        defaultValue: mixed,
        kind: 'LocalArgument',
        name: string,
        type: string,
      }
      declare export type ConcreteNode =
        | ConcreteCondition
        | ConcreteLinkedField
        | ConcreteFragment
        | ConcreteInlineFragment
        | ConcreteRoot
      declare export type ConcreteRoot = {
        argumentDefinitions: Array<ConcreteLocalArgument>,
        kind: 'Root',
        name: string,
        operation: 'mutation' | 'query' | 'subscription',
        selections: Array<ConcreteSelection>,
      }
      declare export type ConcreteScalarField = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'ScalarField',
        name: string,
        storageKey: ?string,
      }
      declare export type ConcreteScalarHandle = {
        alias: ?string,
        args: ?Array<ConcreteArgument>,
        kind: 'ScalarHandle',
        name: string,
        handle: string,
        key: string,
        filters: ?Array<string>,
      }
      declare export type ConcreteSelection =
        | ConcreteCondition
        | ConcreteField
        | ConcreteFragmentSpread
        | ConcreteHandle
        | ConcreteInlineFragment
      declare export type ConcreteVariable = {
        kind: 'Variable',
        name: string,
        type: ?string,
        variableName: string,
      }
      declare export type ConcreteSelectableNode = ConcreteFragment | ConcreteRoot
      declare export type GeneratedNode = ConcreteBatch | ConcreteFragment
    
      // The type of a graphql`...` tagged template expression.
      declare export type GraphQLTaggedNode =
        | (() => ConcreteFragment | ConcreteBatch)
        | {
        modern: () => ConcreteFragment | ConcreteBatch,
        classic: () => ConcreteFragmentDefinition | ConcreteOperationDefinition,
      }
    
      declare export function graphql (strings: Array<string>): GraphQLTaggedNode
    
      declare export type GeneratedNodeMap = { [key: string]: GraphQLTaggedNode }
    
      declare export function createFragmentContainer<TBase: React$ComponentType<*>> (
        Component: TBase,
        fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap
      ): TBase
    
      declare export function createRefetchContainer<TBase: React$ComponentType<*>>(
        Component: TBase,
        fragmentSpec: GraphQLTaggedNode | GeneratedNodeMap,
        taggedNode: GraphQLTaggedNode,
      ): TBase
    
      declare export type Variables = { [name: string]: $FlowFixMe };
      declare export type DataID = string;
    
      declare type TEnvironment = Environment;
      declare type TFragment = ConcreteFragment;
      declare type TGraphQLTaggedNode = GraphQLTaggedNode;
      declare type TNode = ConcreteSelectableNode;
      declare type TOperation = ConcreteBatch;
      declare type TPayload = RelayResponsePayload;
    
      declare export type FragmentMap = CFragmentMap<TFragment>;
      declare export type OperationSelector = COperationSelector<TNode, TOperation>;
      declare export type RelayContext = CRelayContext<TEnvironment>;
      declare export type Selector = CSelector<TNode>;
      declare export type TSnapshot<TRecord> = CSnapshot<TNode, TRecord>;
      declare export type Snapshot = TSnapshot<Record>;
      declare export type ProxySnapshot = TSnapshot<RecordProxy>;
      declare export type UnstableEnvironmentCore = CUnstableEnvironmentCore<TEnvironment,
        TFragment,
        TGraphQLTaggedNode,
        TNode,
        TOperation,
        >;
    
      declare export interface IRecordSource<TRecord> {
        get(dataID: DataID): ?TRecord,
      }
    
      /**
       * A read-only interface for accessing cached graph data.
       */
      declare export interface RecordSource extends IRecordSource<Record> {
        get(dataID: DataID): ?Record,
    
        getRecordIDs(): Array<DataID>,
    
        getStatus(dataID: DataID): RecordState,
    
        has(dataID: DataID): boolean,
    
        load(dataID: DataID,
             callback: (error: ?Error, record: ?Record) => void,): void,
    
        size(): number,
      }
    
      /**
       * A read/write interface for accessing and updating graph data.
       */
      declare export interface MutableRecordSource extends RecordSource {
        clear(): void,
    
        delete(dataID: DataID): void,
    
        remove(dataID: DataID): void,
    
        set(dataID: DataID, record: Record): void,
      }
    
      /**
       * An interface for keeping multiple views of data consistent across an
       * application.
       */
      declare export interface Store {
        /**
         * Get a read-only view of the store's internal RecordSource.
         */
        getSource(): RecordSource,
    
        /**
         * Determine if the selector can be resolved with data in the store (i.e. no
         * fields are missing).
         */
        check(selector: Selector): boolean,
    
        /**
         * Read the results of a selector from in-memory records in the store.
         */
        lookup(selector: Selector): Snapshot,
    
        /**
         * Notify subscribers (see `subscribe`) of any data that was published
         * (`publish()`) since the last time `notify` was called.
         */
        notify(): void,
    
        /**
         * Publish new information (e.g. from the network) to the store, updating its
         * internal record source. Subscribers are not immediately notified - this
         * occurs when `notify()` is called.
         */
        publish(source: RecordSource): void,
    
        /**
         * Attempts to load all the records necessary to fulfill the selector into the
         * target record source.
         */
        resolve(target: MutableRecordSource,
                selector: Selector,
                callback: AsyncLoadCallback,): void,
    
        /**
         * Ensure that all the records necessary to fulfill the given selector are
         * retained in-memory. The records will not be eligible for garbage collection
         * until the returned reference is disposed.
         */
        retain(selector: Selector): Disposable,
    
        /**
         * Subscribe to changes to the results of a selector. The callback is called
         * when `notify()` is called *and* records have been published that affect the
         * selector results relative to the last `notify()`.
         */
        subscribe(snapshot: Snapshot,
                  callback: (snapshot: Snapshot) => void,): Disposable,
      }
    
      /**
       * An interface for imperatively getting/setting properties of a `Record`. This interface
       * is designed to allow the appearance of direct Record manipulation while
       * allowing different implementations that may e.g. create a changeset of
       * the modifications.
       */
      declare export interface RecordProxy {
        copyFieldsFrom(source: RecordProxy): void,
    
        getDataID(): DataID,
    
        getLinkedRecord(name: string, args?: ?Variables): ?RecordProxy,
    
        getLinkedRecords(name: string, args?: ?Variables): ?Array<?RecordProxy>,
    
        getOrCreateLinkedRecord(name: string,
                                typeName: string,
                                args?: ?Variables,): RecordProxy,
    
        getType(): string,
    
        getValue(name: string, args?: ?Variables): mixed,
    
        setLinkedRecord(record: RecordProxy,
                        name: string,
                        args?: ?Variables,): RecordProxy,
    
        setLinkedRecords(records: Array<?RecordProxy>,
                         name: string,
                         args?: ?Variables,): RecordProxy,
    
        setValue(value: mixed, name: string, args?: ?Variables): RecordProxy,
      }
    
      /**
       * An interface for imperatively getting/setting properties of a `RecordSource`. This interface
       * is designed to allow the appearance of direct RecordSource manipulation while
       * allowing different implementations that may e.g. create a changeset of
       * the modifications.
       */
      declare export interface RecordSourceProxy extends IRecordSource<RecordProxy> {
        create(dataID: DataID, typeName: string): RecordProxy,
    
        delete(dataID: DataID): void,
    
        get(dataID: DataID): ?RecordProxy,
    
        getRoot(): RecordProxy,
      }
    
      /**
       * Extends the RecordSourceProxy interface with methods for accessing the root
       * fields of a Selector.
       */
      declare export interface RecordSourceSelectorProxy extends IRecordSource<RecordProxy> {
        create(dataID: DataID, typeName: string): RecordProxy,
    
        delete(dataID: DataID): void,
    
        get(dataID: DataID): ?RecordProxy,
    
        getRoot(): RecordProxy,
    
        getRootField(fieldName: string): ?RecordProxy,
    
        getPluralRootField(fieldName: string): ?Array<?RecordProxy>,
    
        getResponse(): ?Object,
      }
    
      declare export interface IRecordReader<TRecord> {
        getDataID(record: TRecord): DataID,
    
        getType(record: TRecord): string,
    
        getValue(record: TRecord, name: string, args
    
        ?: ?
        Variables
        ):
        mixed,
    
        getLinkedRecordID(record: TRecord, name: string, args
    
        ?: ?
        Variables
        ): ?
        DataID,
    
        getLinkedRecordIDs(record: TRecord,
                           name: string,
                           args
    
        ?: ?
        Variables,
        ): ?
    
        Array<?
    
        DataID
        >,
      }
    
      /**
       * Settings for how a query response may be cached.
       *
       * - `force`: causes a query to be issued unconditionally, irrespective of the
       *   state of any configured response cache.
       * - `poll`: causes a query to live update by polling at the specified interval
       in milliseconds. (This value will be passed to setTimeout.)
       */
      declare export type CacheConfig = {
        force?: ?boolean,
        poll?: ?number,
      };
    
      /**
       * Represents any resource that must be explicitly disposed of. The most common
       * use-case is as a return value for subscriptions, where calling `dispose()`
       * would cancel the subscription.
       */
      declare export type Disposable = {
        dispose(): void,
      };
    
      /**
       * Arbitrary data e.g. received by a container as props.
       */
      declare export type Props = { [key: string]: mixed };
    
      /*
       * An individual cached graph object.
       */
      declare export type Record = { [key: string]: mixed };
    
      /**
       * A collection of records keyed by id.
       */
      declare export type RecordMap<T> = { [dataID: DataID]: ?T };
    
      /**
       * A selector defines the starting point for a traversal into the graph for the
       * purposes of targeting a subgraph.
       */
      declare export type CSelector<TNode> = {
        dataID: DataID,
        node: TNode,
        variables: Variables,
      };
    
      /**
       * A representation of a selector and its results at a particular point in time.
       */
      declare export type CSnapshot<TNode, TRecord> = CSelector<TNode> & {
        data: ?SelectorData,
        seenRecords: RecordMap<TRecord>,
      };
    
      /**
       * The results of a selector given a store/RecordSource.
       */
      declare export type SelectorData = { [key: string]: mixed };
    
      /**
       * The results of reading the results of a FragmentMap given some input
       * `Props`.
       */
      declare export type FragmentSpecResults = { [key: string]: mixed };
    
      /**
       * A utility for resolving and subscribing to the results of a fragment spec
       * (key -> fragment mapping) given some "props" that determine the root ID
       * and variables to use when reading each fragment. When props are changed via
       * `setProps()`, the resolver will update its results and subscriptions
       * accordingly. Internally, the resolver:
       * - Converts the fragment map & props map into a map of `Selector`s.
       * - Removes any resolvers for any props that became null.
       * - Creates resolvers for any props that became non-null.
       * - Updates resolvers with the latest props.
       */
      declare export interface FragmentSpecResolver {
        /**
         * Stop watching for changes to the results of the fragments.
         */
        dispose(): void,
    
        /**
         * Get the current results.
         */
        resolve(): FragmentSpecResults,
    
        /**
         * Update the resolver with new inputs. Call `resolve()` to get the updated
         * results.
         */
        setProps(props: Props): void,
    
        /**
         * Override the variables used to read the results of the fragments. Call
         * `resolve()` to get the updated results.
         */
        setVariables(variables: Variables): void,
      }
    
      declare export type CFragmentMap<TFragment> = { [key: string]: TFragment };
    
      /**
       * An operation selector describes a specific instance of a GraphQL operation
       * with variables applied.
       *
       * - `root`: a selector intended for processing server results or retaining
       *   response data in the store.
       * - `fragment`: a selector intended for use in reading or subscribing to
       *   the results of the the operation.
       */
      declare export type COperationSelector<TNode, TOperation> = {
        fragment: CSelector<TNode>,
        node: TOperation,
        root: CSelector<TNode>,
        variables: Variables,
      };
    
      /**
       * The public API of Relay core. Represents an encapsulated environment with its
       * own in-memory cache.
       */
      declare export interface CEnvironment<
      TEnvironment,
      TFragment,
      TGraphQLTaggedNode,
      TNode,
      TOperation,
      TPayload,
      > {
        /**
         * Read the results of a selector from in-memory records in the store.
         */
        lookup(selector: CSelector<TNode>): CSnapshot<TNode>,
    
        /**
         * Subscribe to changes to the results of a selector. The callback is called
         * when data has been committed to the store that would cause the results of
         * the snapshot's selector to change.
         */
        subscribe(
          snapshot: CSnapshot<TNode>,
          callback: (snapshot: CSnapshot<TNode>) => void,
        ): Disposable,
    
        /**
         * Ensure that all the records necessary to fulfill the given selector are
         * retained in-memory. The records will not be eligible for garbage collection
         * until the returned reference is disposed.
         *
         * Note: This is a no-op in the classic core.
         */
        retain(selector: CSelector<TNode>): Disposable,
    
        /**
         * Send a query to the server with request/response semantics: the query will
         * either complete successfully (calling `onNext` and `onCompleted`) or fail
         * (calling `onError`).
         *
         * Note: Most applications should use `streamQuery` in order to
         * optionally receive updated information over time, should that feature be
         * supported by the network/server. A good rule of thumb is to use this method
         * if you would otherwise immediately dispose the `streamQuery()`
         * after receving the first `onNext` result.
         */
        sendQuery(config: {|
          cacheConfig?: ?CacheConfig,
          onCompleted?: ?() => void,
          onError?: ?(error: Error) => void,
          onNext?: ?(payload: TPayload) => void,
          operation: COperationSelector<TNode, TOperation>,
        |}): Disposable,
    
        /**
         * Send a query to the server with request/subscription semantics: one or more
         * responses may be returned (via `onNext`) over time followed by either
         * the request completing (`onCompleted`) or an error (`onError`).
         *
         * Networks/servers that support subscriptions may choose to hold the
         * subscription open indefinitely such that `onCompleted` is not called.
         */
        streamQuery(config: {|
          cacheConfig?: ?CacheConfig,
          onCompleted?: ?() => void,
          onError?: ?(error: Error) => void,
          onNext?: ?(payload: TPayload) => void,
          operation: COperationSelector<TNode, TOperation>,
        |}): Disposable,
    
        unstable_internal: CUnstableEnvironmentCore<
          TEnvironment,
          TFragment,
          TGraphQLTaggedNode,
          TNode,
          TOperation,
          >,
      }
    
      declare export interface CUnstableEnvironmentCore<
      TEnvironment,
      TFragment,
      TGraphQLTaggedNode,
      TNode,
      TOperation,
      > {
        /**
         * Create an instance of a FragmentSpecResolver.
         *
         * TODO: The FragmentSpecResolver *can* be implemented via the other methods
         * defined here, so this could be moved out of core. It's convenient to have
         * separate implementations until the experimental core is in OSS.
         */
        createFragmentSpecResolver: (
          context: CRelayContext<TEnvironment>,
          containerName: string,
          fragments: CFragmentMap<TFragment>,
          props: Props,
          callback: () => void,
        ) => FragmentSpecResolver,
    
        /**
         * Creates an instance of an OperationSelector given an operation definition
         * (see `getOperation`) and the variables to apply. The input variables are
         * filtered to exclude variables that do not matche defined arguments on the
         * operation, and default values are populated for null values.
         */
        createOperationSelector: (
          operation: TOperation,
          variables: Variables,
        ) => COperationSelector<TNode, TOperation>,
    
        /**
         * Given a graphql`...` tagged template, extract a fragment definition usable
         * by this version of Relay core. Throws if the value is not a fragment.
         */
        getFragment: (node: TGraphQLTaggedNode) => TFragment,
    
        /**
         * Given a graphql`...` tagged template, extract an operation definition
         * usable by this version of Relay core. Throws if the value is not an
         * operation.
         */
        getOperation: (node: TGraphQLTaggedNode) => TOperation,
    
        /**
         * Determine if two selectors are equal (represent the same selection). Note
         * that this function returns `false` when the two queries/fragments are
         * different objects, even if they select the same fields.
         */
        areEqualSelectors: (a: CSelector<TNode>, b: CSelector<TNode>) => boolean,
    
        /**
         * Given the result `item` from a parent that fetched `fragment`, creates a
         * selector that can be used to read the results of that fragment for that item.
         *
         * Example:
         *
         * Given two fragments as follows:
         *
         * ```
         * fragment Parent on User {
       *   id
       *   ...Child
       * }
         * fragment Child on User {
       *   name
       * }
         * ```
         *
         * And given some object `parent` that is the results of `Parent` for id "4",
         * the results of `Child` can be accessed by first getting a selector and then
         * using that selector to `lookup()` the results against the environment:
         *
         * ```
         * const childSelector = getSelector(queryVariables, Child, parent);
         * const childData = environment.lookup(childSelector).data;
         * ```
         */
        getSelector: (
          operationVariables: Variables,
          fragment: TFragment,
          prop: mixed,
        ) => ?CSelector<TNode>,
    
        /**
         * Given the result `items` from a parent that fetched `fragment`, creates a
         * selector that can be used to read the results of that fragment on those
         * items. This is similar to `getSelector` but for "plural" fragments that
         * expect an array of results and therefore return an array of selectors.
         */
        getSelectorList: (
          operationVariables: Variables,
          fragment: TFragment,
          props: Array<mixed>,
        ) => ?Array<CSelector<TNode>>,
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts the selectors for those fragments from the results.
         *
         * The canonical use-case for this function are Relay Containers, which
         * use this function to convert (props, fragments) into selectors so that they
         * can read the results to pass to the inner component.
         */
        getSelectorsFromObject: (
          operationVariables: Variables,
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => {[key: string]: ?(CSelector<TNode> | Array<CSelector<TNode>>)},
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts a mapping of keys -> id(s) of the results.
         *
         * Similar to `getSelectorsFromObject()`, this function can be useful in
         * determining the "identity" of the props passed to a component.
         */
        getDataIDsFromObject: (
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => {[key: string]: ?(DataID | Array<DataID>)},
    
        /**
         * Given a mapping of keys -> results and a mapping of keys -> fragments,
         * extracts the merged variables that would be in scope for those
         * fragments/results.
         *
         * This can be useful in determing what varaibles were used to fetch the data
         * for a Relay container, for example.
         */
        getVariablesFromObject: (
          operationVariables: Variables,
          fragments: CFragmentMap<TFragment>,
          props: Props,
        ) => Variables,
      }
    
      /**
       * The type of the `relay` property set on React context by the React/Relay
       * integration layer (e.g. QueryRenderer, FragmentContainer, etc).
       */
      declare export type CRelayContext<TEnvironment> = {
        environment: TEnvironment,
        variables: Variables,
      };
    
      /**
       * The public API of Relay core. Represents an encapsulated environment with its
       * own in-memory cache.
       */
      declare export interface Environment
        extends CEnvironment<
          TEnvironment,
          TFragment,
          TGraphQLTaggedNode,
          TNode,
          TOperation,
          TPayload,
          > {
        /**
         * Applies an optimistic mutation to the store without committing it to the
         * server. The returned Disposable can be used to revert this change at a
         * later time.
         */
        applyMutation(config: {|
          configs: Array<RelayMutationConfig>,
          operation: ConcreteOperationDefinition,
          optimisticResponse: Object,
          variables: Variables,
        |}): Disposable,
    
        /**
         * Applies an optimistic mutation if provided and commits the mutation to the
         * server. The returned Disposable can be used to bypass the `onCompleted`
         * and `onError` callbacks when the server response is returned.
         */
        sendMutation<ResponseType>(config: {|
          configs: Array<RelayMutationConfig>,
          onCompleted?: ?(response: ResponseType) => void,
          onError?: ?(error: Error) => void,
          operation: ConcreteOperationDefinition,
          optimisticOperation?: ?ConcreteOperationDefinition,
          optimisticResponse?: ?Object,
          variables: Variables,
          uploadables?: UploadableMap,
        |}): Disposable,
      }
    
      declare export type Observer<T> = {
        onCompleted?: ?() => void,
        onError?: ?(error: Error) => void,
        onNext?: ?(data: T) => void,
      };
    
      /**
       * The results of reading data for a fragment. This is similar to a `Selector`,
       * but references the (fragment) node by name rather than by value.
       */
      declare export type FragmentPointer = {
        __id: DataID,
        __fragments: { [fragmentName: string]: Variables },
      };
    
      /**
       * A callback for resolving a Selector from a source.
       */
      declare export type AsyncLoadCallback = (loadingState: LoadingState) => void;
      declare export type LoadingState = $Exact<{
        status: 'aborted' | 'complete' | 'error' | 'missing',
        error?: Error,
      }>;
    
      /**
       * A map of records affected by an update operation.
       */
      declare export type UpdatedRecords = { [dataID: DataID]: boolean };
    
      /**
       * A function that updates a store (via a proxy) given the results of a "handle"
       * field payload.
       */
      declare export type Handler = {
        update: (store: RecordSourceProxy, fieldPayload: HandleFieldPayload) => void,
      };
    
      /**
       * A payload that is used to initialize or update a "handle" field with
       * information from the server.
       */
      declare export type HandleFieldPayload = $Exact<{
        // The arguments that were fetched.
        args: Variables,
        // The __id of the record containing the source/handle field.
        dataID: DataID,
        // The (storage) key at which the original server data was written.
        fieldKey: string,
        // The name of the handle.
        handle: string,
        // The (storage) key at which the handle's data should be written by the
        // handler.
        handleKey: string,
      }>;
    
      /**
       * A function that receives a proxy over the store and may trigger side-effects
       * (indirectly) by calling `set*` methods on the store or its record proxies.
       */
      declare export type StoreUpdater = (store: RecordSourceProxy) => void;
    
      /**
       * Similar to StoreUpdater, but accepts a proxy tied to a specific selector in
       * order to easily access the root fields of a query/mutation.
       */
      declare export type SelectorStoreUpdater = (store: RecordSourceSelectorProxy) => void;
    
      declare export type CallValue = ?(
        | boolean
        | number
        | string
        | {[key: string]: CallValue}
        | Array<CallValue>);
    
      declare export type RangeBehaviorsFunction = (connectionArgs: {
        [argName: string]: CallValue,
      }) => ('APPEND' |
        'IGNORE' |
        'PREPEND' |
        'REFETCH' |
        'REMOVE' |
        'NODE_DELETE_HANDLER' |
        'RANGE_ADD_HANDLER' |
        'RANGE_DELETE_HANDLER' |
        'HANDLER_TYPES' |
        'OPTIMISTIC_UPDATE' |
        'SERVER_UPDATE' |
        'POLLER_UPDATE' |
        'UPDATE_TYPES' |
        'RANGE_OPERATIONS');
    
      declare export type RangeBehaviorsObject = {
        [key: string]: 'APPEND' | 'IGNORE' | 'PREPEND' | 'REFETCH' | 'REMOVE',
      };
    
      declare export type RangeBehaviors = RangeBehaviorsFunction | RangeBehaviorsObject;
    
      declare export type RelayConcreteNode = mixed;
    
      declare export type RelayMutationConfig =
        | {
        type: 'FIELDS_CHANGE',
        fieldIDs: {[fieldName: string]: DataID | Array<DataID>},
      }
        | {
        type: 'RANGE_ADD',
        parentName?: string,
        parentID?: string,
        connectionInfo?: Array<{
          key: string,
          filters?: Variables,
          rangeBehavior: string,
        }>,
        connectionName?: string,
        edgeName: string,
        rangeBehaviors?: RangeBehaviors,
      }
        | {
        type: 'NODE_DELETE',
        parentName?: string,
        parentID?: string,
        connectionName?: string,
        deletedIDFieldName: string,
      }
        | {
        type: 'RANGE_DELETE',
        parentName?: string,
        parentID?: string,
        connectionKeys?: Array<{
          key: string,
          filters?: Variables,
        }>,
        connectionName?: string,
        deletedIDFieldName: string | Array<string>,
        pathToConnection: Array<string>,
      }
        | {
        type: 'REQUIRED_CHILDREN',
        children: Array<RelayConcreteNode>,
      };
    
      declare export type MutationConfig<T> = {|
        configs?: Array<RelayMutationConfig>,
        mutation: GraphQLTaggedNode,
        variables: Variables,
        uploadables?: UploadableMap,
        onCompleted?: ?(response: T, errors: ?Array<PayloadError>) => void,
        onError?: ?(error: Error) => void,
        optimisticUpdater?: ?SelectorStoreUpdater,
        optimisticResponse?: Object,
        updater?: ?SelectorStoreUpdater,
      |};
    
      // a.k.a commitRelayModernMutation
      declare export function commitMutation<T>(
        environment: Environment,
        config: MutationConfig<T>,
      ): Disposable
    
      declare export type ReadyState = {
        error: ?Error,
        props: ?Object,
        retry: ?() => void,
      };
    
      /**
       * Classic environment below here
       */
      declare export class RelayQueryFragment {
        // stub
      }
    
      declare export class RelayQueryNode {
        // stub
      }
    
      declare export class RelayQueryRoot {
        // stub
      }
    
      declare export class RelayStoreData {
        // stub
      }
    
      declare export type RelayQuerySet = {[queryName: string]: ?RelayQueryRoot};
      declare export type ReadyStateChangeCallback = (readyState: ReadyState) => void;
      declare export type Abortable = {
        abort(): void,
      };
      declare export type StoreReaderData = Object;
      declare export type StoreReaderOptions = {
        traverseFragmentReferences?: boolean,
        traverseGeneratedFields?: boolean,
      };
      declare export type FragmentResolver = {
        dispose(): void,
        resolve(
          fragment: RelayQueryFragment,
          dataIDs: DataID | Array<DataID>,
        ): ?(StoreReaderData | Array<?StoreReaderData>),
      };
    
      declare export interface RelayEnvironmentInterface {
        forceFetch(
          querySet: RelayQuerySet,
          onReadyStateChange: ReadyStateChangeCallback,
        ): Abortable,
        getFragmentResolver(
          fragment: RelayQueryFragment,
          onNext: () => void,
        ): FragmentResolver,
        getStoreData(): RelayStoreData,
        primeCache(
          querySet: RelayQuerySet,
          onReadyStateChange: ReadyStateChangeCallback,
        ): Abortable,
        read(
          node: RelayQueryNode,
          dataID: DataID,
          options?: StoreReaderOptions,
        ): ?StoreReaderData,
        readQuery(
          root: RelayQueryRoot,
          options?: StoreReaderOptions,
        ): Array<?StoreReaderData>,
      }
    
      declare export type ClassicEnvironment = RelayEnvironmentInterface;
    
      declare export class QueryRenderer extends React$Component<{
        cacheConfig?: ?CacheConfig,
        environment: Environment | ClassicEnvironment,
        query: ?GraphQLTaggedNode,
        render: (readyState: ReadyState) => ?React$Element<*>,
        variables: Variables,
      }> {}
    
      // https://github.com/facebook/relay/blob/master/packages/relay-runtime/network/RelayNetworkTypes.js
      /**
       * A cache for saving respones to queries (by id) and variables.
       */
      declare export interface ResponseCache {
        get(id: string, variables: Variables): ?QueryPayload,
        set(id: string, variables: Variables, payload: QueryPayload): void,
      }
    
      /**
       * An interface for fetching the data for one or more (possibly interdependent)
       * queries.
       */
      declare export interface Network {
        fetch: FetchFunction,
        request: RequestResponseFunction,
        requestStream: RequestStreamFunction,
      }
    
      declare export type PayloadData = {[key: string]: mixed};
    
      declare export type PayloadError = {
        message: string,
        locations?: Array<{
          line: number,
          column: number,
        }>,
      };
    
      /**
       * The shape of a GraphQL response as dictated by the
       * [spec](http://facebook.github.io/graphql/#sec-Response)
       */
      declare export type QueryPayload = {|
        data?: ?PayloadData,
        errors?: Array<PayloadError>,
        rerunVariables?: Variables,
      |};
    
      /**
       * The shape of data that is returned by the Relay network layer for a given
       * query.
       */
      declare export type RelayResponsePayload = {|
        fieldPayloads?: ?Array<HandleFieldPayload>,
        source: MutableRecordSource,
        errors: ?Array<PayloadError>,
      |};
    
      declare export type PromiseOrValue<T> = Promise<T> | T | Error;
    
      /**
       * A function that executes a GraphQL operation with request/response semantics,
       * with exactly one raw server response returned
       */
      declare export type FetchFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        uploadables?: UploadableMap,
      ) => PromiseOrValue<QueryPayload>;
    
      /**
       * A function that executes a GraphQL operation with request/subscription
       * semantics, returning one or more raw server responses over time.
       */
      declare export type SubscribeFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        observer: Observer<QueryPayload>,
      ) => Disposable;
    
      /**
       * A function that executes a GraphQL operation with request/subscription
       * semantics, returning one or more responses over time that include the
       * initial result and optional updates e.g. as the results of the operation
       * change.
       */
      declare export type RequestStreamFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig: ?CacheConfig,
        observer: Observer<RelayResponsePayload>,
      ) => Disposable;
    
      /**
       * A function that executes a GraphQL operation with request/response semantics,
       * with exactly one response returned.
       */
      declare export type RequestResponseFunction = (
        operation: ConcreteBatch,
        variables: Variables,
        cacheConfig?: ?CacheConfig,
        uploadables?: UploadableMap,
      ) => PromiseOrValue<RelayResponsePayload>;
    
      declare export type Uploadable = File | Blob;
      declare export type UploadableMap = {[key: string]: Uploadable};
    }
    
    
    

    public by Kevin Ross  233  1  3  0

    flow libdef for found

    flow libdef for found: found.js
    // @flow
    
    // WARNING: this is early and mostly unused.  As I'm refactoring code I'll try to update this.  ping me with questions.
    
    declare module 'found' {
      declare type Map = { [key: string]: any }
      /**
       * The shape might be different with a custom matcher or history enhancer, but the default matcher
       * assumes and provides this shape. As such, this validator is purely for user convenience and
       * should not be used internally.
       */
      declare export type Match = {
        location: {
          pathname: string,
          query: Map,
        },
        params: Map,
      }
    
      /**
       * An object implementing the matching algorithm.
       *
       * User code generally shouldn't need this, but it doesn't hurt to export here, since we use it
       * for routerShape below.
       */
      declare export type Matcher = {
        match: Function,
        getRoutes: Function,
        isActive: Function,
        /**
         * Returns the path string for a pattern of the same format as a route path and a object of the
         * corresponding path parameters
         */
        format: (pattern: any, params: Map) => any,
      }
    
      /**
       * Location descriptor string:
       *  store.dispatch(FarceActions.push('/foo?bar=baz#qux'));
       *
       * Equivalent location descriptor object:
       *    store.dispatch(FarceActions.push({
       *     pathname: '/foo',
       *     search: '?bar=baz',
       *     hash: '#qux',
       *   }));
       *
       * https://github.com/4Catalyzer/farce#locations-and-location-descriptors
       */
      declare export type Location = {
        /**
         * 'PUSH' or 'REPLACE' if the location was reached via FarceActions.push or FarceActions.replace respectively;
         * 'POP' on the initial location, or if the location was reached via the browser back or forward buttons or
         * via FarceActions.go
         */
        action: 'PUSH' | 'REPLACE' | 'POP',
        /**
         * the path name; as on window.location e.g. '/foo'
         */
        pathname: string,
        /**
         * the search string; as on window.location e.g. '?bar=baz'
         */
        search: string,
        /**
         * the location hash; as on window.location e.g. '#qux'
         */
        hash: string,
        /**
         * if present, a unique key identifying the current history entry
         */
        key?: string,
        /**
         * the current index of the history entry, starting at 0 for the initial entry; this increments
         * on FarceActions.push but not on FarceActions.replace
         */
        index: number,
        /**
         * the difference between the current index and the index of the previous location
         */
        delta: number,
        /**
         * additional location state that is not part of the URL
         */
        state: any,
        /**
         * map version of search string
         */
        query: Map
      }
    
      /**
       * Lenient arg version of location using in #push and #replace.
       */
      declare export type LocationArg = string | {
          pathname: string,
          search?: string,
          hash?: string,
          state?: any,
          query?: Map
      }
    
      /**
       * The transition hook function receives the location to which the user is attempting to navigate.
       *
       * This function may return:
       *  - true to allow the transition
       *  - false to block the transition
       *  - A string to prompt the user with that string as the message
       *  - A nully value to call the next transition hook and use its return value, if present, or
       *    else to allow the transition
       *  - A promise that resolves to any of the above values, to allow or block the transition
       *    once the promise resolves
       *
       * @see https://github.com/4Catalyzer/farce#transition-hooks
       */
      declare export type TransitionHook = (location: Location) =>
        ?(boolean | string | Promise<?(boolean | string)>)
    
      declare export class Router {
        /**
         * Navigates to a new location
         * @see farce
         */
        push: (location: LocationArg) => void,
        /**
         * Replace the current history entry
         * @see farce
         */
        replace: (location: LocationArg) => void,
        /**
         * Moves delta steps in the history stack
         * @see farce
         */
          go: (delta: number) => void,
    
        createHref: Function,
        createLocation: Function,
        /**
         * for match as above, returns whether match corresponds to location or a subpath of location;
         * if exact is set, returns whether match corresponds exactly to location
         */
        isActive: (match: Match, location: Location, options: {exact?: boolean}) => boolean,
        matcher: Matcher,
        /**
         * Adds a transition hook that can block navigation.
         *
         * This method takes a transition hook function and returns a function to remove the transition hook.
         */
        addTransitionHook: (hook: TransitionHook) => (() => void),
      }
    
      declare export class Route {
        Component: Function
        children?: Array<Route>
        getComponent?: (props: RoutingState) => Promise<Function>
        path?: string
        render?: (args: RenderArgs) => Function
        prepareParams?: (params: Map, match: Match) => Map
        queries?: {
          [key: string]: Function
        }
      }
    
      declare export type RoutingState = {
        /**
         * The current location
         */
        location: Location,
        /**
         * The union of path parameters for all matched routes
         */
        params: Map,
        /**
         * An array of all matched route objects
         */
        routes: Array<Route>,
        /**
         * The route object corresponding to this component
         */
        route: Route,
        /**
         * the path parameters for route
         */
        routeParams: Map,
        router: Router,
        /**
         * an object with location and params as properties
         */
        match: Match,
        /**
         * an object with static router properties
         */
        router: Router
      }
    
      /**
       * @see https://github.com/4Catalyzer/found/blob/master/README.md#route-configuration
       * A bit lower for the list, no anchor there
       */
      declare export type RenderArgs = {
        match: Match,
        /**
         * the component for the route, if any; null if the component has not yet been loaded
         */
        Component?: Function,
        /**
         * the default props for the route component, specifically match with data as an additional property;
         * null if data have not yet been loaded
         */
        props?: RoutingState,
        /**
         * the data for the route, as above; null if the data have not yet been loaded
         */
        data?: any
      }
    }
    
    
    

    public by Kevin Ross  255  0  3  0

    Development webpack config - http://stackoverflow.com/questions/41420329/consuming-pure-es2015-libraries-with-webpack-2

    Development webpack config - http://stackoverflow.com/questions/41420329/consuming-pure-es2015-libraries-with-webpack-2: webpack.config.js
    const config = {
      devtool: 'source-map',
      devServer: {
        port: 3808,
        headers: {
          'Access-Control-Allow-Origin': '*'
        }
      },
      context: '/Users/kross/projects/af/spec/dummy',
      entry: {
        application: [
          'react-hot-loader/patch',
          'webpack-dev-server/client?http://localhost:3808',
          'webpack/hot/only-dev-server',
          './ui/src/index.js'
        ],
        vendor: [
          '@alienfast/material-ui',
          'classnames',
          'cookie',
          'core-js',
          'dom-helpers',
          'dompurify',
          'es-collections',
          'fbemitter',
          'graphql',
          'graphql-relay',
          'i18next',
          'i18next-browser-languagedetector',
          'i18next-localstorage-cache',
          'i18next-sprintf-postprocessor',
          'jwt-decode',
          'jss',
          'jss-camel-case',
          'jss-compose',
          'jss-default-unit',
          'jss-expand',
          'jss-global',
          'jss-nested',
          'jss-preset-default',
          'jss-props-sort',
          'jss-theme-reactor',
          'key.js',
          'lodash',
          'material-ui',
          'md5',
          'query-string',
          'react',
          'react-dom',
          'react-formal',
          'react-helmet',
          'react-i18next',
          'react-relay',
          'react-relay-network-layer',
          'react-router',
          'react-router-relay',
          'react-sizeme',
          'react-tap-event-plugin',
          'recompose',
          'ua-parser-js',
          'whatwg-fetch',
          'yup'
        ]
      },
      output: {
        path: '/Users/kross/projects/af/spec/dummy/public/webpack',
        publicPath: '//localhost:3808/webpack/',
        filename: '[name].js'
      },
      resolve: {
        extensions: [
          '.js',
          '.jsx',
          '.json'
        ],
        alias: {
          react: '/Users/kross/projects/af/spec/dummy/node_modules/react',
          'react-relay': '/Users/kross/projects/af/spec/dummy/node_modules/react-relay'
        }
      },
      module: {
        loaders: [
          {
            test: /\.jsx?$/,
            include: [
              '/Users/kross/projects/af/spec/dummy/ui/src',
              '/Users/kross/projects/af/spec/dummy/ui/tests',
              '/Users/kross/projects/af/spec/dummy/node_modules/react',
              '/Users/kross/projects/af/spec/dummy/node_modules/react-relay'
            ],
            exclude: /node_modules\/(?!(react|react-relay)\/).*/,
            loaders: [
              'happypack/loader'
            ]
          },
          {
            test: /\.json$/,
            loader: 'json-loader'
          },
          {
            test: /\.svg(\?.*)?$/,
            loader: 'url-loader?prefix=fonts/&name=[path][name].[ext]&limit=10000&mimetype=image/svg+xml'
          },
          {
            test: /\.(png|jpg)$/,
            loader: 'url-loader?limit=8192'
          }
        ]
      },
      plugins: [
        new HappyPack({ loaders: [ 'babel-loader' ] }),
        new webpack.DefinePlugin({
          NODE_ENV: 'development',
          __DEV__: true,
          __PROD__: false,
          __TEST__: false,
          ENV: 'development',
          'process.env': {
            NODE_ENV: '"development"'
          }
        }),
        new StatsPlugin('manifest.json', {
          // We only need assetsByChunkName
          chunkModules: false,
          source: false,
          chunks: false,
          modules: false,
          assets: true
        }),
        new webpack.NoErrorsPlugin(),
        new webpack.optimize.OccurrenceOrderPlugin(),
        new webpack.optimize.LimitChunkCountPlugin({ maxChunks: 15 }),
        new webpack.optimize.MinChunkSizePlugin({ minChunkSize: 10000 }),
        new webpack.optimize.CommonsChunkPlugin({
          names: [ 'vendor', 'manifest' ] // Specify the common bundle's name.
        })
      ]
    }
    
    

    public by rosskevin  1478  0  4  0

    cucumber setup with docker chrome standalone

    cucumber setup with docker chrome standalone: driver.rb
    require 'selenium/webdriver'
    
    ###
    # Important details:
    #   - Capybara server is run on the host container at 0.0.0.0:4100
    #   - Test code determines the host's advertised IP address e.g. 172.1.1.1
    #   - Capybara Instructions execute on selenium/standalone-chrome container via api call to http://127.0.0.1:4444/wd/hub and gives it urls such as http://dummy.com.172.1.1.1.nip.io:4100 to visit the server on the host container.
    #   - This works on an OSX host with manually running the selenium container with docker run -p 4444:4444 selenium/standalone-chrome:3.0.1-germanium
    #
    #
    # Interaction (host ip 172.1.1.1)
    #   - host api call to selenium -> http://127.0.0.1:4444/wd/hub
    #   - selenium browser visit -> 172.1.1.1:4100
    #
    $remote = true
    $browser = :chrome
    # $browser = :firefox
    $wait_time = 5
    $default_driver = :selenium
    
    # establish capabilities
    desired_capabilities = begin
      if $browser == :firefox
        Selenium::WebDriver::Remote::Capabilities.firefox(loggingPrefs: {browser: 'ALL'})
      else
        # Tell selenium we want all messages by default - we'll sort them out with our own +ConsoleMessages+ class
        prefs = {
          # http://peter.sh/experiments/chromium-command-line-switches/
    
          # No change with the following
          # ----------------------------------
          # --js-flags="--max-old-space-size=500"
          # --disable-backing-store-limit
          # --diagnostics
          # --disable-extensions
          # --enable-leak-detection --crash-on-failure
    
          # Not yet tried but might be interesting
          # ---------------------------------------
          # --diagnostics
          # --disable-background-networking
          # --disable-background-timer-throttling
          # --disable-backing-store-limit
    
          #
          switches: %w(--disable-notifications --enable-leak-detection --crash-on-failure),
          loggingPrefs: {
            browser: 'ALL' #,
            # performance: 'ALL'
          },
          chromeOptions: {
            prefs: {
              credentials_enable_service: false, # disable saved passwords
              profile: {
                password_manager_enabled: false  # disable saved passwords
              }
            }
          }
        }
    
        Selenium::WebDriver::Remote::Capabilities.chrome(prefs)
      end
    end
    
    # For debugging selenium itself:
    # Selenium::WebDriver.logger.level = :debug
    if $remote == true
      # http://stackoverflow.com/questions/35821718/how-to-configure-capybara-to-run-tests-in-a-dockerized-selenium-grid
      Capybara.register_driver $default_driver do |app|
        # noinspection RubyArgCount
        Capybara::Selenium::Driver.new(app, {
          browser: :remote,
          url: 'http://127.0.0.1:4444/wd/hub', # selenium hub accessible url
          desired_capabilities: desired_capabilities
        })
      end
    else
      # Register chrome browser for the :selenium driver, can be triggered below with @show
      Capybara.register_driver $default_driver do |app|
        # noinspection RubyArgCount
        Capybara::Selenium::Driver.new(app, {
          browser: $browser,
          desired_capabilities: desired_capabilities
        })
      end
    end
    
    
    # Make the server available on the network.  default is 127.0.0.1 which is private
    Capybara.server_host = '0.0.0.0'
    Capybara.server_port = 4100
    Capybara.server = :puma
    cuke_log "Capybara running on #{Capybara.server_host}:#{Capybara.server_port} Process: #{Process.pid}"
    ENV['CIRCLE_NODE_INDEX'] = '9' unless ENV['CIRCLE_NODE_INDEX'].presence # default the node for local testing
    
    # first time around, we need this set.
    Capybara.default_driver = $default_driver
    Capybara.default_max_wait_time = $wait_time
    
    #
    # If the @show tag is present on a non-mac environment, ignore it,
    #   otherwise allow the combination of @javascript @show to trigger the
    #   :selenium driver (which is :chrome browser as configured above)
    #
    Before do |scenario|
      @scenario = scenario
      raise 'Scenario should not have @javascript tag, it really messes up truncation' if has_tag(scenario, '@javascript')
    
      # reset the default driver
      Capybara.current_driver = $default_driver
      Capybara.javascript_driver = $default_driver
      Capybara.default_max_wait_time = $wait_time # reset in case a scenario upped it
    
      # OLD, but if we need to exec a script to clear storage or cache, do it here.
      # page.driver.execute_script('window.localStorage.clear()')
    
      if should_show(scenario)
        # for some reason, just using the `using_driver` doesn't get us all the way there, so set/reset the `javascript_driver` as necessary.
        Capybara.current_driver = :selenium
        Capybara.javascript_driver = :selenium # needed for @show with chrome, as it doesn't seem to explicitly set the javascript driver
      end
      # cuke_log "Using #{Capybara.current_driver}/#{Capybara.javascript_driver}/#{Capybara.default_driver} wait: #{Capybara.default_max_wait_time}"
    end
    
    After do |scenario|
      # problem on @show with backgrounds: https://github.com/cucumber/cucumber/issues/52
      # cuke_log "Done #{Capybara.current_driver}/#{Capybara.javascript_driver}/#{Capybara.default_driver} - resetting driver and sessions."
      Capybara.use_default_driver
      Capybara.reset_sessions!
    end
    
    def selenium?
      Capybara.current_driver == :selenium
    end
    
    
    

    public by Kevin Ross  267  0  3  0

    React Performance/shouldComponentUpdate visibility helper

    React Performance/shouldComponentUpdate visibility helper: Performance.js
    // @flow
    import reShallowEqual from 'recompose/shallowEqual'
    import Logger from './Logger'
    
    class Performance {
      static shouldComponentUpdate (component, nextProps, nextState, nextContext, dig = false) {
        if (!__DEV__) {
          return (
            !reShallowEqual(this.props, nextProps) || !reShallowEqual(this.state, nextState) || !reShallowEqual(this.context, nextContext)
          )
        }
        else {
          const dirty = []
          const propsDiff = !shallowEqual(dirty, dig, 'props', component.props, nextProps)
          const stateDiff = !shallowEqual(dirty, dig, 'state', component.state, nextState)
          const contextDiff = !shallowEqual(dirty, dig, 'context', component.context, nextContext)
          const result = propsDiff || stateDiff || contextDiff
          if (result) {
            this._log(component, `is dirty: ${dirty.join(', ')}`)
          }
    
          return result
        }
      }
    
      // private
      static _log (component, ...args) {
        log.debug(`[${Logger.objectName(component)}] ${args.join(' ')}`)
      }
    }
    
    /*
     ---------------------------------------------------------------------------------------
     Below is a copy of shallowEqual, instrumented to aid in finding differences more easily
     */
    
    /* eslint-disable no-self-compare */
    const hasOwnProperty = Object.prototype.hasOwnProperty
    
    /**
     * inlined Object.is polyfill to avoid requiring consumers ship their own
     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
     */
    function is (x: mixed, y: mixed): boolean {
      // SameValue algorithm
      if (x === y) { // Steps 1-5, 7-10
        // Steps 6.b-6.e: +0 != -0
        return x !== 0 || 1 / (x: $FlowIssue) === 1 / (y: $FlowIssue)
      } else {
        // Step 6.a: NaN == NaN
        return x !== x && y !== y
      }
    }
    
    /**
     * Performs equality by iterating through keys on an object and returning false
     * when any key has values which are not strictly equal between the arguments.
     * Returns true when the values of all keys are strictly equal.
     */
    function shallowEqual (dirty: Array<string>, dig: boolean, name: string, objA: mixed, objB: mixed): boolean {
      // always return the result from the known-good recompose library.
      const result = reShallowEqual(objA, objB)
    
      if (!dig || result) {
        if (!result) {
          dirty.push(name)
        }
        return result
      }
    
      // dig below here
      let msg = ''
      if (!result) {
        msg += name
      }
    
      if (is(objA, objB)) {
        msg += ' (is diff)'
        dirty.push(msg)
        return result
      }
    
      if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
        msg += ' (null diff)'
        dirty.push(msg)
        return result
      }
    
      const keysA = Object.keys(objA)
      const keysB = Object.keys(objB)
    
      if (keysA.length !== keysB.length) {
        msg += ' (key length diff)'
        dirty.push(msg)
        return result
      }
    
      // Test for A's keys different from B.
      const diffKeys = []
      for (let i = 0; i < keysA.length; i++) {
        const aKey = keysA[ i ]
        if (!hasOwnProperty.call(objB, aKey) || !is(objA[ aKey ], objB[ aKey ])) {
          diffKeys.push(aKey)
        }
      }
    
      msg += ` ([${diffKeys.join(', ')}] keys are diff)`
    
      dirty.push(msg)
      return result
    }
    
    const log = new Logger(Performance) // eslint-disable-line
    
    export default Performance
    
    
    

    public by rosskevin  129  0  2  0

    This is the failed output of rollup for the statement `import {expect} from 'chai'` - bad options for global?

    This is the failed output of rollup for the statement `import {expect} from 'chai'` - bad options for global?: es2015-rollup-import-chai.js
    /*
    Rollup messages:
    [15:45:47] Treating 'buffer' as external dependency
    [15:45:48] No name was provided for external module 'buffer' in options.globals – guessing 'require$$0'
    
    index.js 
     import {expect} from 'chai'
    
    chai - chai@3.5.0
    
    rollup options:
    
    let options = {
        entry: 'test/index.js',
        sourceMap: true,
        format: 'iife',
        plugins: [ 
            commonjs({
                include: 'node_modules/**',
                extensions: [
                    '.js'
                ]
            }),
            nodeResolve({
                jsnext: true,
                main: true,
                builtins: false,
                browser: true,
                extensions: [
                    '.js',
                    '.json'
                ]
            }),
            babel({
                babelrc: false,
                presets: [
                    'es2015-rollup'
                ]
            }),
        ],
        dest: 'dist/picker-tests.js.iife.js',
        moduleName: 'pickerTests'
    }
    
    
    */
    
    
    (function (require$$0) {
      'use strict';
    
      require$$0 = 'default' in require$$0 ? require$$0['default'] : require$$0;
    
      var __commonjs_global = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : this;
      function __commonjs(fn, module) { return module = { exports: {} }, fn(module, module.exports, __commonjs_global), module.exports; }
    
    
      var babelHelpers = {};
      babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
        return typeof obj;
      } : function (obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
      };
    
      babelHelpers.classCallCheck = function (instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      };
    
      babelHelpers.createClass = function () {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
    
        return function (Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();
    
      babelHelpers.get = function get(object, property, receiver) {
        if (object === null) object = Function.prototype;
        var desc = Object.getOwnPropertyDescriptor(object, property);
    
        if (desc === undefined) {
          var parent = Object.getPrototypeOf(object);
    
          if (parent === null) {
            return undefined;
          } else {
            return get(parent, property, receiver);
          }
        } else if ("value" in desc) {
          return desc.value;
        } else {
          var getter = desc.get;
    
          if (getter === undefined) {
            return undefined;
          }
    
          return getter.call(receiver);
        }
      };
    
      babelHelpers.inherits = function (subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
        }
    
        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      };
    
      babelHelpers.possibleConstructorReturn = function (self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }
    
        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      };
    
      babelHelpers.toConsumableArray = function (arr) {
        if (Array.isArray(arr)) {
          for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
    
          return arr2;
        } else {
          return Array.from(arr);
        }
      };
    
      babelHelpers;
    
      var assert = __commonjs(function (module) {
        /*!
         * chai
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        module.exports = function (chai, util) {
    
          /*!
           * Chai dependencies.
           */
    
          var Assertion = chai.Assertion,
              flag = util.flag;
    
          /*!
           * Module export.
           */
    
          /**
           * ### assert(expression, message)
           *
           * Write your own test expressions.
           *
           *     assert('foo' !== 'bar', 'foo is not bar');
           *     assert(Array.isArray([]), 'empty arrays are arrays');
           *
           * @param {Mixed} expression to test for truthiness
           * @param {String} message to display on error
           * @name assert
           * @namespace Assert
           * @api public
           */
    
          var assert = chai.assert = function (express, errmsg) {
            var test = new Assertion(null, null, chai.assert);
            test.assert(express, errmsg, '[ negation message unavailable ]');
          };
    
          /**
           * ### .fail(actual, expected, [message], [operator])
           *
           * Throw a failure. Node.js `assert` module-compatible.
           *
           * @name fail
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @param {String} operator
           * @namespace Assert
           * @api public
           */
    
          assert.fail = function (actual, expected, message, operator) {
            message = message || 'assert.fail()';
            throw new chai.AssertionError(message, {
              actual: actual,
              expected: expected,
              operator: operator
            }, assert.fail);
          };
    
          /**
           * ### .isOk(object, [message])
           *
           * Asserts that `object` is truthy.
           *
           *     assert.isOk('everything', 'everything is ok');
           *     assert.isOk(false, 'this will fail');
           *
           * @name isOk
           * @alias ok
           * @param {Mixed} object to test
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isOk = function (val, msg) {
            new Assertion(val, msg).is.ok;
          };
    
          /**
           * ### .isNotOk(object, [message])
           *
           * Asserts that `object` is falsy.
           *
           *     assert.isNotOk('everything', 'this will fail');
           *     assert.isNotOk(false, 'this will pass');
           *
           * @name isNotOk
           * @alias notOk
           * @param {Mixed} object to test
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotOk = function (val, msg) {
            new Assertion(val, msg).is.not.ok;
          };
    
          /**
           * ### .equal(actual, expected, [message])
           *
           * Asserts non-strict equality (`==`) of `actual` and `expected`.
           *
           *     assert.equal(3, '3', '== coerces values to strings');
           *
           * @name equal
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.equal = function (act, exp, msg) {
            var test = new Assertion(act, msg, assert.equal);
    
            test.assert(exp == flag(test, 'object'), 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{act}', exp, act);
          };
    
          /**
           * ### .notEqual(actual, expected, [message])
           *
           * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
           *
           *     assert.notEqual(3, 4, 'these numbers are not equal');
           *
           * @name notEqual
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notEqual = function (act, exp, msg) {
            var test = new Assertion(act, msg, assert.notEqual);
    
            test.assert(exp != flag(test, 'object'), 'expected #{this} to not equal #{exp}', 'expected #{this} to equal #{act}', exp, act);
          };
    
          /**
           * ### .strictEqual(actual, expected, [message])
           *
           * Asserts strict equality (`===`) of `actual` and `expected`.
           *
           *     assert.strictEqual(true, true, 'these booleans are strictly equal');
           *
           * @name strictEqual
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.strictEqual = function (act, exp, msg) {
            new Assertion(act, msg).to.equal(exp);
          };
    
          /**
           * ### .notStrictEqual(actual, expected, [message])
           *
           * Asserts strict inequality (`!==`) of `actual` and `expected`.
           *
           *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');
           *
           * @name notStrictEqual
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notStrictEqual = function (act, exp, msg) {
            new Assertion(act, msg).to.not.equal(exp);
          };
    
          /**
           * ### .deepEqual(actual, expected, [message])
           *
           * Asserts that `actual` is deeply equal to `expected`.
           *
           *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });
           *
           * @name deepEqual
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.deepEqual = function (act, exp, msg) {
            new Assertion(act, msg).to.eql(exp);
          };
    
          /**
           * ### .notDeepEqual(actual, expected, [message])
           *
           * Assert that `actual` is not deeply equal to `expected`.
           *
           *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
           *
           * @name notDeepEqual
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notDeepEqual = function (act, exp, msg) {
            new Assertion(act, msg).to.not.eql(exp);
          };
    
          /**
          * ### .isAbove(valueToCheck, valueToBeAbove, [message])
          *
          * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`
          *
          *     assert.isAbove(5, 2, '5 is strictly greater than 2');
          *
          * @name isAbove
          * @param {Mixed} valueToCheck
          * @param {Mixed} valueToBeAbove
          * @param {String} message
          * @namespace Assert
          * @api public
          */
    
          assert.isAbove = function (val, abv, msg) {
            new Assertion(val, msg).to.be.above(abv);
          };
    
          /**
          * ### .isAtLeast(valueToCheck, valueToBeAtLeast, [message])
          *
          * Asserts `valueToCheck` is greater than or equal to (>=) `valueToBeAtLeast`
          *
          *     assert.isAtLeast(5, 2, '5 is greater or equal to 2');
          *     assert.isAtLeast(3, 3, '3 is greater or equal to 3');
          *
          * @name isAtLeast
          * @param {Mixed} valueToCheck
          * @param {Mixed} valueToBeAtLeast
          * @param {String} message
          * @namespace Assert
          * @api public
          */
    
          assert.isAtLeast = function (val, atlst, msg) {
            new Assertion(val, msg).to.be.least(atlst);
          };
    
          /**
          * ### .isBelow(valueToCheck, valueToBeBelow, [message])
          *
          * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`
          *
          *     assert.isBelow(3, 6, '3 is strictly less than 6');
          *
          * @name isBelow
          * @param {Mixed} valueToCheck
          * @param {Mixed} valueToBeBelow
          * @param {String} message
          * @namespace Assert
          * @api public
          */
    
          assert.isBelow = function (val, blw, msg) {
            new Assertion(val, msg).to.be.below(blw);
          };
    
          /**
          * ### .isAtMost(valueToCheck, valueToBeAtMost, [message])
          *
          * Asserts `valueToCheck` is less than or equal to (<=) `valueToBeAtMost`
          *
          *     assert.isAtMost(3, 6, '3 is less than or equal to 6');
          *     assert.isAtMost(4, 4, '4 is less than or equal to 4');
          *
          * @name isAtMost
          * @param {Mixed} valueToCheck
          * @param {Mixed} valueToBeAtMost
          * @param {String} message
          * @namespace Assert
          * @api public
          */
    
          assert.isAtMost = function (val, atmst, msg) {
            new Assertion(val, msg).to.be.most(atmst);
          };
    
          /**
           * ### .isTrue(value, [message])
           *
           * Asserts that `value` is true.
           *
           *     var teaServed = true;
           *     assert.isTrue(teaServed, 'the tea has been served');
           *
           * @name isTrue
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isTrue = function (val, msg) {
            new Assertion(val, msg).is['true'];
          };
    
          /**
           * ### .isNotTrue(value, [message])
           *
           * Asserts that `value` is not true.
           *
           *     var tea = 'tasty chai';
           *     assert.isNotTrue(tea, 'great, time for tea!');
           *
           * @name isNotTrue
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotTrue = function (val, msg) {
            new Assertion(val, msg).to.not.equal(true);
          };
    
          /**
           * ### .isFalse(value, [message])
           *
           * Asserts that `value` is false.
           *
           *     var teaServed = false;
           *     assert.isFalse(teaServed, 'no tea yet? hmm...');
           *
           * @name isFalse
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isFalse = function (val, msg) {
            new Assertion(val, msg).is['false'];
          };
    
          /**
           * ### .isNotFalse(value, [message])
           *
           * Asserts that `value` is not false.
           *
           *     var tea = 'tasty chai';
           *     assert.isNotFalse(tea, 'great, time for tea!');
           *
           * @name isNotFalse
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotFalse = function (val, msg) {
            new Assertion(val, msg).to.not.equal(false);
          };
    
          /**
           * ### .isNull(value, [message])
           *
           * Asserts that `value` is null.
           *
           *     assert.isNull(err, 'there was no error');
           *
           * @name isNull
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNull = function (val, msg) {
            new Assertion(val, msg).to.equal(null);
          };
    
          /**
           * ### .isNotNull(value, [message])
           *
           * Asserts that `value` is not null.
           *
           *     var tea = 'tasty chai';
           *     assert.isNotNull(tea, 'great, time for tea!');
           *
           * @name isNotNull
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotNull = function (val, msg) {
            new Assertion(val, msg).to.not.equal(null);
          };
    
          /**
           * ### .isNaN
           * Asserts that value is NaN
           *
           *    assert.isNaN('foo', 'foo is NaN');
           *
           * @name isNaN
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNaN = function (val, msg) {
            new Assertion(val, msg).to.be.NaN;
          };
    
          /**
           * ### .isNotNaN
           * Asserts that value is not NaN
           *
           *    assert.isNotNaN(4, '4 is not NaN');
           *
           * @name isNotNaN
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
          assert.isNotNaN = function (val, msg) {
            new Assertion(val, msg).not.to.be.NaN;
          };
    
          /**
           * ### .isUndefined(value, [message])
           *
           * Asserts that `value` is `undefined`.
           *
           *     var tea;
           *     assert.isUndefined(tea, 'no tea defined');
           *
           * @name isUndefined
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isUndefined = function (val, msg) {
            new Assertion(val, msg).to.equal(undefined);
          };
    
          /**
           * ### .isDefined(value, [message])
           *
           * Asserts that `value` is not `undefined`.
           *
           *     var tea = 'cup of chai';
           *     assert.isDefined(tea, 'tea has been defined');
           *
           * @name isDefined
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isDefined = function (val, msg) {
            new Assertion(val, msg).to.not.equal(undefined);
          };
    
          /**
           * ### .isFunction(value, [message])
           *
           * Asserts that `value` is a function.
           *
           *     function serveTea() { return 'cup of tea'; };
           *     assert.isFunction(serveTea, 'great, we can have tea now');
           *
           * @name isFunction
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isFunction = function (val, msg) {
            new Assertion(val, msg).to.be.a('function');
          };
    
          /**
           * ### .isNotFunction(value, [message])
           *
           * Asserts that `value` is _not_ a function.
           *
           *     var serveTea = [ 'heat', 'pour', 'sip' ];
           *     assert.isNotFunction(serveTea, 'great, we have listed the steps');
           *
           * @name isNotFunction
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotFunction = function (val, msg) {
            new Assertion(val, msg).to.not.be.a('function');
          };
    
          /**
           * ### .isObject(value, [message])
           *
           * Asserts that `value` is an object of type 'Object' (as revealed by `Object.prototype.toString`).
           * _The assertion does not match subclassed objects._
           *
           *     var selection = { name: 'Chai', serve: 'with spices' };
           *     assert.isObject(selection, 'tea selection is an object');
           *
           * @name isObject
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isObject = function (val, msg) {
            new Assertion(val, msg).to.be.a('object');
          };
    
          /**
           * ### .isNotObject(value, [message])
           *
           * Asserts that `value` is _not_ an object of type 'Object' (as revealed by `Object.prototype.toString`).
           *
           *     var selection = 'chai'
           *     assert.isNotObject(selection, 'tea selection is not an object');
           *     assert.isNotObject(null, 'null is not an object');
           *
           * @name isNotObject
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotObject = function (val, msg) {
            new Assertion(val, msg).to.not.be.a('object');
          };
    
          /**
           * ### .isArray(value, [message])
           *
           * Asserts that `value` is an array.
           *
           *     var menu = [ 'green', 'chai', 'oolong' ];
           *     assert.isArray(menu, 'what kind of tea do we want?');
           *
           * @name isArray
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isArray = function (val, msg) {
            new Assertion(val, msg).to.be.an('array');
          };
    
          /**
           * ### .isNotArray(value, [message])
           *
           * Asserts that `value` is _not_ an array.
           *
           *     var menu = 'green|chai|oolong';
           *     assert.isNotArray(menu, 'what kind of tea do we want?');
           *
           * @name isNotArray
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotArray = function (val, msg) {
            new Assertion(val, msg).to.not.be.an('array');
          };
    
          /**
           * ### .isString(value, [message])
           *
           * Asserts that `value` is a string.
           *
           *     var teaOrder = 'chai';
           *     assert.isString(teaOrder, 'order placed');
           *
           * @name isString
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isString = function (val, msg) {
            new Assertion(val, msg).to.be.a('string');
          };
    
          /**
           * ### .isNotString(value, [message])
           *
           * Asserts that `value` is _not_ a string.
           *
           *     var teaOrder = 4;
           *     assert.isNotString(teaOrder, 'order placed');
           *
           * @name isNotString
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotString = function (val, msg) {
            new Assertion(val, msg).to.not.be.a('string');
          };
    
          /**
           * ### .isNumber(value, [message])
           *
           * Asserts that `value` is a number.
           *
           *     var cups = 2;
           *     assert.isNumber(cups, 'how many cups');
           *
           * @name isNumber
           * @param {Number} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNumber = function (val, msg) {
            new Assertion(val, msg).to.be.a('number');
          };
    
          /**
           * ### .isNotNumber(value, [message])
           *
           * Asserts that `value` is _not_ a number.
           *
           *     var cups = '2 cups please';
           *     assert.isNotNumber(cups, 'how many cups');
           *
           * @name isNotNumber
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotNumber = function (val, msg) {
            new Assertion(val, msg).to.not.be.a('number');
          };
    
          /**
           * ### .isBoolean(value, [message])
           *
           * Asserts that `value` is a boolean.
           *
           *     var teaReady = true
           *       , teaServed = false;
           *
           *     assert.isBoolean(teaReady, 'is the tea ready');
           *     assert.isBoolean(teaServed, 'has tea been served');
           *
           * @name isBoolean
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isBoolean = function (val, msg) {
            new Assertion(val, msg).to.be.a('boolean');
          };
    
          /**
           * ### .isNotBoolean(value, [message])
           *
           * Asserts that `value` is _not_ a boolean.
           *
           *     var teaReady = 'yep'
           *       , teaServed = 'nope';
           *
           *     assert.isNotBoolean(teaReady, 'is the tea ready');
           *     assert.isNotBoolean(teaServed, 'has tea been served');
           *
           * @name isNotBoolean
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.isNotBoolean = function (val, msg) {
            new Assertion(val, msg).to.not.be.a('boolean');
          };
    
          /**
           * ### .typeOf(value, name, [message])
           *
           * Asserts that `value`'s type is `name`, as determined by
           * `Object.prototype.toString`.
           *
           *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
           *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
           *     assert.typeOf('tea', 'string', 'we have a string');
           *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
           *     assert.typeOf(null, 'null', 'we have a null');
           *     assert.typeOf(undefined, 'undefined', 'we have an undefined');
           *
           * @name typeOf
           * @param {Mixed} value
           * @param {String} name
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.typeOf = function (val, type, msg) {
            new Assertion(val, msg).to.be.a(type);
          };
    
          /**
           * ### .notTypeOf(value, name, [message])
           *
           * Asserts that `value`'s type is _not_ `name`, as determined by
           * `Object.prototype.toString`.
           *
           *     assert.notTypeOf('tea', 'number', 'strings are not numbers');
           *
           * @name notTypeOf
           * @param {Mixed} value
           * @param {String} typeof name
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notTypeOf = function (val, type, msg) {
            new Assertion(val, msg).to.not.be.a(type);
          };
    
          /**
           * ### .instanceOf(object, constructor, [message])
           *
           * Asserts that `value` is an instance of `constructor`.
           *
           *     var Tea = function (name) { this.name = name; }
           *       , chai = new Tea('chai');
           *
           *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');
           *
           * @name instanceOf
           * @param {Object} object
           * @param {Constructor} constructor
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.instanceOf = function (val, type, msg) {
            new Assertion(val, msg).to.be.instanceOf(type);
          };
    
          /**
           * ### .notInstanceOf(object, constructor, [message])
           *
           * Asserts `value` is not an instance of `constructor`.
           *
           *     var Tea = function (name) { this.name = name; }
           *       , chai = new String('chai');
           *
           *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
           *
           * @name notInstanceOf
           * @param {Object} object
           * @param {Constructor} constructor
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notInstanceOf = function (val, type, msg) {
            new Assertion(val, msg).to.not.be.instanceOf(type);
          };
    
          /**
           * ### .include(haystack, needle, [message])
           *
           * Asserts that `haystack` includes `needle`. Works
           * for strings and arrays.
           *
           *     assert.include('foobar', 'bar', 'foobar contains string "bar"');
           *     assert.include([ 1, 2, 3 ], 3, 'array contains value');
           *
           * @name include
           * @param {Array|String} haystack
           * @param {Mixed} needle
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.include = function (exp, inc, msg) {
            new Assertion(exp, msg, assert.include).include(inc);
          };
    
          /**
           * ### .notInclude(haystack, needle, [message])
           *
           * Asserts that `haystack` does not include `needle`. Works
           * for strings and arrays.
           *
           *     assert.notInclude('foobar', 'baz', 'string not include substring');
           *     assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value');
           *
           * @name notInclude
           * @param {Array|String} haystack
           * @param {Mixed} needle
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notInclude = function (exp, inc, msg) {
            new Assertion(exp, msg, assert.notInclude).not.include(inc);
          };
    
          /**
           * ### .match(value, regexp, [message])
           *
           * Asserts that `value` matches the regular expression `regexp`.
           *
           *     assert.match('foobar', /^foo/, 'regexp matches');
           *
           * @name match
           * @param {Mixed} value
           * @param {RegExp} regexp
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.match = function (exp, re, msg) {
            new Assertion(exp, msg).to.match(re);
          };
    
          /**
           * ### .notMatch(value, regexp, [message])
           *
           * Asserts that `value` does not match the regular expression `regexp`.
           *
           *     assert.notMatch('foobar', /^foo/, 'regexp does not match');
           *
           * @name notMatch
           * @param {Mixed} value
           * @param {RegExp} regexp
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notMatch = function (exp, re, msg) {
            new Assertion(exp, msg).to.not.match(re);
          };
    
          /**
           * ### .property(object, property, [message])
           *
           * Asserts that `object` has a property named by `property`.
           *
           *     assert.property({ tea: { green: 'matcha' }}, 'tea');
           *
           * @name property
           * @param {Object} object
           * @param {String} property
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.property = function (obj, prop, msg) {
            new Assertion(obj, msg).to.have.property(prop);
          };
    
          /**
           * ### .notProperty(object, property, [message])
           *
           * Asserts that `object` does _not_ have a property named by `property`.
           *
           *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
           *
           * @name notProperty
           * @param {Object} object
           * @param {String} property
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notProperty = function (obj, prop, msg) {
            new Assertion(obj, msg).to.not.have.property(prop);
          };
    
          /**
           * ### .deepProperty(object, property, [message])
           *
           * Asserts that `object` has a property named by `property`, which can be a
           * string using dot- and bracket-notation for deep reference.
           *
           *     assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');
           *
           * @name deepProperty
           * @param {Object} object
           * @param {String} property
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.deepProperty = function (obj, prop, msg) {
            new Assertion(obj, msg).to.have.deep.property(prop);
          };
    
          /**
           * ### .notDeepProperty(object, property, [message])
           *
           * Asserts that `object` does _not_ have a property named by `property`, which
           * can be a string using dot- and bracket-notation for deep reference.
           *
           *     assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
           *
           * @name notDeepProperty
           * @param {Object} object
           * @param {String} property
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.notDeepProperty = function (obj, prop, msg) {
            new Assertion(obj, msg).to.not.have.deep.property(prop);
          };
    
          /**
           * ### .propertyVal(object, property, value, [message])
           *
           * Asserts that `object` has a property named by `property` with value given
           * by `value`.
           *
           *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
           *
           * @name propertyVal
           * @param {Object} object
           * @param {String} property
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.propertyVal = function (obj, prop, val, msg) {
            new Assertion(obj, msg).to.have.property(prop, val);
          };
    
          /**
           * ### .propertyNotVal(object, property, value, [message])
           *
           * Asserts that `object` has a property named by `property`, but with a value
           * different from that given by `value`.
           *
           *     assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');
           *
           * @name propertyNotVal
           * @param {Object} object
           * @param {String} property
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.propertyNotVal = function (obj, prop, val, msg) {
            new Assertion(obj, msg).to.not.have.property(prop, val);
          };
    
          /**
           * ### .deepPropertyVal(object, property, value, [message])
           *
           * Asserts that `object` has a property named by `property` with value given
           * by `value`. `property` can use dot- and bracket-notation for deep
           * reference.
           *
           *     assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
           *
           * @name deepPropertyVal
           * @param {Object} object
           * @param {String} property
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.deepPropertyVal = function (obj, prop, val, msg) {
            new Assertion(obj, msg).to.have.deep.property(prop, val);
          };
    
          /**
           * ### .deepPropertyNotVal(object, property, value, [message])
           *
           * Asserts that `object` has a property named by `property`, but with a value
           * different from that given by `value`. `property` can use dot- and
           * bracket-notation for deep reference.
           *
           *     assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
           *
           * @name deepPropertyNotVal
           * @param {Object} object
           * @param {String} property
           * @param {Mixed} value
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.deepPropertyNotVal = function (obj, prop, val, msg) {
            new Assertion(obj, msg).to.not.have.deep.property(prop, val);
          };
    
          /**
           * ### .lengthOf(object, length, [message])
           *
           * Asserts that `object` has a `length` property with the expected value.
           *
           *     assert.lengthOf([1,2,3], 3, 'array has length of 3');
           *     assert.lengthOf('foobar', 6, 'string has length of 6');
           *
           * @name lengthOf
           * @param {Mixed} object
           * @param {Number} length
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.lengthOf = function (exp, len, msg) {
            new Assertion(exp, msg).to.have.length(len);
          };
    
          /**
           * ### .throws(function, [constructor/string/regexp], [string/regexp], [message])
           *
           * Asserts that `function` will throw an error that is an instance of
           * `constructor`, or alternately that it will throw an error with message
           * matching `regexp`.
           *
           *     assert.throws(fn, 'function throws a reference error');
           *     assert.throws(fn, /function throws a reference error/);
           *     assert.throws(fn, ReferenceError);
           *     assert.throws(fn, ReferenceError, 'function throws a reference error');
           *     assert.throws(fn, ReferenceError, /function throws a reference error/);
           *
           * @name throws
           * @alias throw
           * @alias Throw
           * @param {Function} function
           * @param {ErrorConstructor} constructor
           * @param {RegExp} regexp
           * @param {String} message
           * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
           * @namespace Assert
           * @api public
           */
    
          assert.throws = function (fn, errt, errs, msg) {
            if ('string' === typeof errt || errt instanceof RegExp) {
              errs = errt;
              errt = null;
            }
    
            var assertErr = new Assertion(fn, msg).to.throw(errt, errs);
            return flag(assertErr, 'object');
          };
    
          /**
           * ### .doesNotThrow(function, [constructor/regexp], [message])
           *
           * Asserts that `function` will _not_ throw an error that is an instance of
           * `constructor`, or alternately that it will not throw an error with message
           * matching `regexp`.
           *
           *     assert.doesNotThrow(fn, Error, 'function does not throw');
           *
           * @name doesNotThrow
           * @param {Function} function
           * @param {ErrorConstructor} constructor
           * @param {RegExp} regexp
           * @param {String} message
           * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
           * @namespace Assert
           * @api public
           */
    
          assert.doesNotThrow = function (fn, type, msg) {
            if ('string' === typeof type) {
              msg = type;
              type = null;
            }
    
            new Assertion(fn, msg).to.not.Throw(type);
          };
    
          /**
           * ### .operator(val1, operator, val2, [message])
           *
           * Compares two values using `operator`.
           *
           *     assert.operator(1, '<', 2, 'everything is ok');
           *     assert.operator(1, '>', 2, 'this will fail');
           *
           * @name operator
           * @param {Mixed} val1
           * @param {String} operator
           * @param {Mixed} val2
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.operator = function (val, operator, val2, msg) {
            var ok;
            switch (operator) {
              case '==':
                ok = val == val2;
                break;
              case '===':
                ok = val === val2;
                break;
              case '>':
                ok = val > val2;
                break;
              case '>=':
                ok = val >= val2;
                break;
              case '<':
                ok = val < val2;
                break;
              case '<=':
                ok = val <= val2;
                break;
              case '!=':
                ok = val != val2;
                break;
              case '!==':
                ok = val !== val2;
                break;
              default:
                throw new Error('Invalid operator "' + operator + '"');
            }
            var test = new Assertion(ok, msg);
            test.assert(true === flag(test, 'object'), 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2), 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2));
          };
    
          /**
           * ### .closeTo(actual, expected, delta, [message])
           *
           * Asserts that the target is equal `expected`, to within a +/- `delta` range.
           *
           *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');
           *
           * @name closeTo
           * @param {Number} actual
           * @param {Number} expected
           * @param {Number} delta
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.closeTo = function (act, exp, delta, msg) {
            new Assertion(act, msg).to.be.closeTo(exp, delta);
          };
    
          /**
           * ### .approximately(actual, expected, delta, [message])
           *
           * Asserts that the target is equal `expected`, to within a +/- `delta` range.
           *
           *     assert.approximately(1.5, 1, 0.5, 'numbers are close');
           *
           * @name approximately
           * @param {Number} actual
           * @param {Number} expected
           * @param {Number} delta
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.approximately = function (act, exp, delta, msg) {
            new Assertion(act, msg).to.be.approximately(exp, delta);
          };
    
          /**
           * ### .sameMembers(set1, set2, [message])
           *
           * Asserts that `set1` and `set2` have the same members.
           * Order is not taken into account.
           *
           *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
           *
           * @name sameMembers
           * @param {Array} set1
           * @param {Array} set2
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.sameMembers = function (set1, set2, msg) {
            new Assertion(set1, msg).to.have.same.members(set2);
          };
    
          /**
           * ### .sameDeepMembers(set1, set2, [message])
           *
           * Asserts that `set1` and `set2` have the same members - using a deep equality checking.
           * Order is not taken into account.
           *
           *     assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members');
           *
           * @name sameDeepMembers
           * @param {Array} set1
           * @param {Array} set2
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.sameDeepMembers = function (set1, set2, msg) {
            new Assertion(set1, msg).to.have.same.deep.members(set2);
          };
    
          /**
           * ### .includeMembers(superset, subset, [message])
           *
           * Asserts that `subset` is included in `superset`.
           * Order is not taken into account.
           *
           *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');
           *
           * @name includeMembers
           * @param {Array} superset
           * @param {Array} subset
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.includeMembers = function (superset, subset, msg) {
            new Assertion(superset, msg).to.include.members(subset);
          };
    
          /**
           * ### .includeDeepMembers(superset, subset, [message])
           *
           * Asserts that `subset` is included in `superset` - using deep equality checking.
           * Order is not taken into account.
           * Duplicates are ignored.
           *
           *     assert.includeDeepMembers([ {a: 1}, {b: 2}, {c: 3} ], [ {b: 2}, {a: 1}, {b: 2} ], 'include deep members');
           *
           * @name includeDeepMembers
           * @param {Array} superset
           * @param {Array} subset
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.includeDeepMembers = function (superset, subset, msg) {
            new Assertion(superset, msg).to.include.deep.members(subset);
          };
    
          /**
           * ### .oneOf(inList, list, [message])
           *
           * Asserts that non-object, non-array value `inList` appears in the flat array `list`.
           *
           *     assert.oneOf(1, [ 2, 1 ], 'Not found in list');
           *
           * @name oneOf
           * @param {*} inList
           * @param {Array<*>} list
           * @param {String} message
           * @namespace Assert
           * @api public
           */
    
          assert.oneOf = function (inList, list, msg) {
            new Assertion(inList, msg).to.be.oneOf(list);
          };
    
          /**
          * ### .changes(function, object, property)
          *
          * Asserts that a function changes the value of a property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { obj.val = 22 };
          *     assert.changes(fn, obj, 'val');
          *
          * @name changes
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.changes = function (fn, obj, prop) {
            new Assertion(fn).to.change(obj, prop);
          };
    
          /**
          * ### .doesNotChange(function, object, property)
          *
          * Asserts that a function does not changes the value of a property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { console.log('foo'); };
          *     assert.doesNotChange(fn, obj, 'val');
          *
          * @name doesNotChange
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.doesNotChange = function (fn, obj, prop) {
            new Assertion(fn).to.not.change(obj, prop);
          };
    
          /**
          * ### .increases(function, object, property)
          *
          * Asserts that a function increases an object property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { obj.val = 13 };
          *     assert.increases(fn, obj, 'val');
          *
          * @name increases
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.increases = function (fn, obj, prop) {
            new Assertion(fn).to.increase(obj, prop);
          };
    
          /**
          * ### .doesNotIncrease(function, object, property)
          *
          * Asserts that a function does not increase object property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { obj.val = 8 };
          *     assert.doesNotIncrease(fn, obj, 'val');
          *
          * @name doesNotIncrease
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.doesNotIncrease = function (fn, obj, prop) {
            new Assertion(fn).to.not.increase(obj, prop);
          };
    
          /**
          * ### .decreases(function, object, property)
          *
          * Asserts that a function decreases an object property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { obj.val = 5 };
          *     assert.decreases(fn, obj, 'val');
          *
          * @name decreases
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.decreases = function (fn, obj, prop) {
            new Assertion(fn).to.decrease(obj, prop);
          };
    
          /**
          * ### .doesNotDecrease(function, object, property)
          *
          * Asserts that a function does not decreases an object property
          *
          *     var obj = { val: 10 };
          *     var fn = function() { obj.val = 15 };
          *     assert.doesNotDecrease(fn, obj, 'val');
          *
          * @name doesNotDecrease
          * @param {Function} modifier function
          * @param {Object} object
          * @param {String} property name
          * @param {String} message _optional_
          * @namespace Assert
          * @api public
          */
    
          assert.doesNotDecrease = function (fn, obj, prop) {
            new Assertion(fn).to.not.decrease(obj, prop);
          };
    
          /*!
           * ### .ifError(object)
           *
           * Asserts if value is not a false value, and throws if it is a true value.
           * This is added to allow for chai to be a drop-in replacement for Node's
           * assert class.
           *
           *     var err = new Error('I am a custom error');
           *     assert.ifError(err); // Rethrows err!
           *
           * @name ifError
           * @param {Object} object
           * @namespace Assert
           * @api public
           */
    
          assert.ifError = function (val) {
            if (val) {
              throw val;
            }
          };
    
          /**
           * ### .isExtensible(object)
           *
           * Asserts that `object` is extensible (can have new properties added to it).
           *
           *     assert.isExtensible({});
           *
           * @name isExtensible
           * @alias extensible
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isExtensible = function (obj, msg) {
            new Assertion(obj, msg).to.be.extensible;
          };
    
          /**
           * ### .isNotExtensible(object)
           *
           * Asserts that `object` is _not_ extensible.
           *
           *     var nonExtensibleObject = Object.preventExtensions({});
           *     var sealedObject = Object.seal({});
           *     var frozenObject = Object.freese({});
           *
           *     assert.isNotExtensible(nonExtensibleObject);
           *     assert.isNotExtensible(sealedObject);
           *     assert.isNotExtensible(frozenObject);
           *
           * @name isNotExtensible
           * @alias notExtensible
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isNotExtensible = function (obj, msg) {
            new Assertion(obj, msg).to.not.be.extensible;
          };
    
          /**
           * ### .isSealed(object)
           *
           * Asserts that `object` is sealed (cannot have new properties added to it
           * and its existing properties cannot be removed).
           *
           *     var sealedObject = Object.seal({});
           *     var frozenObject = Object.seal({});
           *
           *     assert.isSealed(sealedObject);
           *     assert.isSealed(frozenObject);
           *
           * @name isSealed
           * @alias sealed
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isSealed = function (obj, msg) {
            new Assertion(obj, msg).to.be.sealed;
          };
    
          /**
           * ### .isNotSealed(object)
           *
           * Asserts that `object` is _not_ sealed.
           *
           *     assert.isNotSealed({});
           *
           * @name isNotSealed
           * @alias notSealed
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isNotSealed = function (obj, msg) {
            new Assertion(obj, msg).to.not.be.sealed;
          };
    
          /**
           * ### .isFrozen(object)
           *
           * Asserts that `object` is frozen (cannot have new properties added to it
           * and its existing properties cannot be modified).
           *
           *     var frozenObject = Object.freeze({});
           *     assert.frozen(frozenObject);
           *
           * @name isFrozen
           * @alias frozen
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isFrozen = function (obj, msg) {
            new Assertion(obj, msg).to.be.frozen;
          };
    
          /**
           * ### .isNotFrozen(object)
           *
           * Asserts that `object` is _not_ frozen.
           *
           *     assert.isNotFrozen({});
           *
           * @name isNotFrozen
           * @alias notFrozen
           * @param {Object} object
           * @param {String} message _optional_
           * @namespace Assert
           * @api public
           */
    
          assert.isNotFrozen = function (obj, msg) {
            new Assertion(obj, msg).to.not.be.frozen;
          };
    
          /*!
           * Aliases.
           */
    
          (function alias(name, as) {
            assert[as] = assert[name];
            return alias;
          })('isOk', 'ok')('isNotOk', 'notOk')('throws', 'throw')('throws', 'Throw')('isExtensible', 'extensible')('isNotExtensible', 'notExtensible')('isSealed', 'sealed')('isNotSealed', 'notSealed')('isFrozen', 'frozen')('isNotFrozen', 'notFrozen');
        };
      });
    
      var require$$0$2 = assert && (typeof assert === 'undefined' ? 'undefined' : babelHelpers.typeof(assert)) === 'object' && 'default' in assert ? assert['default'] : assert;
    
      var should = __commonjs(function (module) {
        /*!
         * chai
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        module.exports = function (chai, util) {
          var Assertion = chai.Assertion;
    
          function loadShould() {
            // explicitly define this method as function as to have it's name to include as `ssfi`
            function shouldGetter() {
              if (this instanceof String || this instanceof Number || this instanceof Boolean) {
                return new Assertion(this.valueOf(), null, shouldGetter);
              }
              return new Assertion(this, null, shouldGetter);
            }
            function shouldSetter(value) {
              // See https://github.com/chaijs/chai/issues/86: this makes
              // `whatever.should = someValue` actually set `someValue`, which is
              // especially useful for `global.should = require('chai').should()`.
              //
              // Note that we have to use [[DefineProperty]] instead of [[Put]]
              // since otherwise we would trigger this very setter!
              Object.defineProperty(this, 'should', {
                value: value,
                enumerable: true,
                configurable: true,
                writable: true
              });
            }
            // modify Object.prototype to have `should`
            Object.defineProperty(Object.prototype, 'should', {
              set: shouldSetter,
              get: shouldGetter,
              configurable: true
            });
    
            var should = {};
    
            /**
             * ### .fail(actual, expected, [message], [operator])
             *
             * Throw a failure.
             *
             * @name fail
             * @param {Mixed} actual
             * @param {Mixed} expected
             * @param {String} message
             * @param {String} operator
             * @namespace Should
             * @api public
             */
    
            should.fail = function (actual, expected, message, operator) {
              message = message || 'should.fail()';
              throw new chai.AssertionError(message, {
                actual: actual,
                expected: expected,
                operator: operator
              }, should.fail);
            };
    
            /**
             * ### .equal(actual, expected, [message])
             *
             * Asserts non-strict equality (`==`) of `actual` and `expected`.
             *
             *     should.equal(3, '3', '== coerces values to strings');
             *
             * @name equal
             * @param {Mixed} actual
             * @param {Mixed} expected
             * @param {String} message
             * @namespace Should
             * @api public
             */
    
            should.equal = function (val1, val2, msg) {
              new Assertion(val1, msg).to.equal(val2);
            };
    
            /**
             * ### .throw(function, [constructor/string/regexp], [string/regexp], [message])
             *
             * Asserts that `function` will throw an error that is an instance of
             * `constructor`, or alternately that it will throw an error with message
             * matching `regexp`.
             *
             *     should.throw(fn, 'function throws a reference error');
             *     should.throw(fn, /function throws a reference error/);
             *     should.throw(fn, ReferenceError);
             *     should.throw(fn, ReferenceError, 'function throws a reference error');
             *     should.throw(fn, ReferenceError, /function throws a reference error/);
             *
             * @name throw
             * @alias Throw
             * @param {Function} function
             * @param {ErrorConstructor} constructor
             * @param {RegExp} regexp
             * @param {String} message
             * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
             * @namespace Should
             * @api public
             */
    
            should.Throw = function (fn, errt, errs, msg) {
              new Assertion(fn, msg).to.Throw(errt, errs);
            };
    
            /**
             * ### .exist
             *
             * Asserts that the target is neither `null` nor `undefined`.
             *
             *     var foo = 'hi';
             *
             *     should.exist(foo, 'foo exists');
             *
             * @name exist
             * @namespace Should
             * @api public
             */
    
            should.exist = function (val, msg) {
              new Assertion(val, msg).to.exist;
            };
    
            // negation
            should.not = {};
    
            /**
             * ### .not.equal(actual, expected, [message])
             *
             * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
             *
             *     should.not.equal(3, 4, 'these numbers are not equal');
             *
             * @name not.equal
             * @param {Mixed} actual
             * @param {Mixed} expected
             * @param {String} message
             * @namespace Should
             * @api public
             */
    
            should.not.equal = function (val1, val2, msg) {
              new Assertion(val1, msg).to.not.equal(val2);
            };
    
            /**
             * ### .throw(function, [constructor/regexp], [message])
             *
             * Asserts that `function` will _not_ throw an error that is an instance of
             * `constructor`, or alternately that it will not throw an error with message
             * matching `regexp`.
             *
             *     should.not.throw(fn, Error, 'function does not throw');
             *
             * @name not.throw
             * @alias not.Throw
             * @param {Function} function
             * @param {ErrorConstructor} constructor
             * @param {RegExp} regexp
             * @param {String} message
             * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
             * @namespace Should
             * @api public
             */
    
            should.not.Throw = function (fn, errt, errs, msg) {
              new Assertion(fn, msg).to.not.Throw(errt, errs);
            };
    
            /**
             * ### .not.exist
             *
             * Asserts that the target is neither `null` nor `undefined`.
             *
             *     var bar = null;
             *
             *     should.not.exist(bar, 'bar does not exist');
             *
             * @name not.exist
             * @namespace Should
             * @api public
             */
    
            should.not.exist = function (val, msg) {
              new Assertion(val, msg).to.not.exist;
            };
    
            should['throw'] = should['Throw'];
            should.not['throw'] = should.not['Throw'];
    
            return should;
          };
    
          chai.should = loadShould;
          chai.Should = loadShould;
        };
      });
    
      var require$$1 = should && (typeof should === 'undefined' ? 'undefined' : babelHelpers.typeof(should)) === 'object' && 'default' in should ? should['default'] : should;
    
      var expect = __commonjs(function (module) {
        /*!
         * chai
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        module.exports = function (chai, util) {
          chai.expect = function (val, message) {
            return new chai.Assertion(val, message);
          };
    
          /**
           * ### .fail(actual, expected, [message], [operator])
           *
           * Throw a failure.
           *
           * @name fail
           * @param {Mixed} actual
           * @param {Mixed} expected
           * @param {String} message
           * @param {String} operator
           * @namespace Expect
           * @api public
           */
    
          chai.expect.fail = function (actual, expected, message, operator) {
            message = message || 'expect.fail()';
            throw new chai.AssertionError(message, {
              actual: actual,
              expected: expected,
              operator: operator
            }, chai.expect.fail);
          };
        };
      });
    
      var require$$2 = expect && (typeof expect === 'undefined' ? 'undefined' : babelHelpers.typeof(expect)) === 'object' && 'default' in expect ? expect['default'] : expect;
    
      var assertions = __commonjs(function (module) {
        /*!
         * chai
         * http://chaijs.com
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        module.exports = function (chai, _) {
          var Assertion = chai.Assertion,
              toString = Object.prototype.toString,
              flag = _.flag;
    
          /**
           * ### Language Chains
           *
           * The following are provided as chainable getters to
           * improve the readability of your assertions. They
           * do not provide testing capabilities unless they
           * have been overwritten by a plugin.
           *
           * **Chains**
           *
           * - to
           * - be
           * - been
           * - is
           * - that
           * - which
           * - and
           * - has
           * - have
           * - with
           * - at
           * - of
           * - same
           *
           * @name language chains
           * @namespace BDD
           * @api public
           */
    
          ['to', 'be', 'been', 'is', 'and', 'has', 'have', 'with', 'that', 'which', 'at', 'of', 'same'].forEach(function (chain) {
            Assertion.addProperty(chain, function () {
              return this;
            });
          });
    
          /**
           * ### .not
           *
           * Negates any of assertions following in the chain.
           *
           *     expect(foo).to.not.equal('bar');
           *     expect(goodFn).to.not.throw(Error);
           *     expect({ foo: 'baz' }).to.have.property('foo')
           *       .and.not.equal('bar');
           *
           * @name not
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('not', function () {
            flag(this, 'negate', true);
          });
    
          /**
           * ### .deep
           *
           * Sets the `deep` flag, later used by the `equal` and
           * `property` assertions.
           *
           *     expect(foo).to.deep.equal({ bar: 'baz' });
           *     expect({ foo: { bar: { baz: 'quux' } } })
           *       .to.have.deep.property('foo.bar.baz', 'quux');
           *
           * `.deep.property` special characters can be escaped
           * by adding two slashes before the `.` or `[]`.
           *
           *     var deepCss = { '.link': { '[target]': 42 }};
           *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
           *
           * @name deep
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('deep', function () {
            flag(this, 'deep', true);
          });
    
          /**
           * ### .any
           *
           * Sets the `any` flag, (opposite of the `all` flag)
           * later used in the `keys` assertion.
           *
           *     expect(foo).to.have.any.keys('bar', 'baz');
           *
           * @name any
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('any', function () {
            flag(this, 'any', true);
            flag(this, 'all', false);
          });
    
          /**
           * ### .all
           *
           * Sets the `all` flag (opposite of the `any` flag)
           * later used by the `keys` assertion.
           *
           *     expect(foo).to.have.all.keys('bar', 'baz');
           *
           * @name all
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('all', function () {
            flag(this, 'all', true);
            flag(this, 'any', false);
          });
    
          /**
           * ### .a(type)
           *
           * The `a` and `an` assertions are aliases that can be
           * used either as language chains or to assert a value's
           * type.
           *
           *     // typeof
           *     expect('test').to.be.a('string');
           *     expect({ foo: 'bar' }).to.be.an('object');
           *     expect(null).to.be.a('null');
           *     expect(undefined).to.be.an('undefined');
           *     expect(new Error).to.be.an('error');
           *     expect(new Promise).to.be.a('promise');
           *     expect(new Float32Array()).to.be.a('float32array');
           *     expect(Symbol()).to.be.a('symbol');
           *
           *     // es6 overrides
           *     expect({[Symbol.toStringTag]:()=>'foo'}).to.be.a('foo');
           *
           *     // language chain
           *     expect(foo).to.be.an.instanceof(Foo);
           *
           * @name a
           * @alias an
           * @param {String} type
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function an(type, msg) {
            if (msg) flag(this, 'message', msg);
            type = type.toLowerCase();
            var obj = flag(this, 'object'),
                article = ~['a', 'e', 'i', 'o', 'u'].indexOf(type.charAt(0)) ? 'an ' : 'a ';
    
            this.assert(type === _.type(obj), 'expected #{this} to be ' + article + type, 'expected #{this} not to be ' + article + type);
          }
    
          Assertion.addChainableMethod('an', an);
          Assertion.addChainableMethod('a', an);
    
          /**
           * ### .include(value)
           *
           * The `include` and `contain` assertions can be used as either property
           * based language chains or as methods to assert the inclusion of an object
           * in an array or a substring in a string. When used as language chains,
           * they toggle the `contains` flag for the `keys` assertion.
           *
           *     expect([1,2,3]).to.include(2);
           *     expect('foobar').to.contain('foo');
           *     expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');
           *
           * @name include
           * @alias contain
           * @alias includes
           * @alias contains
           * @param {Object|String|Number} obj
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function includeChainingBehavior() {
            flag(this, 'contains', true);
          }
    
          function include(val, msg) {
            _.expectTypes(this, ['array', 'object', 'string']);
    
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            var expected = false;
    
            if (_.type(obj) === 'array' && _.type(val) === 'object') {
              for (var i in obj) {
                if (_.eql(obj[i], val)) {
                  expected = true;
                  break;
                }
              }
            } else if (_.type(val) === 'object') {
              if (!flag(this, 'negate')) {
                for (var k in val) {
                  new Assertion(obj).property(k, val[k]);
                }return;
              }
              var subset = {};
              for (var k in val) {
                subset[k] = obj[k];
              }expected = _.eql(subset, val);
            } else {
              expected = obj != undefined && ~obj.indexOf(val);
            }
            this.assert(expected, 'expected #{this} to include ' + _.inspect(val), 'expected #{this} to not include ' + _.inspect(val));
          }
    
          Assertion.addChainableMethod('include', include, includeChainingBehavior);
          Assertion.addChainableMethod('contain', include, includeChainingBehavior);
          Assertion.addChainableMethod('contains', include, includeChainingBehavior);
          Assertion.addChainableMethod('includes', include, includeChainingBehavior);
    
          /**
           * ### .ok
           *
           * Asserts that the target is truthy.
           *
           *     expect('everything').to.be.ok;
           *     expect(1).to.be.ok;
           *     expect(false).to.not.be.ok;
           *     expect(undefined).to.not.be.ok;
           *     expect(null).to.not.be.ok;
           *
           * @name ok
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('ok', function () {
            this.assert(flag(this, 'object'), 'expected #{this} to be truthy', 'expected #{this} to be falsy');
          });
    
          /**
           * ### .true
           *
           * Asserts that the target is `true`.
           *
           *     expect(true).to.be.true;
           *     expect(1).to.not.be.true;
           *
           * @name true
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('true', function () {
            this.assert(true === flag(this, 'object'), 'expected #{this} to be true', 'expected #{this} to be false', this.negate ? false : true);
          });
    
          /**
           * ### .false
           *
           * Asserts that the target is `false`.
           *
           *     expect(false).to.be.false;
           *     expect(0).to.not.be.false;
           *
           * @name false
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('false', function () {
            this.assert(false === flag(this, 'object'), 'expected #{this} to be false', 'expected #{this} to be true', this.negate ? true : false);
          });
    
          /**
           * ### .null
           *
           * Asserts that the target is `null`.
           *
           *     expect(null).to.be.null;
           *     expect(undefined).to.not.be.null;
           *
           * @name null
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('null', function () {
            this.assert(null === flag(this, 'object'), 'expected #{this} to be null', 'expected #{this} not to be null');
          });
    
          /**
           * ### .undefined
           *
           * Asserts that the target is `undefined`.
           *
           *     expect(undefined).to.be.undefined;
           *     expect(null).to.not.be.undefined;
           *
           * @name undefined
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('undefined', function () {
            this.assert(undefined === flag(this, 'object'), 'expected #{this} to be undefined', 'expected #{this} not to be undefined');
          });
    
          /**
           * ### .NaN
           * Asserts that the target is `NaN`.
           *
           *     expect('foo').to.be.NaN;
           *     expect(4).not.to.be.NaN;
           *
           * @name NaN
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('NaN', function () {
            this.assert(isNaN(flag(this, 'object')), 'expected #{this} to be NaN', 'expected #{this} not to be NaN');
          });
    
          /**
           * ### .exist
           *
           * Asserts that the target is neither `null` nor `undefined`.
           *
           *     var foo = 'hi'
           *       , bar = null
           *       , baz;
           *
           *     expect(foo).to.exist;
           *     expect(bar).to.not.exist;
           *     expect(baz).to.not.exist;
           *
           * @name exist
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('exist', function () {
            this.assert(null != flag(this, 'object'), 'expected #{this} to exist', 'expected #{this} to not exist');
          });
    
          /**
           * ### .empty
           *
           * Asserts that the target's length is `0`. For arrays and strings, it checks
           * the `length` property. For objects, it gets the count of
           * enumerable keys.
           *
           *     expect([]).to.be.empty;
           *     expect('').to.be.empty;
           *     expect({}).to.be.empty;
           *
           * @name empty
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('empty', function () {
            var obj = flag(this, 'object'),
                expected = obj;
    
            if (Array.isArray(obj) || 'string' === typeof object) {
              expected = obj.length;
            } else if ((typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) === 'object') {
              expected = Object.keys(obj).length;
            }
    
            this.assert(!expected, 'expected #{this} to be empty', 'expected #{this} not to be empty');
          });
    
          /**
           * ### .arguments
           *
           * Asserts that the target is an arguments object.
           *
           *     function test () {
           *       expect(arguments).to.be.arguments;
           *     }
           *
           * @name arguments
           * @alias Arguments
           * @namespace BDD
           * @api public
           */
    
          function checkArguments() {
            var obj = flag(this, 'object'),
                type = Object.prototype.toString.call(obj);
            this.assert('[object Arguments]' === type, 'expected #{this} to be arguments but got ' + type, 'expected #{this} to not be arguments');
          }
    
          Assertion.addProperty('arguments', checkArguments);
          Assertion.addProperty('Arguments', checkArguments);
    
          /**
           * ### .equal(value)
           *
           * Asserts that the target is strictly equal (`===`) to `value`.
           * Alternately, if the `deep` flag is set, asserts that
           * the target is deeply equal to `value`.
           *
           *     expect('hello').to.equal('hello');
           *     expect(42).to.equal(42);
           *     expect(1).to.not.equal(true);
           *     expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
           *     expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
           *
           * @name equal
           * @alias equals
           * @alias eq
           * @alias deep.equal
           * @param {Mixed} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertEqual(val, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            if (flag(this, 'deep')) {
              return this.eql(val);
            } else {
              this.assert(val === obj, 'expected #{this} to equal #{exp}', 'expected #{this} to not equal #{exp}', val, this._obj, true);
            }
          }
    
          Assertion.addMethod('equal', assertEqual);
          Assertion.addMethod('equals', assertEqual);
          Assertion.addMethod('eq', assertEqual);
    
          /**
           * ### .eql(value)
           *
           * Asserts that the target is deeply equal to `value`.
           *
           *     expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
           *     expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
           *
           * @name eql
           * @alias eqls
           * @param {Mixed} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertEql(obj, msg) {
            if (msg) flag(this, 'message', msg);
            this.assert(_.eql(obj, flag(this, 'object')), 'expected #{this} to deeply equal #{exp}', 'expected #{this} to not deeply equal #{exp}', obj, this._obj, true);
          }
    
          Assertion.addMethod('eql', assertEql);
          Assertion.addMethod('eqls', assertEql);
    
          /**
           * ### .above(value)
           *
           * Asserts that the target is greater than `value`.
           *
           *     expect(10).to.be.above(5);
           *
           * Can also be used in conjunction with `length` to
           * assert a minimum length. The benefit being a
           * more informative error message than if the length
           * was supplied directly.
           *
           *     expect('foo').to.have.length.above(2);
           *     expect([ 1, 2, 3 ]).to.have.length.above(2);
           *
           * @name above
           * @alias gt
           * @alias greaterThan
           * @param {Number} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertAbove(n, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            if (flag(this, 'doLength')) {
              new Assertion(obj, msg).to.have.property('length');
              var len = obj.length;
              this.assert(len > n, 'expected #{this} to have a length above #{exp} but got #{act}', 'expected #{this} to not have a length above #{exp}', n, len);
            } else {
              this.assert(obj > n, 'expected #{this} to be above ' + n, 'expected #{this} to be at most ' + n);
            }
          }
    
          Assertion.addMethod('above', assertAbove);
          Assertion.addMethod('gt', assertAbove);
          Assertion.addMethod('greaterThan', assertAbove);
    
          /**
           * ### .least(value)
           *
           * Asserts that the target is greater than or equal to `value`.
           *
           *     expect(10).to.be.at.least(10);
           *
           * Can also be used in conjunction with `length` to
           * assert a minimum length. The benefit being a
           * more informative error message than if the length
           * was supplied directly.
           *
           *     expect('foo').to.have.length.of.at.least(2);
           *     expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
           *
           * @name least
           * @alias gte
           * @param {Number} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertLeast(n, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            if (flag(this, 'doLength')) {
              new Assertion(obj, msg).to.have.property('length');
              var len = obj.length;
              this.assert(len >= n, 'expected #{this} to have a length at least #{exp} but got #{act}', 'expected #{this} to have a length below #{exp}', n, len);
            } else {
              this.assert(obj >= n, 'expected #{this} to be at least ' + n, 'expected #{this} to be below ' + n);
            }
          }
    
          Assertion.addMethod('least', assertLeast);
          Assertion.addMethod('gte', assertLeast);
    
          /**
           * ### .below(value)
           *
           * Asserts that the target is less than `value`.
           *
           *     expect(5).to.be.below(10);
           *
           * Can also be used in conjunction with `length` to
           * assert a maximum length. The benefit being a
           * more informative error message than if the length
           * was supplied directly.
           *
           *     expect('foo').to.have.length.below(4);
           *     expect([ 1, 2, 3 ]).to.have.length.below(4);
           *
           * @name below
           * @alias lt
           * @alias lessThan
           * @param {Number} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertBelow(n, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            if (flag(this, 'doLength')) {
              new Assertion(obj, msg).to.have.property('length');
              var len = obj.length;
              this.assert(len < n, 'expected #{this} to have a length below #{exp} but got #{act}', 'expected #{this} to not have a length below #{exp}', n, len);
            } else {
              this.assert(obj < n, 'expected #{this} to be below ' + n, 'expected #{this} to be at least ' + n);
            }
          }
    
          Assertion.addMethod('below', assertBelow);
          Assertion.addMethod('lt', assertBelow);
          Assertion.addMethod('lessThan', assertBelow);
    
          /**
           * ### .most(value)
           *
           * Asserts that the target is less than or equal to `value`.
           *
           *     expect(5).to.be.at.most(5);
           *
           * Can also be used in conjunction with `length` to
           * assert a maximum length. The benefit being a
           * more informative error message than if the length
           * was supplied directly.
           *
           *     expect('foo').to.have.length.of.at.most(4);
           *     expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
           *
           * @name most
           * @alias lte
           * @param {Number} value
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertMost(n, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            if (flag(this, 'doLength')) {
              new Assertion(obj, msg).to.have.property('length');
              var len = obj.length;
              this.assert(len <= n, 'expected #{this} to have a length at most #{exp} but got #{act}', 'expected #{this} to have a length above #{exp}', n, len);
            } else {
              this.assert(obj <= n, 'expected #{this} to be at most ' + n, 'expected #{this} to be above ' + n);
            }
          }
    
          Assertion.addMethod('most', assertMost);
          Assertion.addMethod('lte', assertMost);
    
          /**
           * ### .within(start, finish)
           *
           * Asserts that the target is within a range.
           *
           *     expect(7).to.be.within(5,10);
           *
           * Can also be used in conjunction with `length` to
           * assert a length range. The benefit being a
           * more informative error message than if the length
           * was supplied directly.
           *
           *     expect('foo').to.have.length.within(2,4);
           *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
           *
           * @name within
           * @param {Number} start lowerbound inclusive
           * @param {Number} finish upperbound inclusive
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          Assertion.addMethod('within', function (start, finish, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object'),
                range = start + '..' + finish;
            if (flag(this, 'doLength')) {
              new Assertion(obj, msg).to.have.property('length');
              var len = obj.length;
              this.assert(len >= start && len <= finish, 'expected #{this} to have a length within ' + range, 'expected #{this} to not have a length within ' + range);
            } else {
              this.assert(obj >= start && obj <= finish, 'expected #{this} to be within ' + range, 'expected #{this} to not be within ' + range);
            }
          });
    
          /**
           * ### .instanceof(constructor)
           *
           * Asserts that the target is an instance of `constructor`.
           *
           *     var Tea = function (name) { this.name = name; }
           *       , Chai = new Tea('chai');
           *
           *     expect(Chai).to.be.an.instanceof(Tea);
           *     expect([ 1, 2, 3 ]).to.be.instanceof(Array);
           *
           * @name instanceof
           * @param {Constructor} constructor
           * @param {String} message _optional_
           * @alias instanceOf
           * @namespace BDD
           * @api public
           */
    
          function assertInstanceOf(constructor, msg) {
            if (msg) flag(this, 'message', msg);
            var name = _.getName(constructor);
            this.assert(flag(this, 'object') instanceof constructor, 'expected #{this} to be an instance of ' + name, 'expected #{this} to not be an instance of ' + name);
          };
    
          Assertion.addMethod('instanceof', assertInstanceOf);
          Assertion.addMethod('instanceOf', assertInstanceOf);
    
          /**
           * ### .property(name, [value])
           *
           * Asserts that the target has a property `name`, optionally asserting that
           * the value of that property is strictly equal to  `value`.
           * If the `deep` flag is set, you can use dot- and bracket-notation for deep
           * references into objects and arrays.
           *
           *     // simple referencing
           *     var obj = { foo: 'bar' };
           *     expect(obj).to.have.property('foo');
           *     expect(obj).to.have.property('foo', 'bar');
           *
           *     // deep referencing
           *     var deepObj = {
           *         green: { tea: 'matcha' }
           *       , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]
           *     };
           *
           *     expect(deepObj).to.have.deep.property('green.tea', 'matcha');
           *     expect(deepObj).to.have.deep.property('teas[1]', 'matcha');
           *     expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');
           *
           * You can also use an array as the starting point of a `deep.property`
           * assertion, or traverse nested arrays.
           *
           *     var arr = [
           *         [ 'chai', 'matcha', 'konacha' ]
           *       , [ { tea: 'chai' }
           *         , { tea: 'matcha' }
           *         , { tea: 'konacha' } ]
           *     ];
           *
           *     expect(arr).to.have.deep.property('[0][1]', 'matcha');
           *     expect(arr).to.have.deep.property('[1][2].tea', 'konacha');
           *
           * Furthermore, `property` changes the subject of the assertion
           * to be the value of that property from the original object. This
           * permits for further chainable assertions on that property.
           *
           *     expect(obj).to.have.property('foo')
           *       .that.is.a('string');
           *     expect(deepObj).to.have.property('green')
           *       .that.is.an('object')
           *       .that.deep.equals({ tea: 'matcha' });
           *     expect(deepObj).to.have.property('teas')
           *       .that.is.an('array')
           *       .with.deep.property('[2]')
           *         .that.deep.equals({ tea: 'konacha' });
           *
           * Note that dots and bracket in `name` must be backslash-escaped when
           * the `deep` flag is set, while they must NOT be escaped when the `deep`
           * flag is not set.
           *
           *     // simple referencing
           *     var css = { '.link[target]': 42 };
           *     expect(css).to.have.property('.link[target]', 42);
           *
           *     // deep referencing
           *     var deepCss = { '.link': { '[target]': 42 }};
           *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
           *
           * @name property
           * @alias deep.property
           * @param {String} name
           * @param {Mixed} value (optional)
           * @param {String} message _optional_
           * @returns value of property for chaining
           * @namespace BDD
           * @api public
           */
    
          Assertion.addMethod('property', function (name, val, msg) {
            if (msg) flag(this, 'message', msg);
    
            var isDeep = !!flag(this, 'deep'),
                descriptor = isDeep ? 'deep property ' : 'property ',
                negate = flag(this, 'negate'),
                obj = flag(this, 'object'),
                pathInfo = isDeep ? _.getPathInfo(name, obj) : null,
                hasProperty = isDeep ? pathInfo.exists : _.hasProperty(name, obj),
                value = isDeep ? pathInfo.value : obj[name];
    
            if (negate && arguments.length > 1) {
              if (undefined === value) {
                msg = msg != null ? msg + ': ' : '';
                throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));
              }
            } else {
              this.assert(hasProperty, 'expected #{this} to have a ' + descriptor + _.inspect(name), 'expected #{this} to not have ' + descriptor + _.inspect(name));
            }
    
            if (arguments.length > 1) {
              this.assert(val === value, 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}', 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}', val, value);
            }
    
            flag(this, 'object', value);
          });
    
          /**
           * ### .ownProperty(name)
           *
           * Asserts that the target has an own property `name`.
           *
           *     expect('test').to.have.ownProperty('length');
           *
           * @name ownProperty
           * @alias haveOwnProperty
           * @param {String} name
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertOwnProperty(name, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            this.assert(obj.hasOwnProperty(name), 'expected #{this} to have own property ' + _.inspect(name), 'expected #{this} to not have own property ' + _.inspect(name));
          }
    
          Assertion.addMethod('ownProperty', assertOwnProperty);
          Assertion.addMethod('haveOwnProperty', assertOwnProperty);
    
          /**
           * ### .ownPropertyDescriptor(name[, descriptor[, message]])
           *
           * Asserts that the target has an own property descriptor `name`, that optionally matches `descriptor`.
           *
           *     expect('test').to.have.ownPropertyDescriptor('length');
           *     expect('test').to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 4 });
           *     expect('test').not.to.have.ownPropertyDescriptor('length', { enumerable: false, configurable: false, writable: false, value: 3 });
           *     expect('test').ownPropertyDescriptor('length').to.have.property('enumerable', false);
           *     expect('test').ownPropertyDescriptor('length').to.have.keys('value');
           *
           * @name ownPropertyDescriptor
           * @alias haveOwnPropertyDescriptor
           * @param {String} name
           * @param {Object} descriptor _optional_
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertOwnPropertyDescriptor(name, descriptor, msg) {
            if (typeof descriptor === 'string') {
              msg = descriptor;
              descriptor = null;
            }
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            var actualDescriptor = Object.getOwnPropertyDescriptor(Object(obj), name);
            if (actualDescriptor && descriptor) {
              this.assert(_.eql(descriptor, actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to match ' + _.inspect(descriptor) + ', got ' + _.inspect(actualDescriptor), 'expected the own property descriptor for ' + _.inspect(name) + ' on #{this} to not match ' + _.inspect(descriptor), descriptor, actualDescriptor, true);
            } else {
              this.assert(actualDescriptor, 'expected #{this} to have an own property descriptor for ' + _.inspect(name), 'expected #{this} to not have an own property descriptor for ' + _.inspect(name));
            }
            flag(this, 'object', actualDescriptor);
          }
    
          Assertion.addMethod('ownPropertyDescriptor', assertOwnPropertyDescriptor);
          Assertion.addMethod('haveOwnPropertyDescriptor', assertOwnPropertyDescriptor);
    
          /**
           * ### .length
           *
           * Sets the `doLength` flag later used as a chain precursor to a value
           * comparison for the `length` property.
           *
           *     expect('foo').to.have.length.above(2);
           *     expect([ 1, 2, 3 ]).to.have.length.above(2);
           *     expect('foo').to.have.length.below(4);
           *     expect([ 1, 2, 3 ]).to.have.length.below(4);
           *     expect('foo').to.have.length.within(2,4);
           *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
           *
           * *Deprecation notice:* Using `length` as an assertion will be deprecated
           * in version 2.4.0 and removed in 3.0.0. Code using the old style of
           * asserting for `length` property value using `length(value)` should be
           * switched to use `lengthOf(value)` instead.
           *
           * @name length
           * @namespace BDD
           * @api public
           */
    
          /**
           * ### .lengthOf(value[, message])
           *
           * Asserts that the target's `length` property has
           * the expected value.
           *
           *     expect([ 1, 2, 3]).to.have.lengthOf(3);
           *     expect('foobar').to.have.lengthOf(6);
           *
           * @name lengthOf
           * @param {Number} length
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertLengthChain() {
            flag(this, 'doLength', true);
          }
    
          function assertLength(n, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            new Assertion(obj, msg).to.have.property('length');
            var len = obj.length;
    
            this.assert(len == n, 'expected #{this} to have a length of #{exp} but got #{act}', 'expected #{this} to not have a length of #{act}', n, len);
          }
    
          Assertion.addChainableMethod('length', assertLength, assertLengthChain);
          Assertion.addMethod('lengthOf', assertLength);
    
          /**
           * ### .match(regexp)
           *
           * Asserts that the target matches a regular expression.
           *
           *     expect('foobar').to.match(/^foo/);
           *
           * @name match
           * @alias matches
           * @param {RegExp} RegularExpression
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
          function assertMatch(re, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            this.assert(re.exec(obj), 'expected #{this} to match ' + re, 'expected #{this} not to match ' + re);
          }
    
          Assertion.addMethod('match', assertMatch);
          Assertion.addMethod('matches', assertMatch);
    
          /**
           * ### .string(string)
           *
           * Asserts that the string target contains another string.
           *
           *     expect('foobar').to.have.string('bar');
           *
           * @name string
           * @param {String} string
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          Assertion.addMethod('string', function (str, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            new Assertion(obj, msg).is.a('string');
    
            this.assert(~obj.indexOf(str), 'expected #{this} to contain ' + _.inspect(str), 'expected #{this} to not contain ' + _.inspect(str));
          });
    
          /**
           * ### .keys(key1, [key2], [...])
           *
           * Asserts that the target contains any or all of the passed-in keys.
           * Use in combination with `any`, `all`, `contains`, or `have` will affect
           * what will pass.
           *
           * When used in conjunction with `any`, at least one key that is passed
           * in must exist in the target object. This is regardless whether or not
           * the `have` or `contain` qualifiers are used. Note, either `any` or `all`
           * should be used in the assertion. If neither are used, the assertion is
           * defaulted to `all`.
           *
           * When both `all` and `contain` are used, the target object must have at
           * least all of the passed-in keys but may have more keys not listed.
           *
           * When both `all` and `have` are used, the target object must both contain
           * all of the passed-in keys AND the number of keys in the target object must
           * match the number of keys passed in (in other words, a target object must
           * have all and only all of the passed-in keys).
           *
           *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz');
           *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo');
           *     expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz');
           *     expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']);
           *     expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6});
           *     expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']);
           *     expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo': 7});
           *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']);
           *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys({'bar': 6});
           *
           *
           * @name keys
           * @alias key
           * @param {...String|Array|Object} keys
           * @namespace BDD
           * @api public
           */
    
          function assertKeys(keys) {
            var obj = flag(this, 'object'),
                str,
                ok = true,
                mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments';
    
            switch (_.type(keys)) {
              case "array":
                if (arguments.length > 1) throw new Error(mixedArgsMsg);
                break;
              case "object":
                if (arguments.length > 1) throw new Error(mixedArgsMsg);
                keys = Object.keys(keys);
                break;
              default:
                keys = Array.prototype.slice.call(arguments);
            }
    
            if (!keys.length) throw new Error('keys required');
    
            var actual = Object.keys(obj),
                expected = keys,
                len = keys.length,
                any = flag(this, 'any'),
                all = flag(this, 'all');
    
            if (!any && !all) {
              all = true;
            }
    
            // Has any
            if (any) {
              var intersection = expected.filter(function (key) {
                return ~actual.indexOf(key);
              });
              ok = intersection.length > 0;
            }
    
            // Has all
            if (all) {
              ok = keys.every(function (key) {
                return ~actual.indexOf(key);
              });
              if (!flag(this, 'negate') && !flag(this, 'contains')) {
                ok = ok && keys.length == actual.length;
              }
            }
    
            // Key string
            if (len > 1) {
              keys = keys.map(function (key) {
                return _.inspect(key);
              });
              var last = keys.pop();
              if (all) {
                str = keys.join(', ') + ', and ' + last;
              }
              if (any) {
                str = keys.join(', ') + ', or ' + last;
              }
            } else {
              str = _.inspect(keys[0]);
            }
    
            // Form
            str = (len > 1 ? 'keys ' : 'key ') + str;
    
            // Have / include
            str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;
    
            // Assertion
            this.assert(ok, 'expected #{this} to ' + str, 'expected #{this} to not ' + str, expected.slice(0).sort(), actual.sort(), true);
          }
    
          Assertion.addMethod('keys', assertKeys);
          Assertion.addMethod('key', assertKeys);
    
          /**
           * ### .throw(constructor)
           *
           * Asserts that the function target will throw a specific error, or specific type of error
           * (as determined using `instanceof`), optionally with a RegExp or string inclusion test
           * for the error's message.
           *
           *     var err = new ReferenceError('This is a bad function.');
           *     var fn = function () { throw err; }
           *     expect(fn).to.throw(ReferenceError);
           *     expect(fn).to.throw(Error);
           *     expect(fn).to.throw(/bad function/);
           *     expect(fn).to.not.throw('good function');
           *     expect(fn).to.throw(ReferenceError, /bad function/);
           *     expect(fn).to.throw(err);
           *
           * Please note that when a throw expectation is negated, it will check each
           * parameter independently, starting with error constructor type. The appropriate way
           * to check for the existence of a type of error but for a message that does not match
           * is to use `and`.
           *
           *     expect(fn).to.throw(ReferenceError)
           *        .and.not.throw(/good function/);
           *
           * @name throw
           * @alias throws
           * @alias Throw
           * @param {ErrorConstructor} constructor
           * @param {String|RegExp} expected error message
           * @param {String} message _optional_
           * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
           * @returns error for chaining (null if no error)
           * @namespace BDD
           * @api public
           */
    
          function assertThrows(constructor, errMsg, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            new Assertion(obj, msg).is.a('function');
    
            var thrown = false,
                desiredError = null,
                name = null,
                thrownError = null;
    
            if (arguments.length === 0) {
              errMsg = null;
              constructor = null;
            } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {
              errMsg = constructor;
              constructor = null;
            } else if (constructor && constructor instanceof Error) {
              desiredError = constructor;
              constructor = null;
              errMsg = null;
            } else if (typeof constructor === 'function') {
              name = constructor.prototype.name;
              if (!name || name === 'Error' && constructor !== Error) {
                name = constructor.name || new constructor().name;
              }
            } else {
              constructor = null;
            }
    
            try {
              obj();
            } catch (err) {
              // first, check desired error
              if (desiredError) {
                this.assert(err === desiredError, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp}', desiredError instanceof Error ? desiredError.toString() : desiredError, err instanceof Error ? err.toString() : err);
    
                flag(this, 'object', err);
                return this;
              }
    
              // next, check constructor
              if (constructor) {
                this.assert(err instanceof constructor, 'expected #{this} to throw #{exp} but #{act} was thrown', 'expected #{this} to not throw #{exp} but #{act} was thrown', name, err instanceof Error ? err.toString() : err);
    
                if (!errMsg) {
                  flag(this, 'object', err);
                  return this;
                }
              }
    
              // next, check message
              var message = 'error' === _.type(err) && "message" in err ? err.message : '' + err;
    
              if (message != null && errMsg && errMsg instanceof RegExp) {
                this.assert(errMsg.exec(message), 'expected #{this} to throw error matching #{exp} but got #{act}', 'expected #{this} to throw error not matching #{exp}', errMsg, message);
    
                flag(this, 'object', err);
                return this;
              } else if (message != null && errMsg && 'string' === typeof errMsg) {
                this.assert(~message.indexOf(errMsg), 'expected #{this} to throw error including #{exp} but got #{act}', 'expected #{this} to throw error not including #{act}', errMsg, message);
    
                flag(this, 'object', err);
                return this;
              } else {
                thrown = true;
                thrownError = err;
              }
            }
    
            var actuallyGot = '',
                expectedThrown = name !== null ? name : desiredError ? '#{exp}' //_.inspect(desiredError)
            : 'an error';
    
            if (thrown) {
              actuallyGot = ' but #{act} was thrown';
            }
    
            this.assert(thrown === true, 'expected #{this} to throw ' + expectedThrown + actuallyGot, 'expected #{this} to not throw ' + expectedThrown + actuallyGot, desiredError instanceof Error ? desiredError.toString() : desiredError, thrownError instanceof Error ? thrownError.toString() : thrownError);
    
            flag(this, 'object', thrownError);
          };
    
          Assertion.addMethod('throw', assertThrows);
          Assertion.addMethod('throws', assertThrows);
          Assertion.addMethod('Throw', assertThrows);
    
          /**
           * ### .respondTo(method)
           *
           * Asserts that the object or class target will respond to a method.
           *
           *     Klass.prototype.bar = function(){};
           *     expect(Klass).to.respondTo('bar');
           *     expect(obj).to.respondTo('bar');
           *
           * To check if a constructor will respond to a static function,
           * set the `itself` flag.
           *
           *     Klass.baz = function(){};
           *     expect(Klass).itself.to.respondTo('baz');
           *
           * @name respondTo
           * @alias respondsTo
           * @param {String} method
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function respondTo(method, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object'),
                itself = flag(this, 'itself'),
                context = 'function' === _.type(obj) && !itself ? obj.prototype[method] : obj[method];
    
            this.assert('function' === typeof context, 'expected #{this} to respond to ' + _.inspect(method), 'expected #{this} to not respond to ' + _.inspect(method));
          }
    
          Assertion.addMethod('respondTo', respondTo);
          Assertion.addMethod('respondsTo', respondTo);
    
          /**
           * ### .itself
           *
           * Sets the `itself` flag, later used by the `respondTo` assertion.
           *
           *     function Foo() {}
           *     Foo.bar = function() {}
           *     Foo.prototype.baz = function() {}
           *
           *     expect(Foo).itself.to.respondTo('bar');
           *     expect(Foo).itself.not.to.respondTo('baz');
           *
           * @name itself
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('itself', function () {
            flag(this, 'itself', true);
          });
    
          /**
           * ### .satisfy(method)
           *
           * Asserts that the target passes a given truth test.
           *
           *     expect(1).to.satisfy(function(num) { return num > 0; });
           *
           * @name satisfy
           * @alias satisfies
           * @param {Function} matcher
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function satisfy(matcher, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
            var result = matcher(obj);
            this.assert(result, 'expected #{this} to satisfy ' + _.objDisplay(matcher), 'expected #{this} to not satisfy' + _.objDisplay(matcher), this.negate ? false : true, result);
          }
    
          Assertion.addMethod('satisfy', satisfy);
          Assertion.addMethod('satisfies', satisfy);
    
          /**
           * ### .closeTo(expected, delta)
           *
           * Asserts that the target is equal `expected`, to within a +/- `delta` range.
           *
           *     expect(1.5).to.be.closeTo(1, 0.5);
           *
           * @name closeTo
           * @alias approximately
           * @param {Number} expected
           * @param {Number} delta
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function closeTo(expected, delta, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
    
            new Assertion(obj, msg).is.a('number');
            if (_.type(expected) !== 'number' || _.type(delta) !== 'number') {
              throw new Error('the arguments to closeTo or approximately must be numbers');
            }
    
            this.assert(Math.abs(obj - expected) <= delta, 'expected #{this} to be close to ' + expected + ' +/- ' + delta, 'expected #{this} not to be close to ' + expected + ' +/- ' + delta);
          }
    
          Assertion.addMethod('closeTo', closeTo);
          Assertion.addMethod('approximately', closeTo);
    
          function isSubsetOf(subset, superset, cmp) {
            return subset.every(function (elem) {
              if (!cmp) return superset.indexOf(elem) !== -1;
    
              return superset.some(function (elem2) {
                return cmp(elem, elem2);
              });
            });
          }
    
          /**
           * ### .members(set)
           *
           * Asserts that the target is a superset of `set`,
           * or that the target and `set` have the same strictly-equal (===) members.
           * Alternately, if the `deep` flag is set, set members are compared for deep
           * equality.
           *
           *     expect([1, 2, 3]).to.include.members([3, 2]);
           *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
           *
           *     expect([4, 2]).to.have.members([2, 4]);
           *     expect([5, 2]).to.not.have.members([5, 2, 1]);
           *
           *     expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]);
           *
           * @name members
           * @param {Array} set
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          Assertion.addMethod('members', function (subset, msg) {
            if (msg) flag(this, 'message', msg);
            var obj = flag(this, 'object');
    
            new Assertion(obj).to.be.an('array');
            new Assertion(subset).to.be.an('array');
    
            var cmp = flag(this, 'deep') ? _.eql : undefined;
    
            if (flag(this, 'contains')) {
              return this.assert(isSubsetOf(subset, obj, cmp), 'expected #{this} to be a superset of #{act}', 'expected #{this} to not be a superset of #{act}', obj, subset);
            }
    
            this.assert(isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp), 'expected #{this} to have the same members as #{act}', 'expected #{this} to not have the same members as #{act}', obj, subset);
          });
    
          /**
           * ### .oneOf(list)
           *
           * Assert that a value appears somewhere in the top level of array `list`.
           *
           *     expect('a').to.be.oneOf(['a', 'b', 'c']);
           *     expect(9).to.not.be.oneOf(['z']);
           *     expect([3]).to.not.be.oneOf([1, 2, [3]]);
           *
           *     var three = [3];
           *     // for object-types, contents are not compared
           *     expect(three).to.not.be.oneOf([1, 2, [3]]);
           *     // comparing references works
           *     expect(three).to.be.oneOf([1, 2, three]);
           *
           * @name oneOf
           * @param {Array<*>} list
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function oneOf(list, msg) {
            if (msg) flag(this, 'message', msg);
            var expected = flag(this, 'object');
            new Assertion(list).to.be.an('array');
    
            this.assert(list.indexOf(expected) > -1, 'expected #{this} to be one of #{exp}', 'expected #{this} to not be one of #{exp}', list, expected);
          }
    
          Assertion.addMethod('oneOf', oneOf);
    
          /**
           * ### .change(function)
           *
           * Asserts that a function changes an object property
           *
           *     var obj = { val: 10 };
           *     var fn = function() { obj.val += 3 };
           *     var noChangeFn = function() { return 'foo' + 'bar'; }
           *     expect(fn).to.change(obj, 'val');
           *     expect(noChangeFn).to.not.change(obj, 'val')
           *
           * @name change
           * @alias changes
           * @alias Change
           * @param {String} object
           * @param {String} property name
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertChanges(object, prop, msg) {
            if (msg) flag(this, 'message', msg);
            var fn = flag(this, 'object');
            new Assertion(object, msg).to.have.property(prop);
            new Assertion(fn).is.a('function');
    
            var initial = object[prop];
            fn();
    
            this.assert(initial !== object[prop], 'expected .' + prop + ' to change', 'expected .' + prop + ' to not change');
          }
    
          Assertion.addChainableMethod('change', assertChanges);
          Assertion.addChainableMethod('changes', assertChanges);
    
          /**
           * ### .increase(function)
           *
           * Asserts that a function increases an object property
           *
           *     var obj = { val: 10 };
           *     var fn = function() { obj.val = 15 };
           *     expect(fn).to.increase(obj, 'val');
           *
           * @name increase
           * @alias increases
           * @alias Increase
           * @param {String} object
           * @param {String} property name
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertIncreases(object, prop, msg) {
            if (msg) flag(this, 'message', msg);
            var fn = flag(this, 'object');
            new Assertion(object, msg).to.have.property(prop);
            new Assertion(fn).is.a('function');
    
            var initial = object[prop];
            fn();
    
            this.assert(object[prop] - initial > 0, 'expected .' + prop + ' to increase', 'expected .' + prop + ' to not increase');
          }
    
          Assertion.addChainableMethod('increase', assertIncreases);
          Assertion.addChainableMethod('increases', assertIncreases);
    
          /**
           * ### .decrease(function)
           *
           * Asserts that a function decreases an object property
           *
           *     var obj = { val: 10 };
           *     var fn = function() { obj.val = 5 };
           *     expect(fn).to.decrease(obj, 'val');
           *
           * @name decrease
           * @alias decreases
           * @alias Decrease
           * @param {String} object
           * @param {String} property name
           * @param {String} message _optional_
           * @namespace BDD
           * @api public
           */
    
          function assertDecreases(object, prop, msg) {
            if (msg) flag(this, 'message', msg);
            var fn = flag(this, 'object');
            new Assertion(object, msg).to.have.property(prop);
            new Assertion(fn).is.a('function');
    
            var initial = object[prop];
            fn();
    
            this.assert(object[prop] - initial < 0, 'expected .' + prop + ' to decrease', 'expected .' + prop + ' to not decrease');
          }
    
          Assertion.addChainableMethod('decrease', assertDecreases);
          Assertion.addChainableMethod('decreases', assertDecreases);
    
          /**
           * ### .extensible
           *
           * Asserts that the target is extensible (can have new properties added to
           * it).
           *
           *     var nonExtensibleObject = Object.preventExtensions({});
           *     var sealedObject = Object.seal({});
           *     var frozenObject = Object.freeze({});
           *
           *     expect({}).to.be.extensible;
           *     expect(nonExtensibleObject).to.not.be.extensible;
           *     expect(sealedObject).to.not.be.extensible;
           *     expect(frozenObject).to.not.be.extensible;
           *
           * @name extensible
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('extensible', function () {
            var obj = flag(this, 'object');
    
            // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
            // In ES6, a non-object argument will be treated as if it was a non-extensible ordinary object, simply return false.
            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible
            // The following provides ES6 behavior when a TypeError is thrown under ES5.
    
            var isExtensible;
    
            try {
              isExtensible = Object.isExtensible(obj);
            } catch (err) {
              if (err instanceof TypeError) isExtensible = false;else throw err;
            }
    
            this.assert(isExtensible, 'expected #{this} to be extensible', 'expected #{this} to not be extensible');
          });
    
          /**
           * ### .sealed
           *
           * Asserts that the target is sealed (cannot have new properties added to it
           * and its existing properties cannot be removed).
           *
           *     var sealedObject = Object.seal({});
           *     var frozenObject = Object.freeze({});
           *
           *     expect(sealedObject).to.be.sealed;
           *     expect(frozenObject).to.be.sealed;
           *     expect({}).to.not.be.sealed;
           *
           * @name sealed
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('sealed', function () {
            var obj = flag(this, 'object');
    
            // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
            // In ES6, a non-object argument will be treated as if it was a sealed ordinary object, simply return true.
            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isSealed
            // The following provides ES6 behavior when a TypeError is thrown under ES5.
    
            var isSealed;
    
            try {
              isSealed = Object.isSealed(obj);
            } catch (err) {
              if (err instanceof TypeError) isSealed = true;else throw err;
            }
    
            this.assert(isSealed, 'expected #{this} to be sealed', 'expected #{this} to not be sealed');
          });
    
          /**
           * ### .frozen
           *
           * Asserts that the target is frozen (cannot have new properties added to it
           * and its existing properties cannot be modified).
           *
           *     var frozenObject = Object.freeze({});
           *
           *     expect(frozenObject).to.be.frozen;
           *     expect({}).to.not.be.frozen;
           *
           * @name frozen
           * @namespace BDD
           * @api public
           */
    
          Assertion.addProperty('frozen', function () {
            var obj = flag(this, 'object');
    
            // In ES5, if the argument to this method is not an object (a primitive), then it will cause a TypeError.
            // In ES6, a non-object argument will be treated as if it was a frozen ordinary object, simply return true.
            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/isFrozen
            // The following provides ES6 behavior when a TypeError is thrown under ES5.
    
            var isFrozen;
    
            try {
              isFrozen = Object.isFrozen(obj);
            } catch (err) {
              if (err instanceof TypeError) isFrozen = true;else throw err;
            }
    
            this.assert(isFrozen, 'expected #{this} to be frozen', 'expected #{this} to not be frozen');
          });
        };
      });
    
      var require$$3 = assertions && (typeof assertions === 'undefined' ? 'undefined' : babelHelpers.typeof(assertions)) === 'object' && 'default' in assertions ? assertions['default'] : assertions;
    
      var config$1 = __commonjs(function (module) {
        module.exports = {
    
          /**
           * ### config.includeStack
           *
           * User configurable property, influences whether stack trace
           * is included in Assertion error message. Default of false
           * suppresses stack trace in the error message.
           *
           *     chai.config.includeStack = true;  // enable stack on error
           *
           * @param {Boolean}
           * @api public
           */
    
          includeStack: false,
    
          /**
           * ### config.showDiff
           *
           * User configurable property, influences whether or not
           * the `showDiff` flag should be included in the thrown
           * AssertionErrors. `false` will always be `false`; `true`
           * will be true when the assertion has requested a diff
           * be shown.
           *
           * @param {Boolean}
           * @api public
           */
    
          showDiff: true,
    
          /**
           * ### config.truncateThreshold
           *
           * User configurable property, sets length threshold for actual and
           * expected values in assertion errors. If this threshold is exceeded, for
           * example for large data structures, the value is replaced with something
           * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.
           *
           * Set it to zero if you want to disable truncating altogether.
           *
           * This is especially userful when doing assertions on arrays: having this
           * set to a reasonable large value makes the failure messages readily
           * inspectable.
           *
           *     chai.config.truncateThreshold = 0;  // disable truncating
           *
           * @param {Number}
           * @api public
           */
    
          truncateThreshold: 40
    
        };
      });
    
      var require$$0$3 = config$1 && (typeof config$1 === 'undefined' ? 'undefined' : babelHelpers.typeof(config$1)) === 'object' && 'default' in config$1 ? config$1['default'] : config$1;
    
      var assertion = __commonjs(function (module) {
        /*!
         * chai
         * http://chaijs.com
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var config = require$$0$3;
    
        module.exports = function (_chai, util) {
          /*!
           * Module dependencies.
           */
    
          var AssertionError = _chai.AssertionError,
              flag = util.flag;
    
          /*!
           * Module export.
           */
    
          _chai.Assertion = Assertion;
    
          /*!
           * Assertion Constructor
           *
           * Creates object for chaining.
           *
           * @api private
           */
    
          function Assertion(obj, msg, stack) {
            flag(this, 'ssfi', stack || arguments.callee);
            flag(this, 'object', obj);
            flag(this, 'message', msg);
          }
    
          Object.defineProperty(Assertion, 'includeStack', {
            get: function get() {
              console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
              return config.includeStack;
            },
            set: function set(value) {
              console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
              config.includeStack = value;
            }
          });
    
          Object.defineProperty(Assertion, 'showDiff', {
            get: function get() {
              console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
              return config.showDiff;
            },
            set: function set(value) {
              console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
              config.showDiff = value;
            }
          });
    
          Assertion.addProperty = function (name, fn) {
            util.addProperty(this.prototype, name, fn);
          };
    
          Assertion.addMethod = function (name, fn) {
            util.addMethod(this.prototype, name, fn);
          };
    
          Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
            util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
          };
    
          Assertion.overwriteProperty = function (name, fn) {
            util.overwriteProperty(this.prototype, name, fn);
          };
    
          Assertion.overwriteMethod = function (name, fn) {
            util.overwriteMethod(this.prototype, name, fn);
          };
    
          Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
            util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
          };
    
          /**
           * ### .assert(expression, message, negateMessage, expected, actual, showDiff)
           *
           * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
           *
           * @name assert
           * @param {Philosophical} expression to be tested
           * @param {String|Function} message or function that returns message to display if expression fails
           * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
           * @param {Mixed} expected value (remember to check for negation)
           * @param {Mixed} actual (optional) will default to `this.obj`
           * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
           * @api private
           */
    
          Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
            var ok = util.test(this, arguments);
            if (true !== showDiff) showDiff = false;
            if (true !== config.showDiff) showDiff = false;
    
            if (!ok) {
              var msg = util.getMessage(this, arguments),
                  actual = util.getActual(this, arguments);
              throw new AssertionError(msg, {
                actual: actual,
                expected: expected,
                showDiff: showDiff
              }, config.includeStack ? this.assert : flag(this, 'ssfi'));
            }
          };
    
          /*!
           * ### ._obj
           *
           * Quick reference to stored `actual` value for plugin developers.
           *
           * @api private
           */
    
          Object.defineProperty(Assertion.prototype, '_obj', { get: function get() {
              return flag(this, 'object');
            },
            set: function set(val) {
              flag(this, 'object', val);
            }
          });
        };
      });
    
      var require$$4 = assertion && (typeof assertion === 'undefined' ? 'undefined' : babelHelpers.typeof(assertion)) === 'object' && 'default' in assertion ? assertion['default'] : assertion;
    
      var overwriteChainableMethod = __commonjs(function (module) {
        /*!
         * Chai - overwriteChainableMethod utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### overwriteChainableMethod (ctx, name, method, chainingBehavior)
         *
         * Overwites an already existing chainable method
         * and provides access to the previous function or
         * property.  Must return functions to be used for
         * name.
         *
         *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
         *       function (_super) {
         *       }
         *     , function (_super) {
         *       }
         *     );
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);
         *
         * Then can be used as any other assertion.
         *
         *     expect(myFoo).to.have.length(3);
         *     expect(myFoo).to.have.length.above(3);
         *
         * @param {Object} ctx object whose method / property is to be overwritten
         * @param {String} name of method / property to overwrite
         * @param {Function} method function that returns a function to be used for name
         * @param {Function} chainingBehavior function that returns a function to be used for property
         * @namespace Utils
         * @name overwriteChainableMethod
         * @api public
         */
    
        module.exports = function (ctx, name, method, chainingBehavior) {
          var chainableBehavior = ctx.__methods[name];
    
          var _chainingBehavior = chainableBehavior.chainingBehavior;
          chainableBehavior.chainingBehavior = function () {
            var result = chainingBehavior(_chainingBehavior).call(this);
            return result === undefined ? this : result;
          };
    
          var _method = chainableBehavior.method;
          chainableBehavior.method = function () {
            var result = method(_method).apply(this, arguments);
            return result === undefined ? this : result;
          };
        };
      });
    
      var require$$0$4 = overwriteChainableMethod && (typeof overwriteChainableMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteChainableMethod)) === 'object' && 'default' in overwriteChainableMethod ? overwriteChainableMethod['default'] : overwriteChainableMethod;
    
      var flag = __commonjs(function (module) {
        /*!
         * Chai - flag utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### flag(object, key, [value])
         *
         * Get or set a flag value on an object. If a
         * value is provided it will be set, else it will
         * return the currently set value or `undefined` if
         * the value is not set.
         *
         *     utils.flag(this, 'foo', 'bar'); // setter
         *     utils.flag(this, 'foo'); // getter, returns `bar`
         *
         * @param {Object} object constructed Assertion
         * @param {String} key
         * @param {Mixed} value (optional)
         * @namespace Utils
         * @name flag
         * @api private
         */
    
        module.exports = function (obj, key, value) {
          var flags = obj.__flags || (obj.__flags = Object.create(null));
          if (arguments.length === 3) {
            flags[key] = value;
          } else {
            return flags[key];
          }
        };
      });
    
      var require$$0$5 = flag && (typeof flag === 'undefined' ? 'undefined' : babelHelpers.typeof(flag)) === 'object' && 'default' in flag ? flag['default'] : flag;
    
      var transferFlags = __commonjs(function (module) {
        /*!
         * Chai - transferFlags utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### transferFlags(assertion, object, includeAll = true)
         *
         * Transfer all the flags for `assertion` to `object`. If
         * `includeAll` is set to `false`, then the base Chai
         * assertion flags (namely `object`, `ssfi`, and `message`)
         * will not be transferred.
         *
         *
         *     var newAssertion = new Assertion();
         *     utils.transferFlags(assertion, newAssertion);
         *
         *     var anotherAsseriton = new Assertion(myObj);
         *     utils.transferFlags(assertion, anotherAssertion, false);
         *
         * @param {Assertion} assertion the assertion to transfer the flags from
         * @param {Object} object the object to transfer the flags to; usually a new assertion
         * @param {Boolean} includeAll
         * @namespace Utils
         * @name transferFlags
         * @api private
         */
    
        module.exports = function (assertion, object, includeAll) {
          var flags = assertion.__flags || (assertion.__flags = Object.create(null));
    
          if (!object.__flags) {
            object.__flags = Object.create(null);
          }
    
          includeAll = arguments.length === 3 ? includeAll : true;
    
          for (var flag in flags) {
            if (includeAll || flag !== 'object' && flag !== 'ssfi' && flag != 'message') {
              object.__flags[flag] = flags[flag];
            }
          }
        };
      });
    
      var require$$2$1 = transferFlags && (typeof transferFlags === 'undefined' ? 'undefined' : babelHelpers.typeof(transferFlags)) === 'object' && 'default' in transferFlags ? transferFlags['default'] : transferFlags;
    
      var addChainableMethod = __commonjs(function (module) {
        /*!
         * Chai - addChainingMethod utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Module dependencies
         */
    
        var transferFlags = require$$2$1;
        var flag = require$$0$5;
        var config = require$$0$3;
    
        /*!
         * Module variables
         */
    
        // Check whether `__proto__` is supported
        var hasProtoSupport = '__proto__' in Object;
    
        // Without `__proto__` support, this module will need to add properties to a function.
        // However, some Function.prototype methods cannot be overwritten,
        // and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).
        var excludeNames = /^(?:length|name|arguments|caller)$/;
    
        // Cache `Function` properties
        var call = Function.prototype.call,
            apply = Function.prototype.apply;
    
        /**
         * ### addChainableMethod (ctx, name, method, chainingBehavior)
         *
         * Adds a method to an object, such that the method can also be chained.
         *
         *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
         *       var obj = utils.flag(this, 'object');
         *       new chai.Assertion(obj).to.be.equal(str);
         *     });
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);
         *
         * The result can then be used as both a method assertion, executing both `method` and
         * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
         *
         *     expect(fooStr).to.be.foo('bar');
         *     expect(fooStr).to.be.foo.equal('foo');
         *
         * @param {Object} ctx object to which the method is added
         * @param {String} name of method to add
         * @param {Function} method function to be used for `name`, when called
         * @param {Function} chainingBehavior function to be called every time the property is accessed
         * @namespace Utils
         * @name addChainableMethod
         * @api public
         */
    
        module.exports = function (ctx, name, method, chainingBehavior) {
          if (typeof chainingBehavior !== 'function') {
            chainingBehavior = function chainingBehavior() {};
          }
    
          var chainableBehavior = {
            method: method,
            chainingBehavior: chainingBehavior
          };
    
          // save the methods so we can overwrite them later, if we need to.
          if (!ctx.__methods) {
            ctx.__methods = {};
          }
          ctx.__methods[name] = chainableBehavior;
    
          Object.defineProperty(ctx, name, { get: function get() {
              chainableBehavior.chainingBehavior.call(this);
    
              var assert = function assert() {
                var old_ssfi = flag(this, 'ssfi');
                if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', assert);
                var result = chainableBehavior.method.apply(this, arguments);
                return result === undefined ? this : result;
              };
    
              // Use `__proto__` if available
              if (hasProtoSupport) {
                // Inherit all properties from the object by replacing the `Function` prototype
                var prototype = assert.__proto__ = Object.create(this);
                // Restore the `call` and `apply` methods from `Function`
                prototype.call = call;
                prototype.apply = apply;
              }
              // Otherwise, redefine all properties (slow!)
              else {
                  var asserterNames = Object.getOwnPropertyNames(ctx);
                  asserterNames.forEach(function (asserterName) {
                    if (!excludeNames.test(asserterName)) {
                      var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
                      Object.defineProperty(assert, asserterName, pd);
                    }
                  });
                }
    
              transferFlags(this, assert);
              return assert;
            },
            configurable: true
          });
        };
      });
    
      var require$$1$1 = addChainableMethod && (typeof addChainableMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(addChainableMethod)) === 'object' && 'default' in addChainableMethod ? addChainableMethod['default'] : addChainableMethod;
    
      var overwriteMethod = __commonjs(function (module) {
        /*!
         * Chai - overwriteMethod utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### overwriteMethod (ctx, name, fn)
         *
         * Overwites an already existing method and provides
         * access to previous function. Must return function
         * to be used for name.
         *
         *     utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {
         *       return function (str) {
         *         var obj = utils.flag(this, 'object');
         *         if (obj instanceof Foo) {
         *           new chai.Assertion(obj.value).to.equal(str);
         *         } else {
         *           _super.apply(this, arguments);
         *         }
         *       }
         *     });
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.overwriteMethod('foo', fn);
         *
         * Then can be used as any other assertion.
         *
         *     expect(myFoo).to.equal('bar');
         *
         * @param {Object} ctx object whose method is to be overwritten
         * @param {String} name of method to overwrite
         * @param {Function} method function that returns a function to be used for name
         * @namespace Utils
         * @name overwriteMethod
         * @api public
         */
    
        module.exports = function (ctx, name, method) {
          var _method = ctx[name],
              _super = function _super() {
            return this;
          };
    
          if (_method && 'function' === typeof _method) _super = _method;
    
          ctx[name] = function () {
            var result = method(_super).apply(this, arguments);
            return result === undefined ? this : result;
          };
        };
      });
    
      var require$$2$2 = overwriteMethod && (typeof overwriteMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteMethod)) === 'object' && 'default' in overwriteMethod ? overwriteMethod['default'] : overwriteMethod;
    
      var overwriteProperty = __commonjs(function (module) {
        /*!
         * Chai - overwriteProperty utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### overwriteProperty (ctx, name, fn)
         *
         * Overwites an already existing property getter and provides
         * access to previous value. Must return function to use as getter.
         *
         *     utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {
         *       return function () {
         *         var obj = utils.flag(this, 'object');
         *         if (obj instanceof Foo) {
         *           new chai.Assertion(obj.name).to.equal('bar');
         *         } else {
         *           _super.call(this);
         *         }
         *       }
         *     });
         *
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.overwriteProperty('foo', fn);
         *
         * Then can be used as any other assertion.
         *
         *     expect(myFoo).to.be.ok;
         *
         * @param {Object} ctx object whose property is to be overwritten
         * @param {String} name of property to overwrite
         * @param {Function} getter function that returns a getter function to be used for name
         * @namespace Utils
         * @name overwriteProperty
         * @api public
         */
    
        module.exports = function (ctx, name, getter) {
          var _get = Object.getOwnPropertyDescriptor(ctx, name),
              _super = function _super() {};
    
          if (_get && 'function' === typeof _get.get) _super = _get.get;
    
          Object.defineProperty(ctx, name, { get: function get() {
              var result = getter(_super).call(this);
              return result === undefined ? this : result;
            },
            configurable: true
          });
        };
      });
    
      var require$$3$1 = overwriteProperty && (typeof overwriteProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(overwriteProperty)) === 'object' && 'default' in overwriteProperty ? overwriteProperty['default'] : overwriteProperty;
    
      var addMethod = __commonjs(function (module) {
        /*!
         * Chai - addMethod utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var config = require$$0$3;
    
        /**
         * ### .addMethod (ctx, name, method)
         *
         * Adds a method to the prototype of an object.
         *
         *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {
         *       var obj = utils.flag(this, 'object');
         *       new chai.Assertion(obj).to.be.equal(str);
         *     });
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.addMethod('foo', fn);
         *
         * Then can be used as any other assertion.
         *
         *     expect(fooStr).to.be.foo('bar');
         *
         * @param {Object} ctx object to which the method is added
         * @param {String} name of method to add
         * @param {Function} method function to be used for name
         * @namespace Utils
         * @name addMethod
         * @api public
         */
        var flag = require$$0$5;
    
        module.exports = function (ctx, name, method) {
          ctx[name] = function () {
            var old_ssfi = flag(this, 'ssfi');
            if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', ctx[name]);
            var result = method.apply(this, arguments);
            return result === undefined ? this : result;
          };
        };
      });
    
      var require$$4$1 = addMethod && (typeof addMethod === 'undefined' ? 'undefined' : babelHelpers.typeof(addMethod)) === 'object' && 'default' in addMethod ? addMethod['default'] : addMethod;
    
      var addProperty = __commonjs(function (module) {
        /*!
         * Chai - addProperty utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var config = require$$0$3;
        var flag = require$$0$5;
    
        /**
         * ### addProperty (ctx, name, getter)
         *
         * Adds a property to the prototype of an object.
         *
         *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {
         *       var obj = utils.flag(this, 'object');
         *       new chai.Assertion(obj).to.be.instanceof(Foo);
         *     });
         *
         * Can also be accessed directly from `chai.Assertion`.
         *
         *     chai.Assertion.addProperty('foo', fn);
         *
         * Then can be used as any other assertion.
         *
         *     expect(myFoo).to.be.foo;
         *
         * @param {Object} ctx object to which the property is added
         * @param {String} name of property to add
         * @param {Function} getter function to be used for name
         * @namespace Utils
         * @name addProperty
         * @api public
         */
    
        module.exports = function (ctx, name, getter) {
          Object.defineProperty(ctx, name, { get: function addProperty() {
              var old_ssfi = flag(this, 'ssfi');
              if (old_ssfi && config.includeStack === false) flag(this, 'ssfi', addProperty);
    
              var result = getter.call(this);
              return result === undefined ? this : result;
            },
            configurable: true
          });
        };
      });
    
      var require$$5 = addProperty && (typeof addProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(addProperty)) === 'object' && 'default' in addProperty ? addProperty['default'] : addProperty;
    
      var getName = __commonjs(function (module) {
        /*!
         * Chai - getName utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * # getName(func)
         *
         * Gets the name of a function, in a cross-browser way.
         *
         * @param {Function} a function (usually a constructor)
         * @namespace Utils
         * @name getName
         */
    
        module.exports = function (func) {
          if (func.name) return func.name;
    
          var match = /^\s?function ([^(]*)\(/.exec(func);
          return match && match[1] ? match[1] : "";
        };
      });
    
      var require$$2$3 = getName && (typeof getName === 'undefined' ? 'undefined' : babelHelpers.typeof(getName)) === 'object' && 'default' in getName ? getName['default'] : getName;
    
      var type = __commonjs(function (module) {
        /*!
         * type-detect
         * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Primary Exports
         */
    
        var exports = module.exports = getType;
    
        /**
         * ### typeOf (obj)
         *
         * Use several different techniques to determine
         * the type of object being tested.
         *
         *
         * @param {Mixed} object
         * @return {String} object type
         * @api public
         */
        var objectTypeRegexp = /^\[object (.*)\]$/;
    
        function getType(obj) {
          var type = Object.prototype.toString.call(obj).match(objectTypeRegexp)[1].toLowerCase();
          // Let "new String('')" return 'object'
          if (typeof Promise === 'function' && obj instanceof Promise) return 'promise';
          // PhantomJS has type "DOMWindow" for null
          if (obj === null) return 'null';
          // PhantomJS has type "DOMWindow" for undefined
          if (obj === undefined) return 'undefined';
          return type;
        }
    
        exports.Library = Library;
    
        /**
         * ### Library
         *
         * Create a repository for custom type detection.
         *
         * ```js
         * var lib = new type.Library;
         * ```
         *
         */
    
        function Library() {
          if (!(this instanceof Library)) return new Library();
          this.tests = {};
        }
    
        /**
         * #### .of (obj)
         *
         * Expose replacement `typeof` detection to the library.
         *
         * ```js
         * if ('string' === lib.of('hello world')) {
         *   // ...
         * }
         * ```
         *
         * @param {Mixed} object to test
         * @return {String} type
         */
    
        Library.prototype.of = getType;
    
        /**
         * #### .define (type, test)
         *
         * Add a test to for the `.test()` assertion.
         *
         * Can be defined as a regular expression:
         *
         * ```js
         * lib.define('int', /^[0-9]+$/);
         * ```
         *
         * ... or as a function:
         *
         * ```js
         * lib.define('bln', function (obj) {
         *   if ('boolean' === lib.of(obj)) return true;
         *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
         *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
         *   return !! ~blns.indexOf(obj);
         * });
         * ```
         *
         * @param {String} type
         * @param {RegExp|Function} test
         * @api public
         */
    
        Library.prototype.define = function (type, test) {
          if (arguments.length === 1) return this.tests[type];
          this.tests[type] = test;
          return this;
        };
    
        /**
         * #### .test (obj, test)
         *
         * Assert that an object is of type. Will first
         * check natives, and if that does not pass it will
         * use the user defined custom tests.
         *
         * ```js
         * assert(lib.test('1', 'int'));
         * assert(lib.test('yes', 'bln'));
         * ```
         *
         * @param {Mixed} object
         * @param {String} type
         * @return {Boolean} result
         * @api public
         */
    
        Library.prototype.test = function (obj, type) {
          if (type === getType(obj)) return true;
          var test = this.tests[type];
    
          if (test && 'regexp' === getType(test)) {
            return test.test(obj);
          } else if (test && 'function' === getType(test)) {
            return test(obj);
          } else {
            throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
          }
        };
      });
    
      var require$$0$8 = type && (typeof type === 'undefined' ? 'undefined' : babelHelpers.typeof(type)) === 'object' && 'default' in type ? type['default'] : type;
    
      var index$3 = __commonjs(function (module) {
        module.exports = require$$0$8;
      });
    
      var require$$0$7 = index$3 && (typeof index$3 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$3)) === 'object' && 'default' in index$3 ? index$3['default'] : index$3;
    
      var hasProperty = __commonjs(function (module) {
        /*!
         * Chai - hasProperty utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var type = require$$0$7;
    
        /**
         * ### .hasProperty(object, name)
         *
         * This allows checking whether an object has
         * named property or numeric array index.
         *
         * Basically does the same thing as the `in`
         * operator but works properly with natives
         * and null/undefined values.
         *
         *     var obj = {
         *         arr: ['a', 'b', 'c']
         *       , str: 'Hello'
         *     }
         *
         * The following would be the results.
         *
         *     hasProperty('str', obj);  // true
         *     hasProperty('constructor', obj);  // true
         *     hasProperty('bar', obj);  // false
         *
         *     hasProperty('length', obj.str); // true
         *     hasProperty(1, obj.str);  // true
         *     hasProperty(5, obj.str);  // false
         *
         *     hasProperty('length', obj.arr);  // true
         *     hasProperty(2, obj.arr);  // true
         *     hasProperty(3, obj.arr);  // false
         *
         * @param {Objuect} object
         * @param {String|Number} name
         * @returns {Boolean} whether it exists
         * @namespace Utils
         * @name getPathInfo
         * @api public
         */
    
        var literals = {
          'number': Number,
          'string': String
        };
    
        module.exports = function hasProperty(name, obj) {
          var ot = type(obj);
    
          // Bad Object, obviously no props at all
          if (ot === 'null' || ot === 'undefined') return false;
    
          // The `in` operator does not work with certain literals
          // box these before the check
          if (literals[ot] && (typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj)) !== 'object') obj = new literals[ot](obj);
    
          return name in obj;
        };
      });
    
      var require$$0$6 = hasProperty && (typeof hasProperty === 'undefined' ? 'undefined' : babelHelpers.typeof(hasProperty)) === 'object' && 'default' in hasProperty ? hasProperty['default'] : hasProperty;
    
      var getPathInfo = __commonjs(function (module) {
        /*!
         * Chai - getPathInfo utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var hasProperty = require$$0$6;
    
        /**
         * ### .getPathInfo(path, object)
         *
         * This allows the retrieval of property info in an
         * object given a string path.
         *
         * The path info consists of an object with the
         * following properties:
         *
         * * parent - The parent object of the property referenced by `path`
         * * name - The name of the final property, a number if it was an array indexer
         * * value - The value of the property, if it exists, otherwise `undefined`
         * * exists - Whether the property exists or not
         *
         * @param {String} path
         * @param {Object} object
         * @returns {Object} info
         * @namespace Utils
         * @name getPathInfo
         * @api public
         */
    
        module.exports = function getPathInfo(path, obj) {
          var parsed = parsePath(path),
              last = parsed[parsed.length - 1];
    
          var info = {
            parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj,
            name: last.p || last.i,
            value: _getPathValue(parsed, obj)
          };
          info.exists = hasProperty(info.name, info.parent);
    
          return info;
        };
    
        /*!
         * ## parsePath(path)
         *
         * Helper function used to parse string object
         * paths. Use in conjunction with `_getPathValue`.
         *
         *      var parsed = parsePath('myobject.property.subprop');
         *
         * ### Paths:
         *
         * * Can be as near infinitely deep and nested
         * * Arrays are also valid using the formal `myobject.document[3].property`.
         * * Literal dots and brackets (not delimiter) must be backslash-escaped.
         *
         * @param {String} path
         * @returns {Object} parsed
         * @api private
         */
    
        function parsePath(path) {
          var str = path.replace(/([^\\])\[/g, '$1.['),
              parts = str.match(/(\\\.|[^.]+?)+/g);
          return parts.map(function (value) {
            var re = /^\[(\d+)\]$/,
                mArr = re.exec(value);
            if (mArr) return { i: parseFloat(mArr[1]) };else return { p: value.replace(/\\([.\[\]])/g, '$1') };
          });
        }
    
        /*!
         * ## _getPathValue(parsed, obj)
         *
         * Helper companion function for `.parsePath` that returns
         * the value located at the parsed address.
         *
         *      var value = getPathValue(parsed, obj);
         *
         * @param {Object} parsed definition from `parsePath`.
         * @param {Object} object to search against
         * @param {Number} object to search against
         * @returns {Object|Undefined} value
         * @api private
         */
    
        function _getPathValue(parsed, obj, index) {
          var tmp = obj,
              res;
    
          index = index === undefined ? parsed.length : index;
    
          for (var i = 0, l = index; i < l; i++) {
            var part = parsed[i];
            if (tmp) {
              if ('undefined' !== typeof part.p) tmp = tmp[part.p];else if ('undefined' !== typeof part.i) tmp = tmp[part.i];
              if (i == l - 1) res = tmp;
            } else {
              res = undefined;
            }
          }
          return res;
        }
      });
    
      var require$$0$9 = getPathInfo && (typeof getPathInfo === 'undefined' ? 'undefined' : babelHelpers.typeof(getPathInfo)) === 'object' && 'default' in getPathInfo ? getPathInfo['default'] : getPathInfo;
    
      var getPathValue = __commonjs(function (module) {
        /*!
         * Chai - getPathValue utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * @see https://github.com/logicalparadox/filtr
         * MIT Licensed
         */
    
        var getPathInfo = require$$0$9;
    
        /**
         * ### .getPathValue(path, object)
         *
         * This allows the retrieval of values in an
         * object given a string path.
         *
         *     var obj = {
         *         prop1: {
         *             arr: ['a', 'b', 'c']
         *           , str: 'Hello'
         *         }
         *       , prop2: {
         *             arr: [ { nested: 'Universe' } ]
         *           , str: 'Hello again!'
         *         }
         *     }
         *
         * The following would be the results.
         *
         *     getPathValue('prop1.str', obj); // Hello
         *     getPathValue('prop1.att[2]', obj); // b
         *     getPathValue('prop2.arr[0].nested', obj); // Universe
         *
         * @param {String} path
         * @param {Object} object
         * @returns {Object} value or `undefined`
         * @namespace Utils
         * @name getPathValue
         * @api public
         */
        module.exports = function (path, obj) {
          var info = getPathInfo(path, obj);
          return info.value;
        };
      });
    
      var require$$9 = getPathValue && (typeof getPathValue === 'undefined' ? 'undefined' : babelHelpers.typeof(getPathValue)) === 'object' && 'default' in getPathValue ? getPathValue['default'] : getPathValue;
    
      var type$1 = __commonjs(function (module) {
        /*!
         * type-detect
         * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Primary Exports
         */
    
        var exports = module.exports = getType;
    
        /*!
         * Detectable javascript natives
         */
    
        var natives = {
          '[object Array]': 'array',
          '[object RegExp]': 'regexp',
          '[object Function]': 'function',
          '[object Arguments]': 'arguments',
          '[object Date]': 'date'
        };
    
        /**
         * ### typeOf (obj)
         *
         * Use several different techniques to determine
         * the type of object being tested.
         *
         *
         * @param {Mixed} object
         * @return {String} object type
         * @api public
         */
    
        function getType(obj) {
          var str = Object.prototype.toString.call(obj);
          if (natives[str]) return natives[str];
          if (obj === null) return 'null';
          if (obj === undefined) return 'undefined';
          if (obj === Object(obj)) return 'object';
          return typeof obj === 'undefined' ? 'undefined' : babelHelpers.typeof(obj);
        }
    
        exports.Library = Library;
    
        /**
         * ### Library
         *
         * Create a repository for custom type detection.
         *
         * ```js
         * var lib = new type.Library;
         * ```
         *
         */
    
        function Library() {
          this.tests = {};
        }
    
        /**
         * #### .of (obj)
         *
         * Expose replacement `typeof` detection to the library.
         *
         * ```js
         * if ('string' === lib.of('hello world')) {
         *   // ...
         * }
         * ```
         *
         * @param {Mixed} object to test
         * @return {String} type
         */
    
        Library.prototype.of = getType;
    
        /**
         * #### .define (type, test)
         *
         * Add a test to for the `.test()` assertion.
         *
         * Can be defined as a regular expression:
         *
         * ```js
         * lib.define('int', /^[0-9]+$/);
         * ```
         *
         * ... or as a function:
         *
         * ```js
         * lib.define('bln', function (obj) {
         *   if ('boolean' === lib.of(obj)) return true;
         *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
         *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
         *   return !! ~blns.indexOf(obj);
         * });
         * ```
         *
         * @param {String} type
         * @param {RegExp|Function} test
         * @api public
         */
    
        Library.prototype.define = function (type, test) {
          if (arguments.length === 1) return this.tests[type];
          this.tests[type] = test;
          return this;
        };
    
        /**
         * #### .test (obj, test)
         *
         * Assert that an object is of type. Will first
         * check natives, and if that does not pass it will
         * use the user defined custom tests.
         *
         * ```js
         * assert(lib.test('1', 'int'));
         * assert(lib.test('yes', 'bln'));
         * ```
         *
         * @param {Mixed} object
         * @param {String} type
         * @return {Boolean} result
         * @api public
         */
    
        Library.prototype.test = function (obj, type) {
          if (type === getType(obj)) return true;
          var test = this.tests[type];
    
          if (test && 'regexp' === getType(test)) {
            return test.test(obj);
          } else if (test && 'function' === getType(test)) {
            return test(obj);
          } else {
            throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
          }
        };
      });
    
      var require$$0$11 = type$1 && (typeof type$1 === 'undefined' ? 'undefined' : babelHelpers.typeof(type$1)) === 'object' && 'default' in type$1 ? type$1['default'] : type$1;
    
      var index$5 = __commonjs(function (module) {
        module.exports = require$$0$11;
      });
    
      var require$$1$2 = index$5 && (typeof index$5 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$5)) === 'object' && 'default' in index$5 ? index$5['default'] : index$5;
    
      var eql = __commonjs(function (module) {
        /*!
         * deep-eql
         * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Module dependencies
         */
    
        var type = require$$1$2;
    
        /*!
         * Buffer.isBuffer browser shim
         */
    
        var Buffer;
        try {
          Buffer = require$$0.Buffer;
        } catch (ex) {
          Buffer = {};
          Buffer.isBuffer = function () {
            return false;
          };
        }
    
        /*!
         * Primary Export
         */
    
        module.exports = deepEqual;
    
        /**
         * Assert super-strict (egal) equality between
         * two objects of any type.
         *
         * @param {Mixed} a
         * @param {Mixed} b
         * @param {Array} memoised (optional)
         * @return {Boolean} equal match
         */
    
        function deepEqual(a, b, m) {
          if (sameValue(a, b)) {
            return true;
          } else if ('date' === type(a)) {
            return dateEqual(a, b);
          } else if ('regexp' === type(a)) {
            return regexpEqual(a, b);
          } else if (Buffer.isBuffer(a)) {
            return bufferEqual(a, b);
          } else if ('arguments' === type(a)) {
            return argumentsEqual(a, b, m);
          } else if (!typeEqual(a, b)) {
            return false;
          } else if ('object' !== type(a) && 'object' !== type(b) && 'array' !== type(a) && 'array' !== type(b)) {
            return sameValue(a, b);
          } else {
            return objectEqual(a, b, m);
          }
        }
    
        /*!
         * Strict (egal) equality test. Ensures that NaN always
         * equals NaN and `-0` does not equal `+0`.
         *
         * @param {Mixed} a
         * @param {Mixed} b
         * @return {Boolean} equal match
         */
    
        function sameValue(a, b) {
          if (a === b) return a !== 0 || 1 / a === 1 / b;
          return a !== a && b !== b;
        }
    
        /*!
         * Compare the types of two given objects and
         * return if they are equal. Note that an Array
         * has a type of `array` (not `object`) and arguments
         * have a type of `arguments` (not `array`/`object`).
         *
         * @param {Mixed} a
         * @param {Mixed} b
         * @return {Boolean} result
         */
    
        function typeEqual(a, b) {
          return type(a) === type(b);
        }
    
        /*!
         * Compare two Date objects by asserting that
         * the time values are equal using `saveValue`.
         *
         * @param {Date} a
         * @param {Date} b
         * @return {Boolean} result
         */
    
        function dateEqual(a, b) {
          if ('date' !== type(b)) return false;
          return sameValue(a.getTime(), b.getTime());
        }
    
        /*!
         * Compare two regular expressions by converting them
         * to string and checking for `sameValue`.
         *
         * @param {RegExp} a
         * @param {RegExp} b
         * @return {Boolean} result
         */
    
        function regexpEqual(a, b) {
          if ('regexp' !== type(b)) return false;
          return sameValue(a.toString(), b.toString());
        }
    
        /*!
         * Assert deep equality of two `arguments` objects.
         * Unfortunately, these must be sliced to arrays
         * prior to test to ensure no bad behavior.
         *
         * @param {Arguments} a
         * @param {Arguments} b
         * @param {Array} memoize (optional)
         * @return {Boolean} result
         */
    
        function argumentsEqual(a, b, m) {
          if ('arguments' !== type(b)) return false;
          a = [].slice.call(a);
          b = [].slice.call(b);
          return deepEqual(a, b, m);
        }
    
        /*!
         * Get enumerable properties of a given object.
         *
         * @param {Object} a
         * @return {Array} property names
         */
    
        function enumerable(a) {
          var res = [];
          for (var key in a) {
            res.push(key);
          }return res;
        }
    
        /*!
         * Simple equality for flat iterable objects
         * such as Arrays or Node.js buffers.
         *
         * @param {Iterable} a
         * @param {Iterable} b
         * @return {Boolean} result
         */
    
        function iterableEqual(a, b) {
          if (a.length !== b.length) return false;
    
          var i = 0;
          var match = true;
    
          for (; i < a.length; i++) {
            if (a[i] !== b[i]) {
              match = false;
              break;
            }
          }
    
          return match;
        }
    
        /*!
         * Extension to `iterableEqual` specifically
         * for Node.js Buffers.
         *
         * @param {Buffer} a
         * @param {Mixed} b
         * @return {Boolean} result
         */
    
        function bufferEqual(a, b) {
          if (!Buffer.isBuffer(b)) return false;
          return iterableEqual(a, b);
        }
    
        /*!
         * Block for `objectEqual` ensuring non-existing
         * values don't get in.
         *
         * @param {Mixed} object
         * @return {Boolean} result
         */
    
        function isValue(a) {
          return a !== null && a !== undefined;
        }
    
        /*!
         * Recursively check the equality of two objects.
         * Once basic sameness has been established it will
         * defer to `deepEqual` for each enumerable key
         * in the object.
         *
         * @param {Mixed} a
         * @param {Mixed} b
         * @return {Boolean} result
         */
    
        function objectEqual(a, b, m) {
          if (!isValue(a) || !isValue(b)) {
            return false;
          }
    
          if (a.prototype !== b.prototype) {
            return false;
          }
    
          var i;
          if (m) {
            for (i = 0; i < m.length; i++) {
              if (m[i][0] === a && m[i][1] === b || m[i][0] === b && m[i][1] === a) {
                return true;
              }
            }
          } else {
            m = [];
          }
    
          try {
            var ka = enumerable(a);
            var kb = enumerable(b);
          } catch (ex) {
            return false;
          }
    
          ka.sort();
          kb.sort();
    
          if (!iterableEqual(ka, kb)) {
            return false;
          }
    
          m.push([a, b]);
    
          var key;
          for (i = ka.length - 1; i >= 0; i--) {
            key = ka[i];
            if (!deepEqual(a[key], b[key], m)) {
              return false;
            }
          }
    
          return true;
        }
      });
    
      var require$$0$10 = eql && (typeof eql === 'undefined' ? 'undefined' : babelHelpers.typeof(eql)) === 'object' && 'default' in eql ? eql['default'] : eql;
    
      var index$4 = __commonjs(function (module) {
        module.exports = require$$0$10;
      });
    
      var require$$10 = index$4 && (typeof index$4 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$4)) === 'object' && 'default' in index$4 ? index$4['default'] : index$4;
    
      var getEnumerableProperties = __commonjs(function (module) {
        /*!
         * Chai - getEnumerableProperties utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### .getEnumerableProperties(object)
         *
         * This allows the retrieval of enumerable property names of an object,
         * inherited or not.
         *
         * @param {Object} object
         * @returns {Array}
         * @namespace Utils
         * @name getEnumerableProperties
         * @api public
         */
    
        module.exports = function getEnumerableProperties(object) {
          var result = [];
          for (var name in object) {
            result.push(name);
          }
          return result;
        };
      });
    
      var require$$0$13 = getEnumerableProperties && (typeof getEnumerableProperties === 'undefined' ? 'undefined' : babelHelpers.typeof(getEnumerableProperties)) === 'object' && 'default' in getEnumerableProperties ? getEnumerableProperties['default'] : getEnumerableProperties;
    
      var getProperties = __commonjs(function (module) {
        /*!
         * Chai - getProperties utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### .getProperties(object)
         *
         * This allows the retrieval of property names of an object, enumerable or not,
         * inherited or not.
         *
         * @param {Object} object
         * @returns {Array}
         * @namespace Utils
         * @name getProperties
         * @api public
         */
    
        module.exports = function getProperties(object) {
          var result = Object.getOwnPropertyNames(object);
    
          function addProperty(property) {
            if (result.indexOf(property) === -1) {
              result.push(property);
            }
          }
    
          var proto = Object.getPrototypeOf(object);
          while (proto !== null) {
            Object.getOwnPropertyNames(proto).forEach(addProperty);
            proto = Object.getPrototypeOf(proto);
          }
    
          return result;
        };
      });
    
      var require$$1$4 = getProperties && (typeof getProperties === 'undefined' ? 'undefined' : babelHelpers.typeof(getProperties)) === 'object' && 'default' in getProperties ? getProperties['default'] : getProperties;
    
      var inspect = __commonjs(function (module, exports) {
        // This is (almost) directly from Node.js utils
        // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
    
        var getName = require$$2$3;
        var getProperties = require$$1$4;
        var getEnumerableProperties = require$$0$13;
    
        module.exports = inspect;
    
        /**
         * Echos the value of a value. Trys to print the value out
         * in the best way possible given the different types.
         *
         * @param {Object} obj The object to print out.
         * @param {Boolean} showHidden Flag that shows hidden (not enumerable)
         *    properties of objects.
         * @param {Number} depth Depth in which to descend in object. Default is 2.
         * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
         *    output. Default is false (no coloring).
         * @namespace Utils
         * @name inspect
         */
        function inspect(obj, showHidden, depth, colors) {
          var ctx = {
            showHidden: showHidden,
            seen: [],
            stylize: function stylize(str) {
              return str;
            }
          };
          return formatValue(ctx, obj, typeof depth === 'undefined' ? 2 : depth);
        }
    
        // Returns true if object is a DOM element.
        var isDOMElement = function isDOMElement(object) {
          if ((typeof HTMLElement === 'undefined' ? 'undefined' : babelHelpers.typeof(HTMLElement)) === 'object') {
            return object instanceof HTMLElement;
          } else {
            return object && (typeof object === 'undefined' ? 'undefined' : babelHelpers.typeof(object)) === 'object' && object.nodeType === 1 && typeof object.nodeName === 'string';
          }
        };
    
        function formatValue(ctx, value, recurseTimes) {
          // Provide a hook for user-specified inspect functions.
          // Check that value is an object with an inspect function on it
          if (value && typeof value.inspect === 'function' &&
          // Filter out the util module, it's inspect function is special
          value.inspect !== exports.inspect &&
          // Also filter out any prototype objects using the circular check.
          !(value.constructor && value.constructor.prototype === value)) {
            var ret = value.inspect(recurseTimes);
            if (typeof ret !== 'string') {
              ret = formatValue(ctx, ret, recurseTimes);
            }
            return ret;
          }
    
          // Primitive types cannot have properties
          var primitive = formatPrimitive(ctx, value);
          if (primitive) {
            return primitive;
          }
    
          // If this is a DOM element, try to get the outer HTML.
          if (isDOMElement(value)) {
            if ('outerHTML' in value) {
              return value.outerHTML;
              // This value does not have an outerHTML attribute,
              //   it could still be an XML element
            } else {
                // Attempt to serialize it
                try {
                  if (document.xmlVersion) {
                    var xmlSerializer = new XMLSerializer();
                    return xmlSerializer.serializeToString(value);
                  } else {
                    // Firefox 11- do not support outerHTML
                    //   It does, however, support innerHTML
                    //   Use the following to render the element
                    var ns = "http://www.w3.org/1999/xhtml";
                    var container = document.createElementNS(ns, '_');
    
                    container.appendChild(value.cloneNode(false));
                    html = container.innerHTML.replace('><', '>' + value.innerHTML + '<');
                    container.innerHTML = '';
                    return html;
                  }
                } catch (err) {
                  // This could be a non-native DOM implementation,
                  //   continue with the normal flow:
                  //   printing the element as if it is an object.
                }
              }
          }
    
          // Look up the keys of the object.
          var visibleKeys = getEnumerableProperties(value);
          var keys = ctx.showHidden ? getProperties(value) : visibleKeys;
    
          // Some type of object without properties can be shortcutted.
          // In IE, errors have a single `stack` property, or if they are vanilla `Error`,
          // a `stack` plus `description` property; ignore those for consistency.
          if (keys.length === 0 || isError(value) && (keys.length === 1 && keys[0] === 'stack' || keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')) {
            if (typeof value === 'function') {
              var name = getName(value);
              var nameSuffix = name ? ': ' + name : '';
              return ctx.stylize('[Function' + nameSuffix + ']', 'special');
            }
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            }
            if (isDate(value)) {
              return ctx.stylize(Date.prototype.toUTCString.call(value), 'date');
            }
            if (isError(value)) {
              return formatError(value);
            }
          }
    
          var base = '',
              array = false,
              braces = ['{', '}'];
    
          // Make Array say that they are Array
          if (isArray(value)) {
            array = true;
            braces = ['[', ']'];
          }
    
          // Make functions say that they are functions
          if (typeof value === 'function') {
            var name = getName(value);
            var nameSuffix = name ? ': ' + name : '';
            base = ' [Function' + nameSuffix + ']';
          }
    
          // Make RegExps say that they are RegExps
          if (isRegExp(value)) {
            base = ' ' + RegExp.prototype.toString.call(value);
          }
    
          // Make dates with properties first say the date
          if (isDate(value)) {
            base = ' ' + Date.prototype.toUTCString.call(value);
          }
    
          // Make error with message first say the error
          if (isError(value)) {
            return formatError(value);
          }
    
          if (keys.length === 0 && (!array || value.length == 0)) {
            return braces[0] + base + braces[1];
          }
    
          if (recurseTimes < 0) {
            if (isRegExp(value)) {
              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
            } else {
              return ctx.stylize('[Object]', 'special');
            }
          }
    
          ctx.seen.push(value);
    
          var output;
          if (array) {
            output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
          } else {
            output = keys.map(function (key) {
              return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
            });
          }
    
          ctx.seen.pop();
    
          return reduceToSingleString(output, base, braces);
        }
    
        function formatPrimitive(ctx, value) {
          switch (typeof value === 'undefined' ? 'undefined' : babelHelpers.typeof(value)) {
            case 'undefined':
              return ctx.stylize('undefined', 'undefined');
    
            case 'string':
              var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + '\'';
              return ctx.stylize(simple, 'string');
    
            case 'number':
              if (value === 0 && 1 / value === -Infinity) {
                return ctx.stylize('-0', 'number');
              }
              return ctx.stylize('' + value, 'number');
    
            case 'boolean':
              return ctx.stylize('' + value, 'boolean');
          }
          // For some reason typeof null is "object", so special case here.
          if (value === null) {
            return ctx.stylize('null', 'null');
          }
        }
    
        function formatError(value) {
          return '[' + Error.prototype.toString.call(value) + ']';
        }
    
        function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
          var output = [];
          for (var i = 0, l = value.length; i < l; ++i) {
            if (Object.prototype.hasOwnProperty.call(value, String(i))) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
            } else {
              output.push('');
            }
          }
          keys.forEach(function (key) {
            if (!key.match(/^\d+$/)) {
              output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
            }
          });
          return output;
        }
    
        function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
          var name, str;
          if (value.__lookupGetter__) {
            if (value.__lookupGetter__(key)) {
              if (value.__lookupSetter__(key)) {
                str = ctx.stylize('[Getter/Setter]', 'special');
              } else {
                str = ctx.stylize('[Getter]', 'special');
              }
            } else {
              if (value.__lookupSetter__(key)) {
                str = ctx.stylize('[Setter]', 'special');
              }
            }
          }
          if (visibleKeys.indexOf(key) < 0) {
            name = '[' + key + ']';
          }
          if (!str) {
            if (ctx.seen.indexOf(value[key]) < 0) {
              if (recurseTimes === null) {
                str = formatValue(ctx, value[key], null);
              } else {
                str = formatValue(ctx, value[key], recurseTimes - 1);
              }
              if (str.indexOf('\n') > -1) {
                if (array) {
                  str = str.split('\n').map(function (line) {
                    return '  ' + line;
                  }).join('\n').substr(2);
                } else {
                  str = '\n' + str.split('\n').map(function (line) {
                    return '   ' + line;
                  }).join('\n');
                }
              }
            } else {
              str = ctx.stylize('[Circular]', 'special');
            }
          }
          if (typeof name === 'undefined') {
            if (array && key.match(/^\d+$/)) {
              return str;
            }
            name = JSON.stringify('' + key);
            if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
              name = name.substr(1, name.length - 2);
              name = ctx.stylize(name, 'name');
            } else {
              name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
              name = ctx.stylize(name, 'string');
            }
          }
    
          return name + ': ' + str;
        }
    
        function reduceToSingleString(output, base, braces) {
          var numLinesEst = 0;
          var length = output.reduce(function (prev, cur) {
            numLinesEst++;
            if (cur.indexOf('\n') >= 0) numLinesEst++;
            return prev + cur.length + 1;
          }, 0);
    
          if (length > 60) {
            return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
          }
    
          return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
        }
    
        function isArray(ar) {
          return Array.isArray(ar) || (typeof ar === 'undefined' ? 'undefined' : babelHelpers.typeof(ar)) === 'object' && objectToString(ar) === '[object Array]';
        }
    
        function isRegExp(re) {
          return (typeof re === 'undefined' ? 'undefined' : babelHelpers.typeof(re)) === 'object' && objectToString(re) === '[object RegExp]';
        }
    
        function isDate(d) {
          return (typeof d === 'undefined' ? 'undefined' : babelHelpers.typeof(d)) === 'object' && objectToString(d) === '[object Date]';
        }
    
        function isError(e) {
          return (typeof e === 'undefined' ? 'undefined' : babelHelpers.typeof(e)) === 'object' && objectToString(e) === '[object Error]';
        }
    
        function objectToString(o) {
          return Object.prototype.toString.call(o);
        }
      });
    
      var require$$1$3 = inspect && (typeof inspect === 'undefined' ? 'undefined' : babelHelpers.typeof(inspect)) === 'object' && 'default' in inspect ? inspect['default'] : inspect;
    
      var objDisplay = __commonjs(function (module) {
        /*!
         * Chai - flag utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Module dependancies
         */
    
        var inspect = require$$1$3;
        var config = require$$0$3;
    
        /**
         * ### .objDisplay (object)
         *
         * Determines if an object or an array matches
         * criteria to be inspected in-line for error
         * messages or should be truncated.
         *
         * @param {Mixed} javascript object to inspect
         * @name objDisplay
         * @namespace Utils
         * @api public
         */
    
        module.exports = function (obj) {
          var str = inspect(obj),
              type = Object.prototype.toString.call(obj);
    
          if (config.truncateThreshold && str.length >= config.truncateThreshold) {
            if (type === '[object Function]') {
              return !obj.name || obj.name === '' ? '[Function]' : '[Function: ' + obj.name + ']';
            } else if (type === '[object Array]') {
              return '[ Array(' + obj.length + ') ]';
            } else if (type === '[object Object]') {
              var keys = Object.keys(obj),
                  kstr = keys.length > 2 ? keys.splice(0, 2).join(', ') + ', ...' : keys.join(', ');
              return '{ Object (' + kstr + ') }';
            } else {
              return str;
            }
          } else {
            return str;
          }
        };
      });
    
      var require$$0$12 = objDisplay && (typeof objDisplay === 'undefined' ? 'undefined' : babelHelpers.typeof(objDisplay)) === 'object' && 'default' in objDisplay ? objDisplay['default'] : objDisplay;
    
      var getActual = __commonjs(function (module) {
        /*!
         * Chai - getActual utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * # getActual(object, [actual])
         *
         * Returns the `actual` value for an Assertion
         *
         * @param {Object} object (constructed Assertion)
         * @param {Arguments} chai.Assertion.prototype.assert arguments
         * @namespace Utils
         * @name getActual
         */
    
        module.exports = function (obj, args) {
          return args.length > 4 ? args[4] : obj._obj;
        };
      });
    
      var require$$2$4 = getActual && (typeof getActual === 'undefined' ? 'undefined' : babelHelpers.typeof(getActual)) === 'object' && 'default' in getActual ? getActual['default'] : getActual;
    
      var getMessage = __commonjs(function (module) {
        /*!
         * Chai - message composition utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Module dependancies
         */
    
        var flag = require$$0$5,
            getActual = require$$2$4,
            inspect = require$$1$3,
            objDisplay = require$$0$12;
    
        /**
         * ### .getMessage(object, message, negateMessage)
         *
         * Construct the error message based on flags
         * and template tags. Template tags will return
         * a stringified inspection of the object referenced.
         *
         * Message template tags:
         * - `#{this}` current asserted object
         * - `#{act}` actual value
         * - `#{exp}` expected value
         *
         * @param {Object} object (constructed Assertion)
         * @param {Arguments} chai.Assertion.prototype.assert arguments
         * @namespace Utils
         * @name getMessage
         * @api public
         */
    
        module.exports = function (obj, args) {
          var negate = flag(obj, 'negate'),
              val = flag(obj, 'object'),
              expected = args[3],
              actual = getActual(obj, args),
              msg = negate ? args[2] : args[1],
              flagMsg = flag(obj, 'message');
    
          if (typeof msg === "function") msg = msg();
          msg = msg || '';
          msg = msg.replace(/#\{this\}/g, function () {
            return objDisplay(val);
          }).replace(/#\{act\}/g, function () {
            return objDisplay(actual);
          }).replace(/#\{exp\}/g, function () {
            return objDisplay(expected);
          });
    
          return flagMsg ? flagMsg + ': ' + msg : msg;
        };
      });
    
      var require$$16 = getMessage && (typeof getMessage === 'undefined' ? 'undefined' : babelHelpers.typeof(getMessage)) === 'object' && 'default' in getMessage ? getMessage['default'] : getMessage;
    
      var index$6 = __commonjs(function (module) {
        /*!
         * assertion-error
         * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
         * MIT Licensed
         */
    
        /*!
         * Return a function that will copy properties from
         * one object to another excluding any originally
         * listed. Returned function will create a new `{}`.
         *
         * @param {String} excluded properties ...
         * @return {Function}
         */
    
        function exclude() {
          var excludes = [].slice.call(arguments);
    
          function excludeProps(res, obj) {
            Object.keys(obj).forEach(function (key) {
              if (! ~excludes.indexOf(key)) res[key] = obj[key];
            });
          }
    
          return function extendExclude() {
            var args = [].slice.call(arguments),
                i = 0,
                res = {};
    
            for (; i < args.length; i++) {
              excludeProps(res, args[i]);
            }
    
            return res;
          };
        };
    
        /*!
         * Primary Exports
         */
    
        module.exports = AssertionError;
    
        /**
         * ### AssertionError
         *
         * An extension of the JavaScript `Error` constructor for
         * assertion and validation scenarios.
         *
         * @param {String} message
         * @param {Object} properties to include (optional)
         * @param {callee} start stack function (optional)
         */
    
        function AssertionError(message, _props, ssf) {
          var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON'),
              props = extend(_props || {});
    
          // default values
          this.message = message || 'Unspecified AssertionError';
          this.showDiff = false;
    
          // copy from properties
          for (var key in props) {
            this[key] = props[key];
          }
    
          // capture stack trace
          ssf = ssf || arguments.callee;
          if (ssf && Error.captureStackTrace) {
            Error.captureStackTrace(this, ssf);
          } else {
            this.stack = new Error().stack;
          }
        }
    
        /*!
         * Inherit from Error.prototype
         */
    
        AssertionError.prototype = Object.create(Error.prototype);
    
        /*!
         * Statically set name
         */
    
        AssertionError.prototype.name = 'AssertionError';
    
        /*!
         * Ensure correct constructor
         */
    
        AssertionError.prototype.constructor = AssertionError;
    
        /**
         * Allow errors to be converted to JSON for static transfer.
         *
         * @param {Boolean} include stack (default: `true`)
         * @return {Object} object that can be `JSON.stringify`
         */
    
        AssertionError.prototype.toJSON = function (stack) {
          var extend = exclude('constructor', 'toJSON', 'stack'),
              props = extend({ name: this.name }, this);
    
          // include stack if exists and not turned off
          if (false !== stack && this.stack) {
            props.stack = this.stack;
          }
    
          return props;
        };
      });
    
      var require$$2$5 = index$6 && (typeof index$6 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$6)) === 'object' && 'default' in index$6 ? index$6['default'] : index$6;
    
      var expectTypes = __commonjs(function (module) {
        /*!
         * Chai - expectTypes utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /**
         * ### expectTypes(obj, types)
         *
         * Ensures that the object being tested against is of a valid type.
         *
         *     utils.expectTypes(this, ['array', 'object', 'string']);
         *
         * @param {Mixed} obj constructed Assertion
         * @param {Array} type A list of allowed types for this assertion
         * @namespace Utils
         * @name expectTypes
         * @api public
         */
    
        var AssertionError = require$$2$5;
        var flag = require$$0$5;
        var type = require$$0$7;
    
        module.exports = function (obj, types) {
          var obj = flag(obj, 'object');
          types = types.map(function (t) {
            return t.toLowerCase();
          });
          types.sort();
    
          // Transforms ['lorem', 'ipsum'] into 'a lirum, or an ipsum'
          var str = types.map(function (t, index) {
            var art = ~['a', 'e', 'i', 'o', 'u'].indexOf(t.charAt(0)) ? 'an' : 'a';
            var or = types.length > 1 && index === types.length - 1 ? 'or ' : '';
            return or + art + ' ' + t;
          }).join(', ');
    
          if (!types.some(function (expected) {
            return type(obj) === expected;
          })) {
            throw new AssertionError('object tested must be ' + str + ', but ' + type(obj) + ' given');
          }
        };
      });
    
      var require$$17 = expectTypes && (typeof expectTypes === 'undefined' ? 'undefined' : babelHelpers.typeof(expectTypes)) === 'object' && 'default' in expectTypes ? expectTypes['default'] : expectTypes;
    
      var test = __commonjs(function (module) {
        /*!
         * Chai - test utility
         * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Module dependancies
         */
    
        var flag = require$$0$5;
    
        /**
         * # test(object, expression)
         *
         * Test and object for expression.
         *
         * @param {Object} object (constructed Assertion)
         * @param {Arguments} chai.Assertion.prototype.assert arguments
         * @namespace Utils
         * @name test
         */
    
        module.exports = function (obj, args) {
          var negate = flag(obj, 'negate'),
              expr = args[0];
          return negate ? !expr : expr;
        };
      });
    
      var require$$19 = test && (typeof test === 'undefined' ? 'undefined' : babelHelpers.typeof(test)) === 'object' && 'default' in test ? test['default'] : test;
    
      var index$2 = __commonjs(function (module) {
        /*!
         * chai
         * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        /*!
         * Main exports
         */
    
        var exports = module.exports = {};
    
        /*!
         * test utility
         */
    
        exports.test = require$$19;
    
        /*!
         * type utility
         */
    
        exports.type = require$$0$7;
    
        /*!
         * expectTypes utility
         */
        exports.expectTypes = require$$17;
    
        /*!
         * message utility
         */
    
        exports.getMessage = require$$16;
    
        /*!
         * actual utility
         */
    
        exports.getActual = require$$2$4;
    
        /*!
         * Inspect util
         */
    
        exports.inspect = require$$1$3;
    
        /*!
         * Object Display util
         */
    
        exports.objDisplay = require$$0$12;
    
        /*!
         * Flag utility
         */
    
        exports.flag = require$$0$5;
    
        /*!
         * Flag transferring utility
         */
    
        exports.transferFlags = require$$2$1;
    
        /*!
         * Deep equal utility
         */
    
        exports.eql = require$$10;
    
        /*!
         * Deep path value
         */
    
        exports.getPathValue = require$$9;
    
        /*!
         * Deep path info
         */
    
        exports.getPathInfo = require$$0$9;
    
        /*!
         * Check if a property exists
         */
    
        exports.hasProperty = require$$0$6;
    
        /*!
         * Function name
         */
    
        exports.getName = require$$2$3;
    
        /*!
         * add Property
         */
    
        exports.addProperty = require$$5;
    
        /*!
         * add Method
         */
    
        exports.addMethod = require$$4$1;
    
        /*!
         * overwrite Property
         */
    
        exports.overwriteProperty = require$$3$1;
    
        /*!
         * overwrite Method
         */
    
        exports.overwriteMethod = require$$2$2;
    
        /*!
         * Add a chainable method
         */
    
        exports.addChainableMethod = require$$1$1;
    
        /*!
         * Overwrite chainable method
         */
    
        exports.overwriteChainableMethod = require$$0$4;
      });
    
      var require$$6 = index$2 && (typeof index$2 === 'undefined' ? 'undefined' : babelHelpers.typeof(index$2)) === 'object' && 'default' in index$2 ? index$2['default'] : index$2;
    
      var chai = __commonjs(function (module, exports) {
        /*!
         * chai
         * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
         * MIT Licensed
         */
    
        var used = [],
            exports = module.exports = {};
    
        /*!
         * Chai version
         */
    
        exports.version = '3.5.0';
    
        /*!
         * Assertion Error
         */
    
        exports.AssertionError = require$$2$5;
    
        /*!
         * Utils for plugins (not exported)
         */
    
        var util = require$$6;
    
        /**
         * # .use(function)
         *
         * Provides a way to extend the internals of Chai
         *
         * @param {Function}
         * @returns {this} for chaining
         * @api public
         */
    
        exports.use = function (fn) {
          if (! ~used.indexOf(fn)) {
            fn(this, util);
            used.push(fn);
          }
    
          return this;
        };
    
        /*!
         * Utility Functions
         */
    
        exports.util = util;
    
        /*!
         * Configuration
         */
    
        var config = require$$0$3;
        exports.config = config;
    
        /*!
         * Primary `Assertion` prototype
         */
    
        var assertion = require$$4;
        exports.use(assertion);
    
        /*!
         * Core Assertions
         */
    
        var core = require$$3;
        exports.use(core);
    
        /*!
         * Expect interface
         */
    
        var expect = require$$2;
        exports.use(expect);
    
        /*!
         * Should interface
         */
    
        var should = require$$1;
        exports.use(should);
    
        /*!
         * Assert interface
         */
    
        var assert = require$$0$2;
        exports.use(assert);
      });
    
      var require$$0$1 = chai && (typeof chai === 'undefined' ? 'undefined' : babelHelpers.typeof(chai)) === 'object' && 'default' in chai ? chai['default'] : chai;
    
      var index = __commonjs(function (module) {
        module.exports = require$$0$1;
      });
    
      index && (typeof index === 'undefined' ? 'undefined' : babelHelpers.typeof(index)) === 'object' && 'default' in index ? index['default'] : index;
    
      //import {jQuery as $, input as $input, expect} from '../support/fixture'
      //import {jQuery, input, expect} from '../support/fixture'
    
      var $ = window.jQuery;
      var $input = $('input');
    
    }(require$$0));
    //# sourceMappingURL=picker-tests.js.iife.js.map
    
    

    public by Geoffrey Dhuyvetters  841  0  3  0

    .babelrc

    .babelrc: .babelrc
    {
      "stage": 0
    }
    
    

    List Complete ( 8 snippets total )

    • Public Snippets
    • Channels Snippets