traceur-rb 0.0.1 → 0.0.2

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/.npmignore

@@ -1,11 +0,0 @@
-.gitignore
-.travis.ymp
-.tmp
-/bench
-checklist.csv
-collections.cat.js
-collections.min.js
-/coverage
-/demo
-/minify
-/spec

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/CHANGES.md

@@ -1,78 +0,0 @@
-
-## v0.2.2
-
--   `one` now returns a consistent value between changes of a sorted
-    set.
--   All collections can now be required using the MontageJS style, as
-    well as the Node.js style. I reserve the right to withdraw support
-    for the current MontageJS style if in a future,
-    backward-incompatible release of Montage migrated to the Node.js
-    style.
-
-## v0.2.1
-
--   Identify Maps with `isMap` property instead of `keys`, as ES6
-    proposes `keys`, `values`, and `entries` methods for arrays.
-
-## v0.2.0
-
--   Fixes the enumerability of dispatchesRangeChanges and
-    dispatchesMapChanges on observable arrays (and others,
-    incidentally).
--   List and Set now dispatch valid range changes, at the penalty of
-    making updates linear when they are made observable.
--   Adds `join` method to generic collections.
--   Fixes a bug in `Object.has(object, value)`, where it would not
-    delegate polymorphically to `object.has(value)`
--   Fixes `Object.addEach(object, undefined)`, such that it tolerates
-    the case without throwing an error, like `addEach` on other
-    collections.
--   Fixes change dispatch on LruSet (Paul Koppen) such that a single
-    change event gets dispatched for both augmentation and truncation.
--   Fixes change dispatch on Dict, such that the value gets sent on
-    addition.
-
-## v0.1.24
-
--   Factored out WeakMap into separately maintained package.
-
-## v0.1.23
-
--   Introduces `entries` and deprecates `items` on all map collections.
--   Fixes Map clear change dispatch.
-
-## v0.1.22
-
--   Fixes Set clear change dispatch.
-
-## v0.1.21
-
--   Fixes a bug when the `plus` argument of swap is not an array.
-
-## v0.1.20
-
--   Fixes generic map change dispatch on clear.
--   Adds map change dispatch to Dict.
-
-## v0.1.18, v0.1.19
-
--   Require total order on SortedSet
--   Remove Node v0.6 from supported versions
--   Add Node v0.10 to supported versions
--   Fixes `hrtime` handling (Alexy Kupershtokh)
-
-## v0.1.17
-
-...
-
-## v0.0.5
-
--   The `observable-array` and `observable-object` modules have been
-    moved to the Functional Reactive Bindings (`frb`) package as `array`
-    and `object`.
--   `List`, `Set`, and `SortedSet` now support content change
-    notifications compatibly with `frb`.
--   The `observable` module provides generics methods for observables.
-    New collections need only call the appropriate dispatch functions if
-    `isObservable` is true.
-

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/LICENSE.md

@@ -1,21 +0,0 @@
-
-Copyright 2012 Kristopher Michael Kowal. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE.
-

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/README.md

@@ -1,1285 +0,0 @@
-[![Build Status](https://travis-ci.org/montagejs/collections.png?branch=master)](http://travis-ci.org/montagejs/collections)
-
-# Collections
-
-This package contains JavaScript implementations of common data
-structures with idiomatic iterfaces, including extensions for Array and
-Object.
-
-You can use these Node Packaged Modules with Node.js, [Browserify][],
-[Mr][], or any compatible CommonJS module loader.  Using a module loader
-or bundler when using Collections in web browsers has the advantage of
-only incorporating the modules you need.  However, you can just embed
-`<script src="collections/collections.min.js">` and *all* of the
-collections will be introduced as globals.  :warning:
-`require("collections")` is not supported.
-
-```
-npm install collections --save
-```
-
-[Browserify]: https://github.com/substack/node-browserify
-[Mr]: https://github.com/montagejs/mr
-
-
-## Collections
-
-### List(values, equals, getDefault)
-
-```javascript
-var List = require("collections/list");
-```
-
-An ordered collection of values with fast insertion and deletion and
-forward and backward traversal, backed by a cyclic doubly linked
-list with a head node.  Lists support most of the Array interface,
-except that they use and return nodes instead of integer indicies in
-analogous functions.
-
-Lists have a `head` `Node`. The node type is available as `Node` on
-the list prototype and can be overridden by inheritors.  Each node
-has `prev` and `next` properties.
-
-### Set(values, equals, hash, getDefault)
-
-```javascript
-var Set = require("collections/set");
-```
-
-A collection of unique values.  The set can be iterated in the order
-of insertion.  With a good hash function for the stored values,
-insertion and removal are fast regardless of the size of the
-collection.  Values may be objects.  The `equals` and `hash`
-functions can be overridden to provide alternate definitions of
-"unique".  `Set` is backed by `FastSet` and `List`.
-
-### Map(map, equals, hash, getDefault)
-
-```javascript
-var Map = require("collections/map");
-```
-
-A collection of key and value entries with unique keys.  Keys may be
-objects.  The collection iterates in the order of insertion.  `Map`
-is backed by `Set`.
-
-### MultiMap(map, getDefault, equals, hash)
-
-```javascript
-var MultiMap = require("collections/multi-map");
-```
-
-A collection of keys mapped to collections of values.  The default
-`getDefault` collection is an `Array`, but it can be a `List` or any
-other array-like object.  `MultiMap` inherits `Map` but overrides
-the `getDefault(key)` provider.
-
-### WeakMap()
-
-```javascript
-var WeakMap = require("collections/weak-map");
-```
-
-A non-iterable collection of key value pairs.  Keys must objects and
-do not benefit from `hash` functions.  Some engines already
-implement `WeakMap`.  The non-iterable requirement makes it possible
-for weak maps to collect garbage when the key is no longer
-available, without betraying when the key is collected.  The shimmed
-implementation undetectably annotates the given key and thus does
-not necessarily leak memory, but cannot collect certain reference
-graphs.  This WeakMap shim was implemented by Mark Miller of Google.
-
-### SortedSet(values, equals, compare, getDefault)
-
-```javascript
-var SortedSet = require("collections/sorted-set");
-```
-
-A collection of unique values stored in stored order, backed by a
-splay tree.  The `equals` and `compare` functions can be overridden
-to provide alternate definitions of "unique".
-
-The `compare` method *must* provide a total order of all unique
-values.  That is, if `compare(a, b) === 0`, it *must* follow that
-`equals(a, b)`.
-
-### SortedMap(map, equals, compare, getDefault)
-
-```javascript
-var SortedMap = require("collections/sorted-map");
-```
-
-A collection of key value pairs stored in sorted order.  `SortedMap`
-is backed by `SortedSet` and the `GenericMap` mixin.
-
-### LruSet(values, maxLength, equals, hash, getDefault)
-
-```javascript
-var LruSet = require("collections/lru-set");
-```
-
-A cache with the Least-Recently-Used strategy for truncating its
-content when it’s length exceeds `maxLength`.  `LruSet` is backed by
-a `Set` and takes advantage of the already tracked insertion order.
-Both getting and setting a value constitute usage, but checking
-whether the set has a value and iterating values do not.
-
-### LruMap(map, maxLength, equals, hash, getDefault)
-
-```javascript
-var LruMap = require("collections/lru-map");
-```
-
-A cache of entries backed by an `LruSet`.
-
-### SortedArray(values, equals, compare, getDefault)
-
-```javascript
-var SortedArray = require("collections/sorted-array");
-```
-
-A collection of values stored in a stable sorted order, backed by an
-array.
-
-### SortedArraySet(values, equals, compare, getDefault)
-
-```javascript
-var SortedArraySet = require("collections/sorted-array-set");
-```
-
-A collection of unique values stored in sorted order, backed by a
-plain array.  If the given values are an actual array, the sorted
-array set takes ownership of that array and retains its content.  A
-sorted array set performs better than a sorted set when it has
-roughly less than 100 values.
-
-### SortedArrayMap(values, equals, compare, getDefault)
-
-```javascript
-var SortedArrayMap = require("collections/sorted-array-map");
-```
-
-A collection of key value pairs stored in sorted order, backed by a
-sorted array set.
-
-### FastSet(values, equals, hash, getDefault)
-
-```javascript
-var FastSet = require("collections/fast-set");
-```
-
-A collection of unique values stored like a hash table.  The
-underlying storage is a `Dict` that maps hashes to lists of values
-that share the same hash.  Values may be objects.  The `equals` and
-`hash` functions can be overridden to provide alternate definitions
-of "unique".
-
-### FastMap(map, equals, hash, getDefault)
-
-```javascript
-var FastMap = require("collections/fast-map");
-```
-
-A collection of key and value entries with unique keys, backed by a
-set.  Keys may be objects.  `FastMap` is backed by `FastSet` and the
-`GenericMap` mixin.
-
-### Dict(values, getDefault)
-
-```javascript
-var Dict = require("collections/dict");
-```
-
-A collection of string to value mappings backed by a plain
-JavaScript object.  The keys are mangled to prevent collisions with
-JavaScript properties.
-
-### Heap(values, equals, compare)
-
-```javascript
-var Heap = require("collections/heap");
-```
-
-A collection that can always quickly (constant time) report its
-largest value, with reasonable performance for incremental changes
-(logarithmic), using a contiguous array as its backing storage.
-However, it does not track the sorted order of its elements.
-
-### Iterator(iterable)
-
-```javascript
-var Iterator = require("collections/iterator");
-```
-
-A wrapper for any iterable that implements `iterate` or iterator the
-implements `next`, providing a rich lazy traversal interface.
-
-### Array
-
-```javascript
-require("collections/shim-array");
-```
-
-An ordered collection of values with fast random access, push, and
-pop, but slow splice. The `array` module provides extensions so it
-hosts all the expressiveness of other collections.  The `shim-array`
-module shims EcmaScript 5 methods onto the array prototype if they
-are not natively implemented.
-
-### Object
-
-```javascript
-require("collections/shim-object");
-```
-
-Can be used as a mapping of owned string keys to arbitrary values.
-The `object` module provides extensions for the `Object` constructor
-that support the map collection interface and can delegate to
-methods of collections, allowing them to gracefully handle both
-object literals and collections.
-
-## Constructor Arguments
-
-For all of these constructors, the argument `values` is an optional
-collection of initial values, and may be an array.  If the `values` are
-in a map collection, the the values are taken, but the keys are ignored.
-
-### map
-
-The `map` argument is an optional collection to copy shallowly into
-the new mapping.  The `map` may be an object literal.  If `map`
-implements `keys`, it is treated as a mapping itself and copied.
-Otherwise, if `map` implements `forEach`, it may be any collection
-of `[key, value]` pairs.
-
-`equals(x, y)`, `compare(x, y)`, and `hash(value)` are all optional
-arguments overriding the meaning of equality, comparability, and
-consistent hashing for the purposes of the collection.  `equals` must
-return a boolean.  `compare` must return an integer with the same
-relationship to zero as x to y.  `hash` should consistently return the
-same string for any given object.
-
-### equals(x, y)
-
-The default `equals` operator is implemented in terms of `===`, but
-treats `NaN` as equal to itself and `-0` as distinct from `+0`.  It
-also delegates to an `equals` method of either the left or right
-argument if one exists.  The default equality operator is shimmed as
-`Object.equals`.
-
-### compare(x, y)
-
-The default `compare` operator is implemented in terms of `<` and
-`>`.  It delegates to the `compare` method of either the left or
-right argument if one exists.  It inverts the result if it uses the
-falls to the right argument.  The default comparator is shimmed as
-`Object.compare`.
-
-### hash(value)
-
-The default `hash` operator uses `toString` for values and provides
-a [Unique Label][] for arbitrary objects.  The default hash is
-shimmed as `Object.hash`.
-
-[Unique Label]: (http://wiki.ecmascript.org/doku.php?id=harmony:weak_maps#unique_labeler)
-
-### getDefault(key or value)
-
-The default `getDefault` function is `Function.noop`, which returns
-`undefined`.  The fallback function is used when you `get` a
-nonexistant value from any collection.  The `getDefault` function
-becomes a member of the collection object, so `getDefault` is called
-with the collection as `this`, so you can also use it to guarantee
-that default values in a collection are retained, as in `MultiMap`.
-
-
-## Collection Methods
-
-Where these methods coincide with the specification of an existing
-method of Array, Array is noted as an implementation.  `Array+` refers
-to shimmed arrays, as installed with the `array` module.  `Object`
-refers to methods implemented on the `Object` constructor function, as
-opposed to the `Object.prototype`.  `Object+` in turn refers to methods
-shimmed on the object constructor by the `object` module.  These
-functions accept the object as the first argument instead of the `this`
-implied argument.  ~~Strikethrough~~ indicates an implementation that
-should exist but has not yet been made (Send a pull request!).
-
-These are all of the collections:
-
-(Array, Array+, Object+, Iterator, List, Set, Map, MultiMap, WeakMap,
-SortedSet, SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict)
-
-### has
-
-#### has(key)
-
-Whether a value for the given key exists.
-
-(Object+, Map, MultiMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-#### has(value, opt_equals)
-
-Whether a value exists in this collection.  This is slow for list
-(linear), but fast (logarithmic) for SortedSet and SortedArraySet,
-and very fast (constant) for Set.
-
-(Array+, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet,
-FastSet)
-
-### get
-
-#### get(key or index)
-
-The value for a key.  If a Map or SortedMap lacks a key, returns
-`getDefault(key)`.
-
-(Array+, Map, SortedMap, SortedArrayMap, WeakMap, Object+)
-
-#### get(value)
-
-Gets the equivalent value, or falls back to `getDefault(value)`.
-
-(List, Set, SortedSet, LruSet, SortedArray, SortedArraySet, FastSet)
-
-### set(key or index, value)
-
-Sets the value for a key.
-
-(Map, MultiMap, WeakMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-### add
-
-#### add(value)
-
-Adds a value.  Ignores the operation and returns false if an
-equivalent value already exists.
-
-(Array+, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet,
-FastSet, Heap)
-
-#### add(value, key)
-
-Aliases `set(key, value)`, to assist generic methods used for maps,
-sets, and other collections.
-
-### addEach
-
-#### addEach(values)
-
-Copies values from another collection to this one.
-
-(Array+, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet,
-FastSet, Heap)
-
-#### addEach(mapping)
-
-Copies entries from another collection to this map.  If the mapping
-implements `keys` (indicating that it is a mapping) and `forEach`,
-all of the key value pairs are copied.  If the mapping only
-implements `forEach`, it is assumed to contain `[key, value]` arrays
-which are copied instead.
-
-(Object+, Map, MultiMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-### delete
-
-#### delete(key)
-
-Deletes the value for a given key.  Returns whether the key was
-found.
-
-(Map, MultiMap, WeakMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-#### delete(value)
-
-Deletes a value.  Returns whether the value was found.
-
-(Set, SortedSet, LruSet, SortedArray, SortedArraySet, FastSet, Heap)
-
-#### delete(value, equals)
-
-Deletes the equivalent value.  Returns whether the value was found.
-
-(Array+, List)
-
-### deleteEach(values or keys)
-
-Deletes every value or every value for each key.
-
-(Array+, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### indexOf(value)
-
-Returns the position in the collection of a value, or `-1` if it is
-not found.  Returns the position of the first of equivalent values.
-For an Array this takes linear time.  For a SortedArray and
-SortedArraySet, it takes logarithmic time to perform a binary
-search.  For a SortedSet, this takes ammortized logarithmic time
-since it incrementally updates the number of nodes under each
-subtree as it rotates.
-
-(Array, ~~List~~, SortedSet, SortedArray, SortedArraySet)
-
-### lastIndexOf(value)
-
-Returns the position in the collection of a value, or `-1` if it is
-not found.  Returns the position of the last of equivalent values.
-
-(Array, ~~List~~, SortedArray, SortedArraySet)
-
-### find(value, opt_equals)
-
-Finds a value.  For List and SortedSet, returns the node at which
-the value was found.  For SortedSet, the optional `equals` argument
-is ignored.
-
-(Array+, List, SortedSet)
-
-### findLast(value, opt_equals)
-
-Finds the last equivalent value, returning the node at which the
-value was found.
-
-(Array+, List, SortedArray, SortedArraySet)
-
-### findLeast()
-
-Finds the smallest value, returning the node at which it was found,
-or undefined.  This is fast (logarithmic) and performs no rotations.
-
-(SortedSet)
-
-### findLeastGreaterThan(value)
-
-Finds the smallest value greater than the given value.  This is fast
-(logarithic) but does cause rotations.
-
-(SortedSet)
-
-### findLeastGreaterThanOrEqual(value)
-
-Finds the smallest value greater than or equal to the given value.
-This is fast (logarithmic) but does cause rotations.
-
-(SortedSet)
-
-### findGreatest()
-
-(SortedSet)
-
-### findGreatestLessThan(value)
-
-(SortedSet)
-
-### findGreatestLessThanOrEqual(value)
-
-(SortedSet)
-
-### push
-
-#### push(...values)
-
-Adds values to the end of a collection.
-
-(Array, List)
-
-#### push(...values) for non-dequeues
-
-Adds values to their proper places in a collection.
-This method exists only to have the same interface as other
-collections.
-
-(Set, SortedSet, LruSet, SortedArray, SortedArraySet, FastSet, Heap)
-
-### unshift
-
-#### unshift(...values)
-
-Adds values to the beginning of a collection.
-
-(Array, List)
-
-#### unshift(...values) for non-dequeues
-
-Adds values to their proper places in a collection.
-This method exists only to have the same interface as other
-collections.
-
-(Set, SortedSet, LruSet, SortedArray, SortedArraySet, FastSet)
-
-### pop()
-
-Removes and returns the value at the end of a collection.  For a
-Heap, this means the greatest contained value, as defined by the
-comparator.
-
-(Array, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet,
-Heap)
-
-### shift()
-
-Removes and returns the value at the beginning of a collection.
-
-(Array, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet)
-
-### peek()
-
-Returns the last value in an ordered collection.
-
-(List)
-
-### poke(value)
-
-Replaces the last value in an ordered collection.
-
-(List)
-
-### slice(start, end)
-
-Returns an array of the values contained in the
-half-open interval [start, end), that is, including the start and
-excluding the end.  For lists and arrays, both terms may be numeric
-positive or negative indicies.  For a list, either term may be a
-node.
-
-(Array, List, SortedSet, SortedArray, SortedArraySet)
-
-### splice(start, length, ...values)
-
-Works as with an array, but for a list, the start may be an index or
-a node.
-
-(Array, List, SortedArray, SortedSet, SortedArraySet)
-
-### swap(start, length, values)
-
-Performs a splice without variadic arguments.
-
-(Array+, List, SortedArray, SortedSet, SortedArraySet)
-
-### clear()
-
-Deletes the all values.
-
-(Array+, Object+, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### sort(compare)
-
-Sorts a collection in place.  The comparator by only be a function.
-The default comparator coerces unlike types rather than fail to
-compare.
-
-(Array)
-
-### sorted(compare, by, order)
-
-Returns a collection as an array in sorted order.  Accepts an
-optional `compare(x, y)` function, `by(property(x))` function, and
-`order` indicator, `-1` for descending, `1` for ascending, `0` for
-stable.
-
-Instead of a `compare` function, the comparator can be an object
-with `compare` and `by` functions.  The default `compare` value is
-`Object.compare`.
-
-The `by` function must be a function that accepts a value from the
-collection and returns a representative value on which to sort.
-
-(Array+, List, Set, Map, SortedSet, LruSet, SortedArray,
-SortedArraySet, FastSet, Heap)
-
-### group(callback, thisp, equals)
-
-Returns an array of [key, equivalence class] pairs where every
-element from the collection is placed into an equivalence class
-if they have the same corresponding return value from the given
-callback.
-
-(Array+, Object+, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap, Iterator)
-
-### reverse()
-
-Reverses a collection in place.
-
-(Array, List)
-
-### reversed()
-
-Returns a collection of the same type with this collection's
-contents in reverse order.
-
-(Array, List)
-
-### enumerate(start=0)
-
-Returns an array of [index, value] pairs from the source collection,
-starting with the given index.
-
-### join(delimiter="")
-
-Returns a string of all the values in the collection joined.
-
-(Array, List, Set, SortedSet, LruSet, SortedArray, SortedArraySet,
-FastSet, Heap, Iterator)
-
-### concat(...iterables)
-
-Produces a new collection of the same type containing all the values
-of itself and the values of any number of other collections.  Favors
-the last of duplicate values.  For map-like objects, the given
-iterables are treated as map-like objects and each successively
-updates the result.  Array is like a map from index to value.  List,
-Set, and SortedSet are like maps from nodes to values.
-
-(Array, ~~Object+~~, Iterator, List, Set, Map, MultiMap,
-SortedSet, SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### keys()
-
-Returns an array of the keys.
-
-(Object, Map, MultiMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-### values()
-
-Returns an array of the values
-
-(Object+, Map, MultiMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-### entries()
-
-Returns an array of `[key, value]` pairs for each entry.
-
-(Object+, Map, MultiMap, SortedMap, LruMap, SortedArrayMap, FastMap,
-Dict)
-
-### reduce(callback(result, value, key, object, depth), basis, thisp)
-
-(Array, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### reduceRight(callback(result, value, key, object, depth), basis, thisp)
-
-(Array, List, SortedSet, ~~SortedMap~~, SortedArray, SortedArraySet,
-~~SortedArrayMap~~, Heap)
-
-### forEach(callback(value, key, object, depth), thisp)
-
-Calls the callback for each value in the collection.  The iteration
-of lists is resilient to changes to the list.  Particularly, nodes
-added after the current node will be visited and nodes added before
-the current node will be ignored, and no node will be visited twice.
-
-(Array, Object+, Iterator, List, Set, Map, MultiMap, WeakMap,
-SortedSet, SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### map(callback(value, key, object, depth), thisp)
-
-(Array, Object+, Iterator, List, Set, Map, MultiMap, WeakMap,
-SortedSet, SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### toArray()
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### toObject()
-
-Converts any collection to an object, treating this collection as a
-map-like object.  Array is like a map from index to value.
-
-(Array+ Iterator, List, Map, MultiMap, SortedMap, LruMap,
-SortedArrayMap, FastMap, Dict, Heap)
-
-### filter(callback(value, key, object, depth), thisp)
-
-(Array, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### every(callback(value, key, object, depth), thisp)
-
-Whether every value passes a given guard.  Stops evaluating the
-guard after the first failure.  Iterators stop consuming after the
-the first failure.
-
-(Array, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### some(callback(value, key, object, depth), thisp)
-
-Whether there is a value that passes a given guard.  Stops
-evaluating the guard after the first success.  Iterators stop
-consuming after the first success.
-
-(Array, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### any()
-
-Whether any value is truthy.
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### all()
-
-Whether all values are truthy.
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### min()
-
-The smallest value.  This is fast for sorted collections (logarithic
-for SortedSet, constant for SortedArray, SortedArraySet, and
-SortedArrayMap), but slow for everything else (linear).
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict)
-
-### max()
-
-The largest value.  This is fast for sorted collections (logarithic
-for SortedSet, constant for SortedArray, SortedArraySet, and
-SortedArrayMap), but slow for everything else (linear).
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### one()
-
-Any single value, or throws an exception if there are no values.  This
-is very fast (constant time) for most collections.  For a sorted set,
-`set.root.value` is always very fast to access, but changes whenever you
-*access* a value, including using `has` or `find`.  In the interest of
-being consistent across accesses, and only changing in response to
-mutation, `one` returns the `min` of the set in logarithmic time.
-
-(Array+, List, Set, Map, MultiMap, SortedSet, SortedMap, LruSet,
-LruMap, SortedArray, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### only()
-
-The one and only value, or throws an exception if there are no
-values or more than one value.
-
-(Array+, List, Set, Map, MultiMap, SortedSet, SortedMap, LruSet,
-LruMap, SortedArray, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### sum()
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict)
-
-### average()
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict)
-
-### flatten()
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### zip(...collections)
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### enumrate(zero)
-
-(Array+, Iterator, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, SortedArray, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict, Heap)
-
-### clone(depth, memo)
-
-Replicates the collection.  Clones the values deeply, to the
-specified depth, using the memo to resolve reference cycles.  (which
-must the `has` and `set` parts of the Map interface, allowing
-objects for keys)  The default depth is infinite and the default
-memo is a WeakMap.
-
-`Object.clone` can replicate object literals inheriting directly
-from `Object.prototype` or `null`, or any object that implements
-`clone` on its prototype.  Any other object causes `clone` to throw
-an exception.
-
-The `clone` method on any other objects is not intended to be used
-directly since they do not necessarily supply a default depth and
-memo.
-
-(Array+, Object+, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### constructClone(values)
-
-Replicates a collection shallowly.  This is used by each `clone`
-implementation to create a new collection of the same type, with the
-same options (`equals`, `compare`, `hash` options), but it leaves
-the job of deeply cloning the values to the more general `clone`
-method.
-
-(Array+, Object+, List, Set, Map, MultiMap, SortedSet,
-SortedMap, LruSet, LruMap, SortedArray, SortedArraySet,
-SortedArrayMap, FastSet, FastMap, Dict, Heap)
-
-### equals(that, equals)
-
-(Array+, Object+, List, Set, Map, MultiMap, SortedSet, SortedMap,
-LruSet, LruMap, ~~SortedArray~~, SortedArraySet, SortedArrayMap,
-FastSet, FastMap, Dict)
-
-### compare(that)
-
-(Array+, Object+, List, ~~SortedArray~~, ~~SortedArraySet~~)
-
-### iterate
-
-#### iterate()
-
-Produces an iterator with a `next` method.  You may elect to get
-richer iterators by wrapping this iterator with an `Iterator` from
-the `iterator` module.  Iteration order of lists is resilient to
-changes to the list.
-
-(Array+, Iterator, List, Set, SortedSet, LruSet, SortedArray,
-SortedArraySet, FastSet)
-
-#### iterate(start, end)
-
-Returns an iterator for all values at indicies in the half-open
-interval [start, end), that is, greater than start, and less than
-end.
-
-(Array+)
-
-#### iterate(start, end)
-
-Returns an iterator for all values in the half-open interval [start,
-end), that is, greater than start, and less than end.  The iterator
-is resilient against changes to the data.
-
-(SortedSet)
-
-### log(charmap, callback(node, write, writeAbove), log, logger)
-
-Writes a tree describing the internal state of the data structure to
-the console.
-
-`charmap` is an object that notes which characters to use to draw
-lines.  By default, this is the `TreeLog.unicodeRound` property from the
-`tree-log` module.  `TreeLog.unicodeSharp` and `TreeLog.ascii` are
-alternatives.  The properties are:
-
--   intersection: ╋
--   through: ━
--   branchUp: ┻
--   branchDown: ┳
--   fromBelow: ╭
--   fromAbove: ╰
--   fromBoth: ┣
--   strafe: ┃
-
-`callback` is a customizable function for rendering each node of the tree.
-By default, it just writes the value of the node.  It accepts the node and
-a writer functions.  The `write` function produces the line on which the
-node joins the tree, and each subsequent line.  The `writeAbove` function
-can write lines before the branch.
-
-`log` and `logger` default to `console.log` and `console`.  To write
-the representation to an array instead, they can be `array.push` and
-`array`.
-
-(SortedSet)
-
-
-### Iterator
-
-#### dropWhile(callback(value, index, iterator), thisp)
-
-#### takeWhile(callback(value, index, iterator), thisp)
-
-#### mapIterator(callback(value, index, iterator))
-
-Returns an iterator for a mapping on the source values.  Values are
-consumed on demand.
-
-#### filterIterator(callback(value, index, iterator))
-
-Returns an iterator for those values from the source that pass the
-given guard.  Values are consumed on demand.
-
-#### zipIterator(...iterables)
-
-Returns an iterator that incrementally combines the respective
-values of the given iterations.
-
-#### enumerateIterator(start = 0)
-
-Returns an iterator that provides [index, value] pairs from the
-source iteration.
-
-
-### Iterator utilities
-
-#### cycle(iterable, times)
-
-#### concat(iterables)
-
-#### transpose(iterables)
-
-#### zip(...iterables)
-
-Variadic transpose.
-
-#### chain(...iterables)
-
-Variadic concat.
-
-#### range(start, stop, step)
-
-Iterates from start to stop by step.
-
-#### count(start, step)
-
-Iterates from start by step, indefinitely.
-
-#### repeat(value, times)
-
-Repeats the given value either finite times or indefinitely.
-
-
-## Change Listeners
-
-All collections support change listeners.  There are three types of
-changes.  Property changes, map changes, and range changes.
-
-### Property Changes
-
-`PropertyChanges` from the `listen/property-changes` module can
-configure listeners for property changes to specific keys of any object.
-
-With the `listen/array-changes` module required, `PropertyChanges` can
-also listen to changes to the length and indexed properties of an array.
-The only caveat is that watched arrays can only modify their contents
-with method calls like `array.push`.  All methods of a watched array
-support change dispatch.  In addition, arrays have a `set` method to
-make setting the value at a particular index observable.
-
--   PropertyChanges.addOwnPropertyChangeListener(object, key, listener, before)
--   PropertyChanges.removeOwnPropertyChangeListener(object, key, listener, before)
--   PropertyChanges.dispatchOwnPropertyChange(object, key, value, before)
--   PropertyChanges.addBeforeOwnPropertyChangeListener(object, key, listener)
--   PropertyChanges.removeBeforeOwnPropertyChangeListener(object, key, listener)
--   PropertyChanges.dispatchBeforeOwnPropertyChange(object, key, value)
--   PropertyChanges.getOwnPropertyChangeDescriptor(object, key)
-
-All of these functions delegate to methods of the same name if one
-exists on the object.
-
--   object.addOwnPropertyChangeListener(key, listener, before)
--   object.removeOwnPropertyChangeListener(key, listener, before)
--   object.dispatchOwnPropertyChange(key, value, before)
--   object.addBeforeOwnPropertyChangeListener(key, listener)
--   object.removeBeforeOwnPropertyChangeListener(key, listener)
--   object.dispatchBeforeOwnPropertyChange(key, value)
--   object.getOwnPropertyChangeDescriptor(key)
-
-Additionally, `PropertyChanges.prototype` can be **mixed into** other
-types of objects to support the property change dispatch interface.  All
-collections support this interface.
-
-The **listener** for a property change receives the arguments `value`,
-`key`, and `object`, just as a `forEach` or `map` callback.  The
-listener may alternately be a delegate object that implements one of
-these methods:
-
--   listener.handle + **key** + Change **or** WillChange
--   listener.handleProperty + Change **or** WillChange
--   listener.call
-
-### Map Changes
-
-A map change listener receives notifications for the creation, removal,
-or updates for any entry in a map data structure.
-
-With the `listen/array-changes` module required, `Array` can also
-dispatch map changes for the values at each index.
-
--   collection.addMapChangeListener(listener, token, before)
--   collection.removeMapChangeListener(listener, token, before)
--   collection.dispatchMapChange(key, value, before)
--   collection.addBeforeMapChangeListener(listener)
--   collection.removeBeforeMapChangeListener(listener)
--   collection.dispatchBeforeMapChange(key, value)
--   collection.getMapChangeDescriptor()
-
-The **listener** for a map change receives the `value`, `key`, and
-collection `object` as arguments, the same pattern as a `forEach` or
-`map` callback.  In the after change phase, a value of `undefined` may
-indicate that the value was deleted or set to `undefined`.  In the
-before change phase, a value of `undefined` may indicate the the value
-was added or was previously `undefined`.
-
-The listener may be a delegate object with one of the following methods,
-in order of precedence:
-
--   listener.handleMap + Change **or** WillChange
--   listener.handle + **token** + Map + Change **or** WillChange
--   listener.call
-
-The `listen/map-changes` module exports a map changes **mixin**.  The
-methods of `MaxChanges.prototype` can be copied to any collection that
-needs this interface.  Its mutation methods will then need to dispatch
-map changes.
-
-### Range Changes
-
-A range change listener receives notifications when a range of values at
-a particular position is added, removed, or replaced within an ordered
-collection.
-
--   collection.**add**RangeChange**Listener**(listener, token, before)
--   collection.**remove**RangeChange**Listener**(listener, token, before)
--   collection.**dispatch**RangeChange(plus, minus, index, before)
--   collection.add**Before**RangeChange**Listener**(listener)
--   collection.remove**Before**RangeChange**Listener**(listener)
--   collection.dispatch**Before**RangeChange(plus, minus, index)
--   collection.**get**RangeChange**Descriptor**()
-
-The **listener** for a range change is a function that accepts `plus`,
-`minus`, and `index` arguments.  `plus` and `minus` are the values that
-were added or removed at the `index`.  Whatever operation caused these
-changes is equivalent to:
-
-```javascript
-var minus = collection.splice(index, minus.length, ...plus)
-```
-
-The listener can alternately be a delegate object with one of the
-following methods in order of precedence:
-
--   handle + **token** + Range + Change **or** WillChange
--   handleRange + Change **or** WillChange
--   call
-
-The following support range change dispatch:
-
--   `Array` with `require("collections/listen/array-changes")`
--   `SortedSet`
--   `SortedArray`
--   `SortedArraySet`
-
-The `listen/range-changes` module exports a range changes **mixin**.
-The methods of `RangeChanges.prototype` can be copied to any collection
-that needs this interface.  Its mutation methods will need to dispatch
-the range changes.
-
-All **descriptors** are objects with the properties `changeListeners`
-and `willChangeListeners`.  Both are arrays of listener functions or
-objects, in the order in which they were added.
-
-
-## Miscellanea
-
-### Set and Map
-
-Set and map are like hash tables, but not implemented with a block of
-memory as they would be in a lower-level language.  Most of the work of
-providing fast insertion and lookup based on a hash is performed by the
-underlying plain JavaScript object.  Each key of the object is a hash
-string and each value is a List of values with that hash.  The inner
-list resolves collisions.  With a good `hash` method, the use of the
-list can be avoided.
-
-Sets and maps both have a `log` function that displays the internal
-structure of the bucket list in an NPM-style.
-
-```
-┣━┳ 1
-┃ ┗━━ {"key":1,"value":"a"}
-┣━┳ 2
-┃ ┣━━ {"key":2,"value":"c"}
-┃ ┗━━ {"key":2,"value":"d"}
-┗━┳ 3
-  ┗━━ {"key":3,"value":"b"}
-```
-
-
-### Sorted Set and Sorted Map
-
-A binary splay tree is a balanced binary tree that rotates the most
-frequently used entries toward the root such that they can be accessed the
-most quickly.  `sorted-set` and `sorted-map` are backed by a splay tree.
-
-All map implementations use an underlying set implementation.  Any map
-can be implemented trivially atop a set by wrapping `compare`, `equals`,
-or `hash` to operate on the key of an entry.
-
-The sorted set has a `root` node.  Each node has a `left` and `right`
-property, which may be null.  Nodes are returned by all of the "find"
-functions, and provided as the `key` argument to callbacks.
-
-Both `sorted-set` and `sorted-map` implement a `log` function which can
-produce NPM-style visualizations of the internal state of the sorted
-tree.
-
-```
-> set.log(SortedSet.ascii)
-  .-+ -3
-  | '-- -2
-.-+ -1
-+ 0
-| .-- 1
-'-+ 2
-  '-- 3
-```
-
-```
-> set.log(SortedSet.unicodeRound)
-  ╭━┳ -3
-  ┃ ╰━━ -2
-╭━┻ -1
-╋ 0
-┃ ╭━┳ 1
-┃ ┃ ╰━━ 2
-╰━┻ 3
-```
-
-
-### Object and Function Shims
-
-The collection methods on the `Object` constructor all polymorphically
-delegate to the corresponding method of any object that implements the
-method of the same name.  So, `Object.has` can be used to check whether
-a key exists on an object, or in any collection that implements `has`.
-This permits the `Object` interface to be agnostic of the input type.
-
-`Array.from` creates an array from any iterable.
-
-`Array.unzip` transposes a collection of arrays, so rows become columns.
-
-`Array.empty` is an empty array, frozen if possible.  Do not modify it.
-
-`Object.from` creates an object from any map or collection.  For arrays
-and array-like collections, uses the index for the key.
-
-`Object.empty` is an empty object literal.
-
-`Object.isObject(value)` tests whether it is safe to attempt to access
-properties of a given value.
-
-`Object.is(x, y)` compares objects for exact identity and is a good
-alternative to `Object.equals` in many collections.
-
-`Object.getValueOf(value)` safely and idempotently returns the value of
-an object or value by only calling the `valueOf()` if the value
-implements that method.
-
-`Object.owns` is a shorthand for `Object.prototype.hasOwnProperty.call`.
-
-`Object.can(value, name)` checks whether an object implements a method
-on its prototype chain.  An owned function property does not qualify as
-a method, to aid in distinguishing "static" functions.
-
-`Object.concat(...maps)` and `Object.from(entries)` construct an object
-by adding the entries of other objects in order.  The maps can be other
-objects, arrays of entries, or map alike collections.
-
-`Function.noop` is returns undefined.
-
-`Function.identity` returns its first argument.
-
-`Function.by(relation)` creates a comparator from a relation function.
-
-`Function.get(key)` creates a relation that returns the value for the
-property of a given object.
-
-
-### References
-
-- a SplayTree impementation buried in Fedor Indutny’s super-secret
-  [Callgrind](https://github.com/indutny/callgrind.js). This
-  implementation uses parent references.
-- a SplayTree implementation adapted by [Paolo
-  Fragomeni](https://github.com/hij1nx/forest) from the V8 project and
-  based on the top-down splaying algorithm from "Self-adjusting Binary
-  Search Trees" by Sleator and Tarjan. This does not use or require
-  parent references, so I favored it over Fedor Indutny’s style.
-- the interface of ECMAScript harmony [simple maps and
-  sets](http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets)
-- a SplayTree implementation from [JavaScript data
-  structures](derrickburns/Javascript-Data-Structures) mainted by
-  Derrick Burns that supports change-resilient iterators and a
-  comprehensive set of introspection functions.
-
-### Future work
-
-Goals
-
-- make array dispatch length property changes between range changes to
-  be consistent with List.
-- automate the generation of the method support tables in readme and
-  normalize declaration order
-- comprehensive specs and spec coverage tests
-- array set (a set, for fast lookup, backed by an array for meaningful
-  range changes)
-- fast list splicing
-- dict map changes
-- revise map changes to use separate handlers for add/delete
-- revise tokens for range and map changes to specify complete alternate
-  delegate methods, particularly for forwarding directly to dispatch
-- implement on/once/off listeners
-- Make it easier to created a SortedSet with a criterion like
-  Function.by(Function.get('name'))
-- evaluate exposing observeProperty, observeRangeChange, and observeMapChange
-  instead of the aEL/rEL inspired API FRB exposes today, to minimize
-  book-keeping and garbage collection
-
-More possible collections
-
-- sorted-list (sorted, can contain duplicates, perhaps backed by splay
-  tree with relaxation on the uniqueness invariant)
-- sorted-multi-map (sorted, can contain duplicate entries)
-- buffer (backed by a circular array, emits cull events)
-- emit cull events in LRU cache set and map
-- trie-set
-- trie-map
-- immutable-* (mutation functions return new objects that largely share
-  the previous version's internal state, some perhaps backed by a hash
-  trie)
-