node_modules

20 files changed, 2128 insertions, 0 deletions

diff --git a/node_modules/utila/scripts/coffee/lib/Emitter.coffee b/node_modules/utila/scripts/coffee/lib/Emitter.coffee
new file mode 100644
index 000000000..585a924ed
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/Emitter.coffee
@@ -0,0 +1,145 @@
+array = require './array'

+

+module.exports = class Emitter

+

+	constructor: ->

+

+		@_listeners = {}

+

+		@_listenersForAnyEvent = []

+

+		@_disabledEmitters = {}

+

+	on: (eventName, listener) ->

+

+		unless @_listeners[eventName]?

+

+			@_listeners[eventName] = []

+

+		@_listeners[eventName].push listener

+

+		@

+

+	once: (eventName, listener) ->

+

+		ran = no

+

+		cb = =>

+

+			return if ran

+

+			ran = yes

+

+			do listener

+

+			setTimeout =>

+

+				@removeEvent eventName, cb

+

+			, 0

+

+		@on eventName, cb

+

+		@

+

+	onAnyEvent: (listener) ->

+

+		@_listenersForAnyEvent.push listener

+

+		@

+

+	removeEvent: (eventName, listener) ->

+

+		return @ unless @_listeners[eventName]?

+

+		array.pluckOneItem @_listeners[eventName], listener

+

+		@

+

+	removeListeners: (eventName) ->

+

+		return @ unless @_listeners[eventName]?

+

+		@_listeners[eventName].length = 0

+

+		@

+

+	removeAllListeners: ->

+

+		for name, listeners of @_listeners

+

+			listeners.length = 0

+

+		@

+

+	_emit: (eventName, data) ->

+

+		for listener in @_listenersForAnyEvent

+

+			listener.call @, data, eventName

+

+		return unless @_listeners[eventName]?

+

+		for listener in @_listeners[eventName]

+

+			listener.call @, data

+

+		return

+

+	# this makes sure that all the calls to this class's method 'fnName'

+	# are throttled

+	_throttleEmitterMethod: (fnName, time = 1000) ->

+

+		originalFn = @[fnName]

+

+		if typeof originalFn isnt 'function'

+

+			throw Error "this class does not have a method called '#{fnName}'"

+

+		lastCallArgs = null

+		pending = no

+		timer = null

+

+		@[fnName] = =>

+

+			lastCallArgs = arguments

+

+			do pend

+

+		pend = =>

+

+			if pending

+

+				clearTimeout timer

+

+			timer = setTimeout runIt, time

+

+			pending = yes

+

+		runIt = =>

+

+			pending = no

+

+			originalFn.apply @, lastCallArgs

+

+	_disableEmitter: (fnName) ->

+

+		if @_disabledEmitters[fnName]?

+

+			throw Error "#{fnName} is already a disabled emitter"

+

+		@_disabledEmitters[fnName] = @[fnName]

+

+		@[fnName] = ->

+

+	_enableEmitter: (fnName) ->

+

+		fn = @_disabledEmitters[fnName]

+

+		unless fn?

+

+			throw Error "#{fnName} is not a disabled emitter"

+

+		@[fnName] = fn

+

+		delete @_disabledEmitters[fnName]
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/_common.coffee b/node_modules/utila/scripts/coffee/lib/_common.coffee
new file mode 100644
index 000000000..b120937f4
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/_common.coffee
@@ -0,0 +1,99 @@
+module.exports = common =
+
+	###
+	Checks to see if o is an object, and it isn't an instance
+	of some class.
+	###
+	isBareObject: (o) ->
+
+		if o? and o.constructor is Object
+
+			return true
+
+		false
+
+	###
+	Returns type of an object, including:
+	undefined, null, string, number, array,
+	arguments, element, textnode, whitespace, and object
+	###
+	typeOf: (item) ->
+
+		return 'null' if item is null
+
+		return typeof item if typeof item isnt 'object'
+
+		return 'array' if Array.isArray item
+
+		# From MooTools
+		# - do we even need this?
+		if item.nodeName
+
+			if item.nodeType is 1 then return 'element'
+			if item.nodeType is 3 then return (/\S/).test(item.nodeValue) ? 'textnode' : 'whitespace'
+
+		else if typeof item.length is 'number'
+
+			if item.callee then return 'arguments'
+
+		return typeof item
+
+	# Deep clone of any variable.
+	# From MooTools
+	clone: (item, includePrototype = false) ->
+
+		switch common.typeOf item
+
+			when 'array' then return common._cloneArray item, includePrototype
+
+			when 'object' then return common._cloneObject item, includePrototype
+
+			else return item
+
+	###
+	Deep clone of an object.
+	From MooTools
+	###
+	_cloneObject: (o, includePrototype = false) ->
+
+		if common.isBareObject o
+
+			clone = {}
+
+			for key of o
+
+				clone[key] = common.clone o[key], includePrototype
+
+			return clone
+
+		else
+
+			return o unless includePrototype
+
+			return o if o instanceof Function
+
+			clone = Object.create o.constructor.prototype
+
+			for key of o
+
+				if o.hasOwnProperty key
+
+					clone[key] = common.clone o[key], includePrototype
+
+			clone
+
+	###
+	Deep clone of an array.
+	From MooTools
+	###
+	_cloneArray: (a, includePrototype = false) ->
+
+		i = a.length
+
+		clone = new Array i
+
+		while i--
+
+			clone[i] = common.clone a[i], includePrototype
+
+		clone
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/array.coffee b/node_modules/utila/scripts/coffee/lib/array.coffee
new file mode 100644
index 000000000..429bf6dc6
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/array.coffee
@@ -0,0 +1,186 @@
+module.exports = array =
+
+	###
+	Tries to turn anything into an array.
+	###
+	from: (r) ->
+
+		Array::slice.call r
+
+	###
+	Clone of an array. Properties will be shallow copies.
+	###
+	simpleClone: (a) ->
+
+		a.slice 0
+
+	shallowEqual: (a1, a2) ->
+
+		return no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length
+
+		for val, i in a1
+
+			return no unless a2[i] is val
+
+		yes
+
+	pluck: (a, i) ->
+
+		return a if a.length < 1
+
+
+		for value, index in a
+
+			if index > i
+
+				a[index - 1] = a[index]
+
+		a.length = a.length - 1
+
+		a
+
+	pluckItem: (a, item) ->
+
+		return a if a.length < 1
+
+
+		removed = 0
+
+		for value, index in a
+
+			if value is item
+
+				removed++
+
+				continue
+
+			if removed isnt 0
+
+				a[index - removed] = a[index]
+
+		a.length = a.length - removed if removed > 0
+
+		a
+
+	pluckOneItem: (a, item) ->
+
+		return a if a.length < 1
+
+		reached = no
+
+		for value, index in a
+
+			if not reached
+
+				if value is item
+
+					reached = yes
+
+					continue
+
+			else
+
+				a[index - 1] = a[index]
+
+		a.length = a.length - 1 if reached
+
+		a
+
+	pluckByCallback: (a, cb) ->
+
+		return a if a.length < 1
+
+		removed = 0
+
+		for value, index in a
+
+			if cb value, index
+
+				removed++
+
+				continue
+
+			if removed isnt 0
+
+				a[index - removed] = a[index]
+
+		if removed > 0
+
+			a.length = a.length - removed
+
+		a
+
+	pluckMultiple: (array, indexesToRemove) ->
+
+		return array if array.length < 1
+
+		removedSoFar = 0
+
+		indexesToRemove.sort()
+
+		for i in indexesToRemove
+
+			@pluck array, i - removedSoFar
+
+			removedSoFar++
+
+		array
+
+	injectByCallback: (a, toInject, shouldInject) ->
+
+		valA = null
+
+		valB = null
+
+		len = a.length
+
+		if len < 1
+
+			a.push toInject
+
+			return a
+
+
+		for val, i in a
+
+			valA = valB
+
+			valB = val
+
+			if shouldInject valA, valB, toInject
+
+				return a.splice i, 0, toInject
+
+		a.push toInject
+
+		a
+
+	injectInIndex: (a, index, toInject) ->
+
+		len = a.length
+
+		i = index
+
+		if len < 1
+
+			a.push toInject
+
+			return a
+
+		toPut = toInject
+
+		toPutNext = null
+
+		`for(; i <= len; i++){
+
+			toPutNext = a[i];
+
+			a[i] = toPut;
+
+			toPut = toPutNext;
+
+		}`
+
+		# a[i] = toPut
+
+		null
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/classic.coffee b/node_modules/utila/scripts/coffee/lib/classic.coffee
new file mode 100644
index 000000000..5b3f9c82e
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/classic.coffee
@@ -0,0 +1,87 @@
+module.exports = classic = {}
+
+# Little helper for mixins from CoffeeScript FAQ,
+# courtesy of Sethaurus (http://github.com/sethaurus)
+classic.implement = (mixins..., classReference) ->
+
+	for mixin in mixins
+
+		classProto = classReference::
+
+		for member of mixin::
+
+			unless Object.getOwnPropertyDescriptor classProto, member
+
+				desc = Object.getOwnPropertyDescriptor mixin::, member
+
+				Object.defineProperty classProto, member, desc
+
+	classReference
+
+classic.mix = (mixins..., classReference) ->
+
+	classProto = classReference::
+
+	classReference.__mixinCloners = []
+
+	classReference.__applyClonersFor = (instance, args = null) ->
+
+		for cloner in classReference.__mixinCloners
+
+			cloner.apply instance, args
+
+		return
+
+	classReference.__mixinInitializers = []
+
+	classReference.__initMixinsFor = (instance, args = null) ->
+
+		for initializer in classReference.__mixinInitializers
+
+			initializer.apply instance, args
+
+		return
+
+	classReference.__mixinQuitters = []
+
+	classReference.__applyQuittersFor = (instance, args = null) ->
+
+		for quitter in classReference.__mixinQuitters
+
+			quitter.apply instance, args
+
+		return
+
+	for mixin in mixins
+
+		unless mixin.constructor instanceof Function
+
+			throw Error "Mixin should be a function"
+
+		for member of mixin::
+
+			if member.substr(0, 11) is '__initMixin'
+
+				classReference.__mixinInitializers.push mixin::[member]
+
+				continue
+
+			else if member.substr(0, 11) is '__clonerFor'
+
+				classReference.__mixinCloners.push mixin::[member]
+
+				continue
+
+			else if member.substr(0, 12) is '__quitterFor'
+
+				classReference.__mixinQuitters.push mixin::[member]
+
+				continue
+
+			unless Object.getOwnPropertyDescriptor classProto, member
+
+				desc = Object.getOwnPropertyDescriptor mixin::, member
+
+				Object.defineProperty classProto, member, desc
+
+	classReference
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/object.coffee b/node_modules/utila/scripts/coffee/lib/object.coffee
new file mode 100644
index 000000000..79977b3ac
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/object.coffee
@@ -0,0 +1,170 @@
+_common = require './_common'
+
+module.exports = object =
+
+	isBareObject: _common.isBareObject.bind _common
+
+	###
+	if object is an instance of a class
+	###
+	isInstance: (what) ->
+
+		not @isBareObject what
+
+	###
+	Alias to _common.typeOf
+	###
+	typeOf: _common.typeOf.bind _common
+
+	###
+	Alias to _common.clone
+	###
+	clone: _common.clone.bind _common
+
+	###
+	Empties an object of its properties.
+	###
+	empty: (o) ->
+
+		for prop of o
+
+			delete o[prop] if o.hasOwnProperty prop
+
+		o
+
+	###
+	Empties an object. Doesn't check for hasOwnProperty, so it's a tiny
+	bit faster. Use it for plain objects.
+	###
+	fastEmpty: (o) ->
+
+		delete o[property] for property of o
+
+		o
+
+	###
+	Overrides values fomr `newValues` on `base`, as long as they
+	already exist in base.
+	###
+	overrideOnto: (base, newValues) ->
+
+		return base if not @isBareObject(newValues) or not @isBareObject(base)
+
+		for key, oldVal of base
+
+			newVal = newValues[key]
+
+			continue if newVal is undefined
+
+			if typeof newVal isnt 'object' or @isInstance newVal
+
+				base[key] = @clone newVal
+
+			# newVal is a plain object
+			else
+
+				if typeof oldVal isnt 'object' or @isInstance oldVal
+
+					base[key] = @clone newVal
+
+				else
+
+					@overrideOnto oldVal, newVal
+		base
+
+	###
+	Takes a clone of 'base' and runs #overrideOnto on it
+	###
+	override: (base, newValues) ->
+
+		@overrideOnto @clone(base), newValues
+
+	append: (base, toAppend) ->
+
+		@appendOnto @clone(base), toAppend
+
+	# Deep appends values from `toAppend` to `base`
+	appendOnto: (base, toAppend) ->
+
+		return base if not @isBareObject(toAppend) or not @isBareObject(base)
+
+		for own key, newVal of toAppend
+
+			continue unless newVal isnt undefined
+
+			if typeof newVal isnt 'object' or @isInstance newVal
+
+				base[key] = newVal
+
+			else
+
+				# newVal is a bare object
+
+				oldVal = base[key]
+
+				if typeof oldVal isnt 'object' or @isInstance oldVal
+
+					base[key] = @clone newVal
+
+				else
+
+					@appendOnto oldVal, newVal
+
+		base
+
+	# Groups
+	groupProps: (obj, groups) ->
+
+		grouped = {}
+
+		for name, defs of groups
+
+			grouped[name] = {}
+
+		grouped['rest'] = {}
+
+		`top: //`
+		for key, val of obj
+
+			shouldAdd = no
+
+			for name, defs of groups
+
+				unless Array.isArray defs
+
+					defs = [defs]
+
+				for def in defs
+
+					if typeof def is 'string'
+
+						if key is def
+
+							shouldAdd = yes
+
+					else if def instanceof RegExp
+
+						if def.test key
+
+							shouldAdd = yes
+
+					else if def instanceof Function
+
+						if def key
+
+							shouldAdd = yes
+
+					else
+
+						throw Error 'Group definitions must either
+						be strings, regexes, or functions.'
+
+					if shouldAdd
+
+						grouped[name][key] = val
+
+						`continue top`
+
+			grouped['rest'][key] = val
+
+		grouped
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/string.coffee b/node_modules/utila/scripts/coffee/lib/string.coffee
new file mode 100644
index 000000000..9515c648f
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/string.coffee
@@ -0,0 +1,16 @@
+module.exports =

+

+	# pads a number with leading zeroes

+	#

+	# http://stackoverflow.com/a/10073788/607997

+	pad: (n, width, z = '0') ->

+

+		n = n + ''

+

+		if n.length >= width

+

+			n

+

+		else

+

+			new Array(width - n.length + 1).join(z) + n
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/lib/utila.coffee b/node_modules/utila/scripts/coffee/lib/utila.coffee
new file mode 100644
index 000000000..5d68529e4
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/lib/utila.coffee
@@ -0,0 +1,7 @@
+module.exports = utila =
+
+	array: require './array'
+	classic: require './classic'
+	object: require './object'
+	string: require './string'
+	Emitter: require './Emitter'
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/test/_prepare.coffee b/node_modules/utila/scripts/coffee/test/_prepare.coffee
new file mode 100644
index 000000000..b602a464e
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/test/_prepare.coffee
@@ -0,0 +1,5 @@
+path = require 'path'
+
+pathToLib = path.resolve __dirname, '../lib'
+
+require('little-popo')(pathToLib)
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/test/array.coffee b/node_modules/utila/scripts/coffee/test/array.coffee
new file mode 100644
index 000000000..a244861be
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/test/array.coffee
@@ -0,0 +1,143 @@
+require './_prepare'
+
+array = mod 'array'
+
+test 'from', ->
+
+	array.from([1]).should.be.an.instanceOf Array
+	array.from([1])[0].should.equal 1
+
+# test 'clone', ->
+
+# 	a = [0, 1, 2]
+
+# 	b = array.clone a
+
+# 	b[0].should.equal 0
+# 	b[1].should.equal 1
+
+# 	b[0] = 3
+
+# 	a[0].should.equal 0
+
+test 'pluck', ->
+
+	a = [0, 1, 2, 3]
+
+	after = array.pluck a, 1
+
+	after.length.should.equal 3
+
+	after[0].should.equal 0
+	after[1].should.equal 2
+	after[2].should.equal 3
+	after.should.equal a
+
+test 'pluckMultiple', ->
+
+	a = [0, 1, 2, 3, 4, 5, 6]
+
+	array.pluckMultiple a, [0, 4, 2, 6]
+
+	a.length.should.equal 3
+	a[0].should.equal 1
+	a[1].should.equal 3
+	a[2].should.equal 5
+
+test 'pluckItem', ->
+
+	a = [0, 1, 2, 3, 2, 4, 2]
+
+	array.pluckItem a, 2
+
+	a[0].should.equal 0
+	a[1].should.equal 1
+	a[2].should.equal 3
+	a[3].should.equal 4
+
+	array.pluckItem([1], 2).length.should.equal 1
+
+
+test 'pluckOneItem', ->
+
+	a = [0, 1, 2, 3, 2, 4, 2]
+
+	array.pluckOneItem a, 2
+
+	a[0].should.equal 0
+	a[1].should.equal 1
+	a[2].should.equal 3
+	a[3].should.equal 2
+	a[4].should.equal 4
+	a[5].should.equal 2
+
+	a = [1, 2]
+
+	array.pluckOneItem a, 1
+
+	a.length.should.equal 1
+	a[0].should.equal 2
+
+	array.pluckOneItem([], 1).length.should.equal 0
+
+	array.pluckOneItem([1], 2).length.should.equal 1
+
+test 'plcukByCallback', ->
+
+	a = [0, 1, 2, 3]
+
+	array.pluckByCallback a, (val, i) ->
+
+		return yes if val is 2
+
+		return no
+
+	a[0].should.equal 0
+	a[1].should.equal 1
+	a[2].should.equal 3
+
+test 'injectByCallback', ->
+
+	shouldInject = (valA, valB, toInject) ->
+
+		unless valA?
+
+			return yes if toInject <= valB
+
+			return no
+
+		unless valB?
+
+			return yes if valA <= toInject
+
+			return no
+
+		return yes if valA <= toInject <= valB
+
+		return no
+
+	a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]
+
+	array.injectByCallback a, 0, shouldInject
+
+	a[0].should.equal 0
+	a[1].should.equal 0.5
+	a[7].should.equal 3
+
+	a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]
+
+	array.injectByCallback a, 2.7, shouldInject
+
+	a[0].should.equal 0.5
+	a[4].should.equal 2.7
+	a[5].should.equal 2.75
+	a[7].should.equal 3
+
+	a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]
+
+	array.injectByCallback a, 3.2, shouldInject
+
+	a[0].should.equal 0.5
+	a[4].should.equal 2.75
+	a[6].should.equal 3
+	a[7].should.equal 3.2
\ No newline at end of file
diff --git a/node_modules/utila/scripts/coffee/test/object.coffee b/node_modules/utila/scripts/coffee/test/object.coffee
new file mode 100644
index 000000000..e36140c8d
--- /dev/null
+++ b/node_modules/utila/scripts/coffee/test/object.coffee
@@ -0,0 +1,233 @@
+require './_prepare'
+
+object = mod 'object'
+
+test 'isBareObject', ->
+
+	object.isBareObject('a').should.equal false
+
+	object.isBareObject({'a': 'a'}).should.equal true
+
+test 'typeOf', ->
+
+	object.typeOf('s').should.equal 'string'
+	object.typeOf(0).should.equal 'number'
+	object.typeOf(false).should.equal 'boolean'
+	object.typeOf({}).should.equal 'object'
+	object.typeOf(arguments).should.equal 'arguments'
+	object.typeOf([]).should.equal 'array'
+
+test 'empty', ->
+
+	o =
+
+		a: 1
+		b: 2
+
+
+	object.empty o
+
+	o.should.not.have.property 'a'
+	o.should.not.have.property 'b'
+
+test 'fastEmpty', ->
+
+	o =
+		a: 1
+		b: 2
+
+
+	object.fastEmpty o
+
+	o.should.not.have.property 'a'
+	o.should.not.have.property 'b'
+
+test 'clone', ->
+
+	object.clone([1])[0].should.equal 1
+	object.clone({a:1}).a.should.equal 1
+
+	o = {a: 1}
+
+	object.clone(o).should.not.equal o
+
+test 'clone [include prototype]', ->
+
+	class C
+
+		constructor: (@a) ->
+
+		sayA: -> @a + 'a'
+
+	a = new C 'a'
+
+	a.sayA().should.equal 'aa'
+
+	b = object.clone a, yes
+
+	b.should.not.equal a
+
+	b.constructor.should.equal C
+
+	b.a.should.equal 'a'
+
+	b.a = 'a2'
+
+	b.sayA().should.equal 'a2a'
+
+test 'clone [without prototype]', ->
+
+	class C
+
+		constructor: (@a) ->
+
+		sayA: -> @a + 'a'
+
+	a = new C 'a'
+
+	a.sayA().should.equal 'aa'
+
+	b = object.clone a, no
+
+	b.should.equal a
+
+test 'overrideOnto [basic]', ->
+
+	onto =
+		a: 'a'
+		b:
+			c: 'c'
+			d:
+				e: 'e'
+
+	what =
+		a: 'a2'
+		b:
+			c: 'c2'
+			d:
+				f: 'f2'
+
+	object.overrideOnto onto, what
+
+	onto.a.should.equal 'a2'
+	onto.b.should.have.property 'c'
+	onto.b.c.should.equal 'c2'
+	onto.b.d.should.not.have.property 'f'
+	onto.b.d.e.should.equal 'e'
+
+test 'override', ->
+
+	onto =
+
+		a: 'a'
+
+		b:
+
+			c: 'c'
+
+			d:
+
+				e: 'e'
+
+	what =
+
+		a: 'a2'
+
+		b:
+
+			c: 'c2'
+
+			d:
+
+				f: 'f2'
+
+
+	onto2 = object.override onto, what
+
+	onto2.a.should.equal 'a2'
+	onto2.b.should.have.property 'c'
+	onto2.b.c.should.equal 'c2'
+	onto2.b.d.should.not.have.property 'f'
+	onto2.b.d.e.should.equal 'e'
+
+	onto.should.not.equal onto2
+
+do ->
+
+	what =
+
+		a: 'a2'
+
+		c: ->
+
+		z: 'z'
+
+		y:
+
+			a: 'a'
+
+	onto =
+
+		a: 'a'
+
+		b: 'b'
+
+	test 'appendOnto [basic]', ->
+
+		object.appendOnto onto, what
+
+		onto.a.should.equal 'a2'
+		onto.b.should.equal 'b'
+		onto.z.should.equal 'z'
+
+	test "appendOnto [shallow copies instances]", ->
+
+		onto.c.should.be.instanceof Function
+		onto.c.should.equal what.c
+
+
+	test "appendOnto [clones objects]", ->
+
+		onto.should.have.property 'y'
+		onto.y.a.should.equal 'a'
+		onto.y.should.not.equal what.y
+
+test 'groupProps', ->
+
+	obj =
+
+		a1: '1'
+		a2: '2'
+
+		b1: '1'
+		b2: '2'
+
+		c1: '1'
+		c2: '2'
+
+		rest1: '1'
+		rest2: '2'
+
+	groups = object.groupProps obj,
+
+		a: ['a1', 'a2']
+
+		b: [/^b[0-9]+$/]
+
+		c: (key) -> key[0] is 'c'
+
+	groups.a.should.have.property 'a1'
+	groups.a.a1.should.equal '1'
+
+	groups.a.should.have.property 'a2'
+
+	groups.b.should.have.property 'b1'
+	groups.b.should.have.property 'b2'
+
+	groups.c.should.have.property 'c1'
+	groups.c.should.have.property 'c2'
+
+	groups.rest.should.have.property 'rest1'
+	groups.rest.should.have.property 'rest1'
+
+	groups.rest.should.not.have.property 'c1'
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/Emitter.js b/node_modules/utila/scripts/js/lib/Emitter.js
new file mode 100644
index 000000000..8386c819c
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/Emitter.js
@@ -0,0 +1,144 @@
+var Emitter, array;
+
+array = require('./array');
+
+module.exports = Emitter = (function() {
+  function Emitter() {
+    this._listeners = {};
+    this._listenersForAnyEvent = [];
+    this._disabledEmitters = {};
+  }
+
+  Emitter.prototype.on = function(eventName, listener) {
+    if (this._listeners[eventName] == null) {
+      this._listeners[eventName] = [];
+    }
+    this._listeners[eventName].push(listener);
+    return this;
+  };
+
+  Emitter.prototype.once = function(eventName, listener) {
+    var cb, ran;
+    ran = false;
+    cb = (function(_this) {
+      return function() {
+        if (ran) {
+          return;
+        }
+        ran = true;
+        listener();
+        return setTimeout(function() {
+          return _this.removeEvent(eventName, cb);
+        }, 0);
+      };
+    })(this);
+    this.on(eventName, cb);
+    return this;
+  };
+
+  Emitter.prototype.onAnyEvent = function(listener) {
+    this._listenersForAnyEvent.push(listener);
+    return this;
+  };
+
+  Emitter.prototype.removeEvent = function(eventName, listener) {
+    if (this._listeners[eventName] == null) {
+      return this;
+    }
+    array.pluckOneItem(this._listeners[eventName], listener);
+    return this;
+  };
+
+  Emitter.prototype.removeListeners = function(eventName) {
+    if (this._listeners[eventName] == null) {
+      return this;
+    }
+    this._listeners[eventName].length = 0;
+    return this;
+  };
+
+  Emitter.prototype.removeAllListeners = function() {
+    var listeners, name, _ref;
+    _ref = this._listeners;
+    for (name in _ref) {
+      listeners = _ref[name];
+      listeners.length = 0;
+    }
+    return this;
+  };
+
+  Emitter.prototype._emit = function(eventName, data) {
+    var listener, _i, _j, _len, _len1, _ref, _ref1;
+    _ref = this._listenersForAnyEvent;
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      listener = _ref[_i];
+      listener.call(this, data, eventName);
+    }
+    if (this._listeners[eventName] == null) {
+      return;
+    }
+    _ref1 = this._listeners[eventName];
+    for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
+      listener = _ref1[_j];
+      listener.call(this, data);
+    }
+  };
+
+  Emitter.prototype._throttleEmitterMethod = function(fnName, time) {
+    var lastCallArgs, originalFn, pend, pending, runIt, timer;
+    if (time == null) {
+      time = 1000;
+    }
+    originalFn = this[fnName];
+    if (typeof originalFn !== 'function') {
+      throw Error("this class does not have a method called '" + fnName + "'");
+    }
+    lastCallArgs = null;
+    pending = false;
+    timer = null;
+    this[fnName] = (function(_this) {
+      return function() {
+        lastCallArgs = arguments;
+        return pend();
+      };
+    })(this);
+    pend = (function(_this) {
+      return function() {
+        if (pending) {
+          clearTimeout(timer);
+        }
+        timer = setTimeout(runIt, time);
+        return pending = true;
+      };
+    })(this);
+    return runIt = (function(_this) {
+      return function() {
+        pending = false;
+        return originalFn.apply(_this, lastCallArgs);
+      };
+    })(this);
+  };
+
+  Emitter.prototype._disableEmitter = function(fnName) {
+    if (this._disabledEmitters[fnName] != null) {
+      throw Error("" + fnName + " is already a disabled emitter");
+    }
+    this._disabledEmitters[fnName] = this[fnName];
+    return this[fnName] = function() {};
+  };
+
+  Emitter.prototype._enableEmitter = function(fnName) {
+    var fn;
+    fn = this._disabledEmitters[fnName];
+    if (fn == null) {
+      throw Error("" + fnName + " is not a disabled emitter");
+    }
+    this[fnName] = fn;
+    return delete this._disabledEmitters[fnName];
+  };
+
+  return Emitter;
+
+})();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Emitter.js","sourceRoot":"..\\..","sources":["coffee\\lib\\Emitter.coffee"],"names":[],"mappings":"AAAA,IAAA,cAAA;;AEAA,KEAA,GEAQ,OEAA,CEAQ,SEAR,CAAR,CAAA;;AEEA,MEAM,CEAC,OEAP,GEAuB;AEET,EEAA,iBEAA,GEAA;AEEZ,IEAA,IEAC,CEAA,UEAD,GEAc,EEAd,CEAA;AEAA,IEEA,IEAC,CEAA,qBEAD,GEAyB,EEFzB,CEAA;AEAA,IEIA,IEAC,CEAA,iBEAD,GEAqB,EEJrB,CEFY;EEAA,CEAb;;AEAA,oBEQA,EEAA,GEAI,SEAC,SEAD,EEAY,QEAZ,GEAA;AEEH,IEAA,IEAO,kCEAP;AEEC,MEAA,IEAC,CEAA,UEAW,CEAA,SEAA,CEAZ,GEAyB,EEAzB,CEFD;KEAA;AEAA,IEIA,IEAC,CEAA,UEAW,CEAA,SEAA,CEAU,CEAC,IEAvB,CEA4B,QEA5B,CEJA,CEAA;WEMA,KERG;EEAA,CERJ,CEAA;;AEAA,oBEkBA,IEAA,GEAM,SEAC,SEAD,EEAY,QEAZ,GEAA;AEEL,QEAA,OEAA;AEAA,IEAA,GEAA,GEAM,KEAN,CEAA;AEAA,IEEA,EEAA,GEAK,CEAA,SEAA,KEAA,GEAA;aEAA,SEAA,GEAA;AEEJ,QEAA,IEAU,GEAV;AEAA,gBEAA,CEAA;SEAA;AEAA,QEEA,GEAA,GEAM,IEFN,CEAA;AEAA,QEIG,QEAH,CEAA,CEJA,CEAA;eEMA,UEAA,CEAW,SEAA,GEAA;iBEEV,KEAC,CEAA,WEAD,CEAa,SEAb,EEAwB,EEAxB,EEFU;QEAA,CEAX,EEIE,CEJF,EERI;MEAA,EEAA;IEAA,CEAA,CEAA,CEAA,IEAA,CEFL,CEAA;AEAA,IEgBA,IEAC,CEAA,EEAD,CEAI,SEAJ,EEAe,EEAf,CEhBA,CEAA;WEkBA,KEpBK;EEAA,CElBN,CEAA;;AEAA,oBEwCA,UEAA,GEAY,SEAC,QEAD,GEAA;AEEX,IEAA,IEAC,CEAA,qBEAqB,CEAC,IEAvB,CEA4B,QEA5B,CEAA,CEAA;WEEA,KEJW;EEAA,CExCZ,CEAA;;AEAA,oBE8CA,WEAA,GEAa,SEAC,SEAD,EEAY,QEAZ,GEAA;AEEZ,IEAA,IEAgB,kCEAhB;AEAA,aEAO,IEAP,CEAA;KEAA;AEAA,IEEA,KEAK,CEAC,YEAN,CEAmB,IEAC,CEAA,UEAW,CEAA,SEAA,CEA/B,EEA2C,QEA3C,CEFA,CEAA;WEIA,KENY;EEAA,CE9Cb,CEAA;;AEAA,oBEsDA,eEAA,GEAiB,SEAC,SEAD,GEAA;AEEhB,IEAA,IEAgB,kCEAhB;AEAA,aEAO,IEAP,CEAA;KEAA;AEAA,IEEA,IEAC,CEAA,UEAW,CEAA,SEAA,CEAU,CEAC,MEAvB,GEAgC,CEFhC,CEAA;WEIA,KENgB;EEAA,CEtDjB,CEAA;;AEAA,oBE8DA,kBEAA,GEAoB,SEAA,GEAA;AEEnB,QEAA,qBEAA;AEAA;AEAA,SEAA,YEAA;6BEAA;AEEC,MEAA,SEAS,CEAC,MEAV,GEAmB,CEAnB,CEFD;AEAA,KEAA;WEIA,KENmB;EEAA,CE9DpB,CEAA;;AEAA,oBEsEA,KEAA,GEAO,SEAC,SEAD,EEAY,IEAZ,GEAA;AEEN,QEAA,0CEAA;AEAA;AEAA,SEAA,2CEAA;0BEAA;AEEC,MEAA,QEAQ,CEAC,IEAT,CEAc,IEAd,EEAiB,IEAjB,EEAuB,SEAvB,CEAA,CEFD;AEAA,KEAA;AEIA,IEAA,IEAc,kCEAd;AEAA,YEAA,CEAA;KEJA;AEMA;AEAA,SEAA,8CEAA;2BEAA;AEEC,MEAA,QEAQ,CEAC,IEAT,CEAc,IEAd,EEAiB,IEAjB,CEAA,CEFD;AEAA,KERM;EEAA,CEtEP,CEAA;;AEAA,oBEsFA,sBEAA,GEAwB,SEAC,MEAD,EEAS,IEAT,GEAA;AEEvB,QEAA,qDEAA;;MEFgC,OEAO;KEEvC;AEAA,IEAA,UEAA,GEAa,IEAE,CEAA,MEAA,CEAf,CEAA;AEEA,IEAA,IEAG,MEAA,CEAO,UEAP,KEAuB,UEA1B;AEEC,YEAM,KEAA,CEAO,4CEAA,GEA2C,MEA3C,GEAmD,GEA1D,CEAN,CEFD;KEFA;AEAA,IEMA,YEAA,GEAe,IENf,CEAA;AEAA,IEOA,OEAA,GEAU,KEPV,CEAA;AEAA,IEQA,KEAA,GEAQ,IERR,CEAA;AEAA,IEUA,IEAE,CEAA,MEAA,CEAF,GEAY,CEAA,SEAA,KEAA,GEAA;aEAA,SEAA,GEAA;AEEX,QEAA,YEAA,GEAe,SEAf,CEAA;eEEG,IEAH,CEAA,EEJW;MEAA,EEAA;IEAA,CEAA,CEAA,CEAA,IEAA,CEVZ,CEAA;AEAA,IEgBA,IEAA,GEAO,CEAA,SEAA,KEAA,GEAA;aEAA,SEAA,GEAA;AEEN,QEAA,IEAG,OEAH;AEEC,UEAA,YEAA,CEAa,KEAb,CEAA,CEFD;SEAA;AEAA,QEIA,KEAA,GEAQ,UEAA,CEAW,KEAX,EEAkB,IEAlB,CEJR,CEAA;eEMA,OEAA,GEAU,KERJ;MEAA,EEAA;IEAA,CEAA,CEAA,CEAA,IEAA,CEhBP,CEAA;WE0BA,KEAA,GEAQ,CEAA,SEAA,KEAA,GEAA;aEAA,SEAA,GEAA;AEEP,QEAA,OEAA,GEAU,KEAV,CEAA;eEEA,UEAU,CEAC,KEAX,CEAiB,KEAjB,EEAoB,YEApB,EEJO;MEAA,EEAA;IEAA,CEAA,CEAA,CEAA,IEAA,EE5Be;EEAA,CEtFxB,CEAA;;AEAA,oBEwHA,eEAA,GEAiB,SEAC,MEAD,GEAA;AEEhB,IEAA,IEAG,sCEAH;AEEC,YEAM,KEAA,CEAM,EEAA,GEAE,MEAF,GEAU,gCEAhB,CEAN,CEFD;KEAA;AEAA,IEIA,IEAC,CEAA,iBEAkB,CEAA,MEAA,CEAnB,GEA6B,IEAE,CEAA,MEAA,CEJ/B,CEAA;WEMA,IEAE,CEAA,MEAA,CEAF,GEAY,SEAA,GEAA,EERI;EEAA,CExHjB,CEAA;;AEAA,oBEkIA,cEAA,GEAgB,SEAC,MEAD,GEAA;AEEf,QEAA,EEAA;AEAA,IEAA,EEAA,GEAK,IEAC,CEAA,iBEAkB,CEAA,MEAA,CEAxB,CEAA;AEEA,IEAA,IEAO,UEAP;AEEC,YEAM,KEAA,CEAM,EEAA,GEAE,MEAF,GEAU,4BEAhB,CEAN,CEFD;KEFA;AEAA,IEMA,IEAE,CEAA,MEAA,CEAF,GEAY,EENZ,CEAA;WEQA,MEAA,CEAO,IEAC,CEAA,iBEAkB,CEAA,MEAA,EEVX;EEAA,CElIhB,CEAA;;iBEAA;;IAJD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/_common.js b/node_modules/utila/scripts/js/lib/_common.js
new file mode 100644
index 000000000..c9747ddb8
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/_common.js
@@ -0,0 +1,112 @@
+var common;
+
+module.exports = common = {
+
+  /*
+  	Checks to see if o is an object, and it isn't an instance
+  	of some class.
+   */
+  isBareObject: function(o) {
+    if ((o != null) && o.constructor === Object) {
+      return true;
+    }
+    return false;
+  },
+
+  /*
+  	Returns type of an object, including:
+  	undefined, null, string, number, array,
+  	arguments, element, textnode, whitespace, and object
+   */
+  typeOf: function(item) {
+    var _ref;
+    if (item === null) {
+      return 'null';
+    }
+    if (typeof item !== 'object') {
+      return typeof item;
+    }
+    if (Array.isArray(item)) {
+      return 'array';
+    }
+    if (item.nodeName) {
+      if (item.nodeType === 1) {
+        return 'element';
+      }
+      if (item.nodeType === 3) {
+        return (_ref = /\S/.test(item.nodeValue)) != null ? _ref : {
+          'textnode': 'whitespace'
+        };
+      }
+    } else if (typeof item.length === 'number') {
+      if (item.callee) {
+        return 'arguments';
+      }
+    }
+    return typeof item;
+  },
+  clone: function(item, includePrototype) {
+    if (includePrototype == null) {
+      includePrototype = false;
+    }
+    switch (common.typeOf(item)) {
+      case 'array':
+        return common._cloneArray(item, includePrototype);
+      case 'object':
+        return common._cloneObject(item, includePrototype);
+      default:
+        return item;
+    }
+  },
+
+  /*
+  	Deep clone of an object.
+  	From MooTools
+   */
+  _cloneObject: function(o, includePrototype) {
+    var clone, key;
+    if (includePrototype == null) {
+      includePrototype = false;
+    }
+    if (common.isBareObject(o)) {
+      clone = {};
+      for (key in o) {
+        clone[key] = common.clone(o[key], includePrototype);
+      }
+      return clone;
+    } else {
+      if (!includePrototype) {
+        return o;
+      }
+      if (o instanceof Function) {
+        return o;
+      }
+      clone = Object.create(o.constructor.prototype);
+      for (key in o) {
+        if (o.hasOwnProperty(key)) {
+          clone[key] = common.clone(o[key], includePrototype);
+        }
+      }
+      return clone;
+    }
+  },
+
+  /*
+  	Deep clone of an array.
+  	From MooTools
+   */
+  _cloneArray: function(a, includePrototype) {
+    var clone, i;
+    if (includePrototype == null) {
+      includePrototype = false;
+    }
+    i = a.length;
+    clone = new Array(i);
+    while (i--) {
+      clone[i] = common.clone(a[i], includePrototype);
+    }
+    return clone;
+  }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_common.js","sourceRoot":"..\\..","sources":["coffee\\lib\\_common.coffee"],"names":[],"mappings":"AAAA,IAAA,MAAA;;AMAA,MMAM,CMAC,OMAP,GMAiB,MMAA,GMEhB;AMAA;AMAA;;;KMAA;AMAA,EMIA,YMAA,EMAc,SMAC,CMAD,GMAA;AMEb,IMAA,IMAG,WMAA,IMAO,CMAC,CMAC,WMAF,KMAiB,MMA3B;AMEC,aMAO,IMAP,CMFD;KMAA;WMIA,MMNa;EMAA,CMJd;AMYA;AMAA;;;;KMZA;AMAA,EMiBA,MMAA,EMAQ,SMAC,IMAD,GMAA;AMEP,QMAA,IMAA;AMAA,IMAA,IMAiB,IMAA,KMAQ,IMAzB;AMAA,aMAO,MMAP,CMAA;KMAA;AMEA,IMAA,IMAsB,MMAA,CMAO,IMAP,KMAiB,QMAvC;AMAA,aMAO,MMAA,CMAO,IMAd,CMAA;KMFA;AMIA,IMAA,IMAkB,KMAK,CMAC,OMAN,CMAc,IMAd,CMAlB;AMAA,aMAO,OMAP,CMAA;KMJA;AMQA,IMAA,IMAG,IMAI,CMAC,QMAR;AMEC,MMAA,IMAG,IMAI,CMAC,QMAL,KMAiB,CMApB;AMA2B,eMAO,SMAP,CMA3B;OMAA;AMCA,MMAA,IMAG,IMAI,CMAC,QMAL,KMAiB,CMApB;AMA2B,mEMAqC;AMAA,UMAA,UMAA,EMAa,YMAb;SMArC,CMA3B;OMHD;KMAA,MMKK,IMAG,MMAA,CMAO,IMAI,CMAC,MMAZ,KMAsB,QMAzB;AMEJ,MMAA,IMAG,IMAI,CMAC,MMAR;AMAoB,eMAO,WMAP,CMApB;OMFI;KMbL;AMiBA,WMAO,MMAA,CMAO,IMAd,CMnBO;EMAA,CMjBR;AMAA,EMwCA,KMAA,EMAO,SMAC,IMAD,EMAO,gBMAP,GMAA;;MMAO,mBMAmB;KMEhC;AMAA,YMAO,MMAM,CMAC,MMAP,CMAc,IMAd,CMAP;AMAA,WMEM,OMFN;AMEmB,eMAO,MMAM,CMAC,WMAP,CMAmB,IMAnB,EMAyB,gBMAzB,CMAP,CMFnB;AMAA,WMIM,QMJN;AMIoB,eMAO,MMAM,CMAC,YMAP,CMAoB,IMApB,EMA0B,gBMA1B,CMAP,CMJpB;AMAA;AMMM,eMAO,IMAP,CMNN;AMAA,KMFM;EMAA,CMxCP;AMkDA;AMAA;;;KMlDA;AMAA,EMsDA,YMAA,EMAc,SMAC,CMAD,EMAI,gBMAJ,GMAA;AMEb,QMAA,UMAA;;MMFiB,mBMAmB;KMEpC;AMAA,IMAA,IMAG,MMAM,CMAC,YMAP,CMAoB,CMApB,CMAH;AMEC,MMAA,KMAA,GMAQ,EMAR,CMAA;AMEA,WMAA,QMAA,GMAA;AMEC,QMAA,KMAM,CMAA,GMAA,CMAN,GMAa,MMAM,CMAC,KMAP,CMAa,CMAE,CMAA,GMAA,CMAf,EMAqB,gBMArB,CMAb,CMFD;AMAA,OMFA;AMMA,aMAO,KMAP,CMRD;KMAA,MMAA;AMYC,MMAA,IMAA,CMAgB,gBMAhB;AMAA,eMAO,CMAP,CMAA;OMAA;AMEA,MMAA,IMAY,CMAA,YMAa,QMAzB;AMAA,eMAO,CMAP,CMAA;OMFA;AMAA,MMIA,KMAA,GMAQ,MMAM,CMAC,MMAP,CMAc,CMAC,CMAC,WMAW,CMAC,SMA5B,CMJR,CMAA;AMMA,WMAA,QMAA,GMAA;AMEC,QMAA,IMAG,CMAC,CMAC,cMAF,CMAiB,GMAjB,CMAH;AMEC,UMAA,KMAM,CMAA,GMAA,CMAN,GMAa,MMAM,CMAC,KMAP,CMAa,CMAE,CMAA,GMAA,CMAf,EMAqB,gBMArB,CMAb,CMFD;SMFD;AMAA,OMNA;aMYA,MMxBD;KMFa;EMAA,CMtDd;AMkFA;AMAA;;;KMlFA;AMAA,EMsFA,WMAA,EMAa,SMAC,CMAD,EMAI,gBMAJ,GMAA;AMEZ,QMAA,QMAA;;MMFgB,mBMAmB;KMEnC;AMAA,IMAA,CMAA,GMAI,CMAC,CMAC,MMAN,CMAA;AMAA,IMEA,KMAA,GMAY,IMAA,KMAA,CMAM,CMAN,CMFZ,CMAA;AMIA,WMAM,CMAA,EMAN,GMAA;AMEC,MMAA,KMAM,CMAA,CMAA,CMAN,GMAW,MMAM,CMAC,KMAP,CMAa,CMAE,CMAA,CMAA,CMAf,EMAmB,gBMAnB,CMAX,CMFD;IMAA,CMJA;WMQA,MMVY;EMAA,CMtFb;CAFD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n","module.exports = utila =\n\n\tarray: require './array'\n\tclassic: require './classic'\n\tobject: require './object'\n\tstring: require './string'\n\tEmitter: require './Emitter'","module.exports = common =\n\n\t###\n\tChecks to see if o is an object, and it isn't an instance\n\tof some class.\n\t###\n\tisBareObject: (o) ->\n\n\t\tif o? and o.constructor is Object\n\n\t\t\treturn true\n\n\t\tfalse\n\n\t###\n\tReturns type of an object, including:\n\tundefined, null, string, number, array,\n\targuments, element, textnode, whitespace, and object\n\t###\n\ttypeOf: (item) ->\n\n\t\treturn 'null' if item is null\n\n\t\treturn typeof item if typeof item isnt 'object'\n\n\t\treturn 'array' if Array.isArray item\n\n\t\t# From MooTools\n\t\t# - do we even need this?\n\t\tif item.nodeName\n\n\t\t\tif item.nodeType is 1 then return 'element'\n\t\t\tif item.nodeType is 3 then return (/\\S/).test(item.nodeValue) ? 'textnode' : 'whitespace'\n\n\t\telse if typeof item.length is 'number'\n\n\t\t\tif item.callee then return 'arguments'\n\n\t\treturn typeof item\n\n\t# Deep clone of any variable.\n\t# From MooTools\n\tclone: (item, includePrototype = false) ->\n\n\t\tswitch common.typeOf item\n\n\t\t\twhen 'array' then return common._cloneArray item, includePrototype\n\n\t\t\twhen 'object' then return common._cloneObject item, includePrototype\n\n\t\t\telse return item\n\n\t###\n\tDeep clone of an object.\n\tFrom MooTools\n\t###\n\t_cloneObject: (o, includePrototype = false) ->\n\n\t\tif common.isBareObject o\n\n\t\t\tclone = {}\n\n\t\t\tfor key of o\n\n\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\treturn clone\n\n\t\telse\n\n\t\t\treturn o unless includePrototype\n\n\t\t\treturn o if o instanceof Function\n\n\t\t\tclone = Object.create o.constructor.prototype\n\n\t\t\tfor key of o\n\n\t\t\t\tif o.hasOwnProperty key\n\n\t\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\tclone\n\n\t###\n\tDeep clone of an array.\n\tFrom MooTools\n\t###\n\t_cloneArray: (a, includePrototype = false) ->\n\n\t\ti = a.length\n\n\t\tclone = new Array i\n\n\t\twhile i--\n\n\t\t\tclone[i] = common.clone a[i], includePrototype\n\n\t\tclone"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/array.js b/node_modules/utila/scripts/js/lib/array.js
new file mode 100644
index 000000000..44a7c68db
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/array.js
@@ -0,0 +1,166 @@
+var array;
+
+module.exports = array = {
+
+  /*
+  	Tries to turn anything into an array.
+   */
+  from: function(r) {
+    return Array.prototype.slice.call(r);
+  },
+
+  /*
+  	Clone of an array. Properties will be shallow copies.
+   */
+  simpleClone: function(a) {
+    return a.slice(0);
+  },
+  shallowEqual: function(a1, a2) {
+    var i, val, _i, _len;
+    if (!(Array.isArray(a1) && Array.isArray(a2) && a1.length === a2.length)) {
+      return false;
+    }
+    for (i = _i = 0, _len = a1.length; _i < _len; i = ++_i) {
+      val = a1[i];
+      if (a2[i] !== val) {
+        return false;
+      }
+    }
+    return true;
+  },
+  pluck: function(a, i) {
+    var index, value, _i, _len;
+    if (a.length < 1) {
+      return a;
+    }
+    for (index = _i = 0, _len = a.length; _i < _len; index = ++_i) {
+      value = a[index];
+      if (index > i) {
+        a[index - 1] = a[index];
+      }
+    }
+    a.length = a.length - 1;
+    return a;
+  },
+  pluckItem: function(a, item) {
+    var index, removed, value, _i, _len;
+    if (a.length < 1) {
+      return a;
+    }
+    removed = 0;
+    for (index = _i = 0, _len = a.length; _i < _len; index = ++_i) {
+      value = a[index];
+      if (value === item) {
+        removed++;
+        continue;
+      }
+      if (removed !== 0) {
+        a[index - removed] = a[index];
+      }
+    }
+    if (removed > 0) {
+      a.length = a.length - removed;
+    }
+    return a;
+  },
+  pluckOneItem: function(a, item) {
+    var index, reached, value, _i, _len;
+    if (a.length < 1) {
+      return a;
+    }
+    reached = false;
+    for (index = _i = 0, _len = a.length; _i < _len; index = ++_i) {
+      value = a[index];
+      if (!reached) {
+        if (value === item) {
+          reached = true;
+          continue;
+        }
+      } else {
+        a[index - 1] = a[index];
+      }
+    }
+    if (reached) {
+      a.length = a.length - 1;
+    }
+    return a;
+  },
+  pluckByCallback: function(a, cb) {
+    var index, removed, value, _i, _len;
+    if (a.length < 1) {
+      return a;
+    }
+    removed = 0;
+    for (index = _i = 0, _len = a.length; _i < _len; index = ++_i) {
+      value = a[index];
+      if (cb(value, index)) {
+        removed++;
+        continue;
+      }
+      if (removed !== 0) {
+        a[index - removed] = a[index];
+      }
+    }
+    if (removed > 0) {
+      a.length = a.length - removed;
+    }
+    return a;
+  },
+  pluckMultiple: function(array, indexesToRemove) {
+    var i, removedSoFar, _i, _len;
+    if (array.length < 1) {
+      return array;
+    }
+    removedSoFar = 0;
+    indexesToRemove.sort();
+    for (_i = 0, _len = indexesToRemove.length; _i < _len; _i++) {
+      i = indexesToRemove[_i];
+      this.pluck(array, i - removedSoFar);
+      removedSoFar++;
+    }
+    return array;
+  },
+  injectByCallback: function(a, toInject, shouldInject) {
+    var i, len, val, valA, valB, _i, _len;
+    valA = null;
+    valB = null;
+    len = a.length;
+    if (len < 1) {
+      a.push(toInject);
+      return a;
+    }
+    for (i = _i = 0, _len = a.length; _i < _len; i = ++_i) {
+      val = a[i];
+      valA = valB;
+      valB = val;
+      if (shouldInject(valA, valB, toInject)) {
+        return a.splice(i, 0, toInject);
+      }
+    }
+    a.push(toInject);
+    return a;
+  },
+  injectInIndex: function(a, index, toInject) {
+    var i, len, toPut, toPutNext;
+    len = a.length;
+    i = index;
+    if (len < 1) {
+      a.push(toInject);
+      return a;
+    }
+    toPut = toInject;
+    toPutNext = null;
+    for(; i <= len; i++){
+
+			toPutNext = a[i];
+
+			a[i] = toPut;
+
+			toPut = toPutNext;
+
+		};
+    return null;
+  }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.js","sourceRoot":"..\\..","sources":["coffee\\lib\\array.coffee"],"names":[],"mappings":"AAAA,IAAA,KAAA;;AAAA,MAAM,CAAC,OAAP,GAAiB,KAAA,GAEhB;AAAA;AAAA;;KAAA;AAAA,EAGA,IAAA,EAAM,SAAC,CAAD,GAAA;WAEL,KAAK,CAAA,SAAE,CAAA,KAAK,CAAC,IAAb,CAAkB,CAAlB,EAFK;EAAA,CAHN;AAOA;AAAA;;KAPA;AAAA,EAUA,WAAA,EAAa,SAAC,CAAD,GAAA;WAEZ,CAAC,CAAC,KAAF,CAAQ,CAAR,EAFY;EAAA,CAVb;AAAA,EAcA,YAAA,EAAc,SAAC,EAAD,EAAK,EAAL,GAAA;AAEb,QAAA,gBAAA;AAAA,IAAA,IAAA,CAAA,CAAiB,KAAK,CAAC,OAAN,CAAc,EAAd,CAAA,IAAsB,KAAK,CAAC,OAAN,CAAc,EAAd,CAAtB,IAA4C,EAAE,CAAC,MAAH,KAAa,EAAE,CAAC,MAA7E,CAAA;AAAA,aAAO,KAAP,CAAA;KAAA;AAEA,SAAA,iDAAA;kBAAA;AAEC,MAAA,IAAiB,EAAG,CAAA,CAAA,CAAH,KAAS,GAA1B;AAAA,eAAO,KAAP,CAAA;OAFD;AAAA,KAFA;WAMA,KARa;EAAA,CAdd;AAAA,EAwBA,KAAA,EAAO,SAAC,CAAD,EAAI,CAAJ,GAAA;AAEN,QAAA,sBAAA;AAAA,IAAA,IAAY,CAAC,CAAC,MAAF,GAAW,CAAvB;AAAA,aAAO,CAAP,CAAA;KAAA;AAGA,SAAA,wDAAA;uBAAA;AAEC,MAAA,IAAG,KAAA,GAAQ,CAAX;AAEC,QAAA,CAAE,CAAA,KAAA,GAAQ,CAAR,CAAF,GAAe,CAAE,CAAA,KAAA,CAAjB,CAFD;OAFD;AAAA,KAHA;AAAA,IASA,CAAC,CAAC,MAAF,GAAW,CAAC,CAAC,MAAF,GAAW,CATtB,CAAA;WAWA,EAbM;EAAA,CAxBP;AAAA,EAuCA,SAAA,EAAW,SAAC,CAAD,EAAI,IAAJ,GAAA;AAEV,QAAA,+BAAA;AAAA,IAAA,IAAY,CAAC,CAAC,MAAF,GAAW,CAAvB;AAAA,aAAO,CAAP,CAAA;KAAA;AAAA,IAGA,OAAA,GAAU,CAHV,CAAA;AAKA,SAAA,wDAAA;uBAAA;AAEC,MAAA,IAAG,KAAA,KAAS,IAAZ;AAEC,QAAA,OAAA,EAAA,CAAA;AAEA,iBAJD;OAAA;AAMA,MAAA,IAAG,OAAA,KAAa,CAAhB;AAEC,QAAA,CAAE,CAAA,KAAA,GAAQ,OAAR,CAAF,GAAqB,CAAE,CAAA,KAAA,CAAvB,CAFD;OARD;AAAA,KALA;AAiBA,IAAA,IAAiC,OAAA,GAAU,CAA3C;AAAA,MAAA,CAAC,CAAC,MAAF,GAAW,CAAC,CAAC,MAAF,GAAW,OAAtB,CAAA;KAjBA;WAmBA,EArBU;EAAA,CAvCX;AAAA,EA8DA,YAAA,EAAc,SAAC,CAAD,EAAI,IAAJ,GAAA;AAEb,QAAA,+BAAA;AAAA,IAAA,IAAY,CAAC,CAAC,MAAF,GAAW,CAAvB;AAAA,aAAO,CAAP,CAAA;KAAA;AAAA,IAEA,OAAA,GAAU,KAFV,CAAA;AAIA,SAAA,wDAAA;uBAAA;AAEC,MAAA,IAAG,CAAI,OAAP;AAEC,QAAA,IAAG,KAAA,KAAS,IAAZ;AAEC,UAAA,OAAA,GAAU,IAAV,CAAA;AAEA,mBAJD;SAFD;OAAA,MAAA;AAUC,QAAA,CAAE,CAAA,KAAA,GAAQ,CAAR,CAAF,GAAe,CAAE,CAAA,KAAA,CAAjB,CAVD;OAFD;AAAA,KAJA;AAkBA,IAAA,IAA2B,OAA3B;AAAA,MAAA,CAAC,CAAC,MAAF,GAAW,CAAC,CAAC,MAAF,GAAW,CAAtB,CAAA;KAlBA;WAoBA,EAtBa;EAAA,CA9Dd;AAAA,EAsFA,eAAA,EAAiB,SAAC,CAAD,EAAI,EAAJ,GAAA;AAEhB,QAAA,+BAAA;AAAA,IAAA,IAAY,CAAC,CAAC,MAAF,GAAW,CAAvB;AAAA,aAAO,CAAP,CAAA;KAAA;AAAA,IAEA,OAAA,GAAU,CAFV,CAAA;AAIA,SAAA,wDAAA;uBAAA;AAEC,MAAA,IAAG,EAAA,CAAG,KAAH,EAAU,KAAV,CAAH;AAEC,QAAA,OAAA,EAAA,CAAA;AAEA,iBAJD;OAAA;AAMA,MAAA,IAAG,OAAA,KAAa,CAAhB;AAEC,QAAA,CAAE,CAAA,KAAA,GAAQ,OAAR,CAAF,GAAqB,CAAE,CAAA,KAAA,CAAvB,CAFD;OARD;AAAA,KAJA;AAgBA,IAAA,IAAG,OAAA,GAAU,CAAb;AAEC,MAAA,CAAC,CAAC,MAAF,GAAW,CAAC,CAAC,MAAF,GAAW,OAAtB,CAFD;KAhBA;WAoBA,EAtBgB;EAAA,CAtFjB;AAAA,EA8GA,aAAA,EAAe,SAAC,KAAD,EAAQ,eAAR,GAAA;AAEd,QAAA,yBAAA;AAAA,IAAA,IAAgB,KAAK,CAAC,MAAN,GAAe,CAA/B;AAAA,aAAO,KAAP,CAAA;KAAA;AAAA,IAEA,YAAA,GAAe,CAFf,CAAA;AAAA,IAIA,eAAe,CAAC,IAAhB,CAAA,CAJA,CAAA;AAMA,SAAA,sDAAA;8BAAA;AAEC,MAAA,IAAC,CAAA,KAAD,CAAO,KAAP,EAAc,CAAA,GAAI,YAAlB,CAAA,CAAA;AAAA,MAEA,YAAA,EAFA,CAFD;AAAA,KANA;WAYA,MAdc;EAAA,CA9Gf;AAAA,EA8HA,gBAAA,EAAkB,SAAC,CAAD,EAAI,QAAJ,EAAc,YAAd,GAAA;AAEjB,QAAA,iCAAA;AAAA,IAAA,IAAA,GAAO,IAAP,CAAA;AAAA,IAEA,IAAA,GAAO,IAFP,CAAA;AAAA,IAIA,GAAA,GAAM,CAAC,CAAC,MAJR,CAAA;AAMA,IAAA,IAAG,GAAA,GAAM,CAAT;AAEC,MAAA,CAAC,CAAC,IAAF,CAAO,QAAP,CAAA,CAAA;AAEA,aAAO,CAAP,CAJD;KANA;AAaA,SAAA,gDAAA;iBAAA;AAEC,MAAA,IAAA,GAAO,IAAP,CAAA;AAAA,MAEA,IAAA,GAAO,GAFP,CAAA;AAIA,MAAA,IAAG,YAAA,CAAa,IAAb,EAAmB,IAAnB,EAAyB,QAAzB,CAAH;AAEC,eAAO,CAAC,CAAC,MAAF,CAAS,CAAT,EAAY,CAAZ,EAAe,QAAf,CAAP,CAFD;OAND;AAAA,KAbA;AAAA,IAuBA,CAAC,CAAC,IAAF,CAAO,QAAP,CAvBA,CAAA;WAyBA,EA3BiB;EAAA,CA9HlB;AAAA,EA2JA,aAAA,EAAe,SAAC,CAAD,EAAI,KAAJ,EAAW,QAAX,GAAA;AAEd,QAAA,wBAAA;AAAA,IAAA,GAAA,GAAM,CAAC,CAAC,MAAR,CAAA;AAAA,IAEA,CAAA,GAAI,KAFJ,CAAA;AAIA,IAAA,IAAG,GAAA,GAAM,CAAT;AAEC,MAAA,CAAC,CAAC,IAAF,CAAO,QAAP,CAAA,CAAA;AAEA,aAAO,CAAP,CAJD;KAJA;AAAA,IAUA,KAAA,GAAQ,QAVR,CAAA;AAAA,IAYA,SAAA,GAAY,IAZZ,CAAA;AAAA,IAcA;;;;;;;;GAdA,CAAA;WA0BA,KA5Bc;EAAA,CA3Jf;CAFD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/classic.js b/node_modules/utila/scripts/js/lib/classic.js
new file mode 100644
index 000000000..3de0c290f
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/classic.js
@@ -0,0 +1,87 @@
+var classic,
+  __slice = [].slice;
+
+module.exports = classic = {};
+
+classic.implement = function() {
+  var classProto, classReference, desc, member, mixin, mixins, _i, _j, _len;
+  mixins = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), classReference = arguments[_i++];
+  for (_j = 0, _len = mixins.length; _j < _len; _j++) {
+    mixin = mixins[_j];
+    classProto = classReference.prototype;
+    for (member in mixin.prototype) {
+      if (!Object.getOwnPropertyDescriptor(classProto, member)) {
+        desc = Object.getOwnPropertyDescriptor(mixin.prototype, member);
+        Object.defineProperty(classProto, member, desc);
+      }
+    }
+  }
+  return classReference;
+};
+
+classic.mix = function() {
+  var classProto, classReference, desc, member, mixin, mixins, _i, _j, _len;
+  mixins = 2 <= arguments.length ? __slice.call(arguments, 0, _i = arguments.length - 1) : (_i = 0, []), classReference = arguments[_i++];
+  classProto = classReference.prototype;
+  classReference.__mixinCloners = [];
+  classReference.__applyClonersFor = function(instance, args) {
+    var cloner, _j, _len, _ref;
+    if (args == null) {
+      args = null;
+    }
+    _ref = classReference.__mixinCloners;
+    for (_j = 0, _len = _ref.length; _j < _len; _j++) {
+      cloner = _ref[_j];
+      cloner.apply(instance, args);
+    }
+  };
+  classReference.__mixinInitializers = [];
+  classReference.__initMixinsFor = function(instance, args) {
+    var initializer, _j, _len, _ref;
+    if (args == null) {
+      args = null;
+    }
+    _ref = classReference.__mixinInitializers;
+    for (_j = 0, _len = _ref.length; _j < _len; _j++) {
+      initializer = _ref[_j];
+      initializer.apply(instance, args);
+    }
+  };
+  classReference.__mixinQuitters = [];
+  classReference.__applyQuittersFor = function(instance, args) {
+    var quitter, _j, _len, _ref;
+    if (args == null) {
+      args = null;
+    }
+    _ref = classReference.__mixinQuitters;
+    for (_j = 0, _len = _ref.length; _j < _len; _j++) {
+      quitter = _ref[_j];
+      quitter.apply(instance, args);
+    }
+  };
+  for (_j = 0, _len = mixins.length; _j < _len; _j++) {
+    mixin = mixins[_j];
+    if (!(mixin.constructor instanceof Function)) {
+      throw Error("Mixin should be a function");
+    }
+    for (member in mixin.prototype) {
+      if (member.substr(0, 11) === '__initMixin') {
+        classReference.__mixinInitializers.push(mixin.prototype[member]);
+        continue;
+      } else if (member.substr(0, 11) === '__clonerFor') {
+        classReference.__mixinCloners.push(mixin.prototype[member]);
+        continue;
+      } else if (member.substr(0, 12) === '__quitterFor') {
+        classReference.__mixinQuitters.push(mixin.prototype[member]);
+        continue;
+      }
+      if (!Object.getOwnPropertyDescriptor(classProto, member)) {
+        desc = Object.getOwnPropertyDescriptor(mixin.prototype, member);
+        Object.defineProperty(classProto, member, desc);
+      }
+    }
+  }
+  return classReference;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classic.js","sourceRoot":"..\\..","sources":["coffee\\lib\\classic.coffee"],"names":[],"mappings":"AAAA,IAAA,OAAA;EAAA,kBAAA;;ACAA,MCAM,CCAC,OCAP,GCAiB,OCAA,GCAU,EAA3B,CAAA;;ACIA,OCAO,CCAC,SCAR,GCAoB,SCAA,GCAA;ACEnB,MCAA,qECAA;ACAA,ECFoB,uGCAW,gCCE/B,CCAA;ACAA,OCAA,6CCAA;uBCAA;ACEC,ICAA,UCAA,GCAa,cCAc,CCAA,SCA3B,CCAA;ACEA,SCAA,yBCAA,GCAA;ACEC,MCAA,ICAA,CCAO,MCAM,CCAC,wBCAP,CCAgC,UCAhC,ECA4C,MCA5C,CCAP;ACEC,QCAA,ICAA,GCAO,MCAM,CCAC,wBCAP,CCAgC,KCAK,CCAA,SCArC,ECAyC,MCAzC,CCAP,CCAA;ACAA,QCEA,MCAM,CCAC,cCAP,CCAsB,UCAtB,ECAkC,MCAlC,ECA0C,ICA1C,CCFA,CCFD;OCFD;ACAA,KCJD;ACAA,GCAA;SCYA,eCdmB;ACAA,CAJpB,CAAA;;ACoBA,OCAO,CCAC,GCAR,GCAc,SCAA,GCAA;ACEb,MCAA,qECAA;ACAA,ECFc,uGCAW,gCCEzB,CCAA;ACAA,ECAA,UCAA,GCAa,cCAc,CCAA,SCA3B,CCAA;ACAA,ECEA,cCAc,CCAC,cCAf,GCAgC,ECFhC,CCAA;ACAA,ECIA,cCAc,CCAC,iBCAf,GCAmC,SCAC,QCAD,ECAW,ICAX,GCAA;ACElC,QCAA,sBCAA;;MCF6C,OCAO;KCEpD;ACAA;ACAA,SCAA,2CCAA;wBCAA;ACEC,MCAA,MCAM,CCAC,KCAP,CCAa,QCAb,ECAuB,ICAvB,CCAA,CCFD;ACAA,KCFkC;ECAA,CCJnC,CCAA;ACAA,ECYA,cCAc,CCAC,mBCAf,GCAqC,ECZrC,CCAA;ACAA,ECcA,cCAc,CCAC,eCAf,GCAiC,SCAC,QCAD,ECAW,ICAX,GCAA;ACEhC,QCAA,2BCAA;;MCF2C,OCAO;KCElD;ACAA;ACAA,SCAA,2CCAA;6BCAA;ACEC,MCAA,WCAW,CCAC,KCAZ,CCAkB,QCAlB,ECA4B,ICA5B,CCAA,CCFD;ACAA,KCFgC;ECAA,CCdjC,CCAA;ACAA,ECsBA,cCAc,CCAC,eCAf,GCAiC,ECtBjC,CCAA;ACAA,ECwBA,cCAc,CCAC,kBCAf,GCAoC,SCAC,QCAD,ECAW,ICAX,GCAA;ACEnC,QCAA,uBCAA;;MCF8C,OCAO;KCErD;ACAA;ACAA,SCAA,2CCAA;yBCAA;ACEC,MCAA,OCAO,CCAC,KCAR,CCAc,QCAd,ECAwB,ICAxB,CCAA,CCFD;ACAA,KCFmC;ECAA,CCxBpC,CCAA;ACgCA,OCAA,6CCAA;uBCAA;ACEC,ICAA,ICAA,CCAA,CCAO,KCAK,CCAC,WCAN,YCA6B,QCApC,CCAA;ACEC,YCAM,KCAA,CCAM,4BCAN,CCAN,CCFD;KCAA;ACIA,SCAA,yBCAA,GCAA;ACEC,MCAA,ICAG,MCAM,CCAC,MCAP,CCAc,CCAd,ECAiB,ECAjB,CCAA,KCAwB,aCA3B;ACEC,QCAA,cCAc,CCAC,mBCAmB,CCAC,ICAnC,CCAwC,KCAK,CCAA,SCAG,CCAA,MCAA,CCAhD,CCAA,CCAA;ACEA,iBCJD;OCAA,MCMK,ICAG,MCAM,CCAC,MCAP,CCAc,CCAd,ECAiB,ECAjB,CCAA,KCAwB,aCA3B;ACEJ,QCAA,cCAc,CCAC,cCAc,CCAC,ICA9B,CCAmC,KCAK,CCAA,SCAG,CCAA,MCAA,CCA3C,CCAA,CCAA;ACEA,iBCJI;OCAA,MCMA,ICAG,MCAM,CCAC,MCAP,CCAc,CCAd,ECAiB,ECAjB,CCAA,KCAwB,cCA3B;ACEJ,QCAA,cCAc,CCAC,eCAe,CCAC,ICA/B,CCAoC,KCAK,CCAA,SCAG,CCAA,MCAA,CCA5C,CCAA,CCAA;ACEA,iBCJI;OCZL;ACkBA,MCAA,ICAA,CCAO,MCAM,CCAC,wBCAP,CCAgC,UCAhC,ECA4C,MCA5C,CCAP;ACEC,QCAA,ICAA,GCAO,MCAM,CCAC,wBCAP,CCAgC,KCAK,CCAA,SCArC,ECAyC,MCAzC,CCAP,CCAA;ACAA,QCEA,MCAM,CCAC,cCAP,CCAsB,UCAtB,ECAkC,MCAlC,ECA0C,ICA1C,CCFA,CCFD;OCpBD;ACAA,KCND;ACAA,GChCA;SCgEA,eClEa;ACAA,CApBd,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/object.js b/node_modules/utila/scripts/js/lib/object.js
new file mode 100644
index 000000000..c776361c0
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/object.js
@@ -0,0 +1,158 @@
+var object, _common,
+  __hasProp = {}.hasOwnProperty;
+
+_common = require('./_common');
+
+module.exports = object = {
+  isBareObject: _common.isBareObject.bind(_common),
+
+  /*
+  	if object is an instance of a class
+   */
+  isInstance: function(what) {
+    return !this.isBareObject(what);
+  },
+
+  /*
+  	Alias to _common.typeOf
+   */
+  typeOf: _common.typeOf.bind(_common),
+
+  /*
+  	Alias to _common.clone
+   */
+  clone: _common.clone.bind(_common),
+
+  /*
+  	Empties an object of its properties.
+   */
+  empty: function(o) {
+    var prop;
+    for (prop in o) {
+      if (o.hasOwnProperty(prop)) {
+        delete o[prop];
+      }
+    }
+    return o;
+  },
+
+  /*
+  	Empties an object. Doesn't check for hasOwnProperty, so it's a tiny
+  	bit faster. Use it for plain objects.
+   */
+  fastEmpty: function(o) {
+    var property;
+    for (property in o) {
+      delete o[property];
+    }
+    return o;
+  },
+
+  /*
+  	Overrides values fomr `newValues` on `base`, as long as they
+  	already exist in base.
+   */
+  overrideOnto: function(base, newValues) {
+    var key, newVal, oldVal;
+    if (!this.isBareObject(newValues) || !this.isBareObject(base)) {
+      return base;
+    }
+    for (key in base) {
+      oldVal = base[key];
+      newVal = newValues[key];
+      if (newVal === void 0) {
+        continue;
+      }
+      if (typeof newVal !== 'object' || this.isInstance(newVal)) {
+        base[key] = this.clone(newVal);
+      } else {
+        if (typeof oldVal !== 'object' || this.isInstance(oldVal)) {
+          base[key] = this.clone(newVal);
+        } else {
+          this.overrideOnto(oldVal, newVal);
+        }
+      }
+    }
+    return base;
+  },
+
+  /*
+  	Takes a clone of 'base' and runs #overrideOnto on it
+   */
+  override: function(base, newValues) {
+    return this.overrideOnto(this.clone(base), newValues);
+  },
+  append: function(base, toAppend) {
+    return this.appendOnto(this.clone(base), toAppend);
+  },
+  appendOnto: function(base, toAppend) {
+    var key, newVal, oldVal;
+    if (!this.isBareObject(toAppend) || !this.isBareObject(base)) {
+      return base;
+    }
+    for (key in toAppend) {
+      if (!__hasProp.call(toAppend, key)) continue;
+      newVal = toAppend[key];
+      if (newVal === void 0) {
+        continue;
+      }
+      if (typeof newVal !== 'object' || this.isInstance(newVal)) {
+        base[key] = newVal;
+      } else {
+        oldVal = base[key];
+        if (typeof oldVal !== 'object' || this.isInstance(oldVal)) {
+          base[key] = this.clone(newVal);
+        } else {
+          this.appendOnto(oldVal, newVal);
+        }
+      }
+    }
+    return base;
+  },
+  groupProps: function(obj, groups) {
+    var def, defs, grouped, key, name, shouldAdd, val, _i, _len;
+    grouped = {};
+    for (name in groups) {
+      defs = groups[name];
+      grouped[name] = {};
+    }
+    grouped['rest'] = {};
+    top: //;
+    for (key in obj) {
+      val = obj[key];
+      shouldAdd = false;
+      for (name in groups) {
+        defs = groups[name];
+        if (!Array.isArray(defs)) {
+          defs = [defs];
+        }
+        for (_i = 0, _len = defs.length; _i < _len; _i++) {
+          def = defs[_i];
+          if (typeof def === 'string') {
+            if (key === def) {
+              shouldAdd = true;
+            }
+          } else if (def instanceof RegExp) {
+            if (def.test(key)) {
+              shouldAdd = true;
+            }
+          } else if (def instanceof Function) {
+            if (def(key)) {
+              shouldAdd = true;
+            }
+          } else {
+            throw Error('Group definitions must either be strings, regexes, or functions.');
+          }
+          if (shouldAdd) {
+            grouped[name][key] = val;
+            continue top;
+          }
+        }
+      }
+      grouped['rest'][key] = val;
+    }
+    return grouped;
+  }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.js","sourceRoot":"..\\..","sources":["coffee\\lib\\object.coffee"],"names":[],"mappings":"AAAA,IAAA,eAAA;EAAA,6BAAA;;AGAA,OGAA,GGAU,OGAA,CGAQ,WGAR,CAAV,CAAA;;AGEA,MGAM,CGAC,OGAP,GGAiB,MGAA,GGEhB;AGAA,EGAA,YGAA,EGAc,OGAO,CGAC,YGAY,CGAC,IGArB,CGA0B,OGA1B,CGAd;AGEA;AGAA;;KGFA;AGAA,EGKA,UGAA,EGAY,SGAC,IGAD,GGAA;WGEX,CGAI,IGAC,CGAA,YGAD,CGAc,IGAd,EGFO;EGAA,CGLZ;AGSA;AGAA;;KGTA;AGAA,EGYA,MGAA,EGAQ,OGAO,CGAC,MGAM,CGAC,IGAf,CGAoB,OGApB,CGZR;AGcA;AGAA;;KGdA;AGAA,EGiBA,KGAA,EGAO,OGAO,CGAC,KGAK,CGAC,IGAd,CGAmB,OGAnB,CGjBP;AGmBA;AGAA;;KGnBA;AGAA,EGsBA,KGAA,EGAO,SGAC,CGAD,GGAA;AGEN,QGAA,IGAA;AGAA,SGAA,SGAA,GGAA;AGEC,MGAA,IGAkB,CGAC,CGAC,cGAF,CGAiB,IGAjB,CGAlB;AGAA,QGAA,MGAA,CGAO,CGAE,CGAA,IGAA,CGAT,CGAA;OGFD;AGAA,KGAA;WGIA,EGNM;EGAA,CGtBP;AG8BA;AGAA;;;KG9BA;AGAA,EGkCA,SGAA,EGAW,SGAC,CGAD,GGAA;AGEV,QGAA,QGAA;AGAA,SGAA,aGAA,GGAA;AGAA,MGAA,MGAA,CGAO,CGAE,CGAA,QGAA,CGAT,CGAA;AGAA,KGAA;WGEA,EGJU;EGAA,CGlCX;AGwCA;AGAA;;;KGxCA;AGAA,EG4CA,YGAA,EGAc,SGAC,IGAD,EGAO,SGAP,GGAA;AGEb,QGAA,mBGAA;AGAA,IGAA,IGAe,CGAI,IGAC,CGAA,YGAD,CGAc,SGAd,CGAJ,IGAgC,CGAI,IGAC,CGAA,YGAD,CGAc,IGAd,CGAnD;AGAA,aGAO,IGAP,CGAA;KGAA;AGEA,SGAA,WGAA;yBGAA;AGEC,MGAA,MGAA,GGAS,SGAU,CGAA,GGAA,CGAnB,CGAA;AGEA,MGAA,IGAY,MGAA,KGAU,MGAtB;AGAA,iBGAA;OGFA;AGIA,MGAA,IGAG,MGAA,CGAO,MGAP,KGAmB,QGAnB,IGA+B,IGAC,CGAA,UGAD,CGAY,MGAZ,CGAlC;AGEC,QGAA,IGAK,CGAA,GGAA,CGAL,GGAY,IGAC,CGAA,KGAD,CGAO,MGAP,CGAZ,CGFD;OGAA,MGAA;AGOC,QGAA,IGAG,MGAA,CGAO,MGAP,KGAmB,QGAnB,IGA+B,IGAC,CGAA,UGAD,CGAY,MGAZ,CGAlC;AGEC,UGAA,IGAK,CGAA,GGAA,CGAL,GGAY,IGAC,CGAA,KGAD,CGAO,MGAP,CGAZ,CGFD;SGAA,MGAA;AGMC,UGAA,IGAC,CGAA,YGAD,CGAc,MGAd,EGAsB,MGAtB,CGAA,CGND;SGPD;OGND;AGAA,KGFA;WGsBA,KGxBa;EGAA,CG5Cd;AGsEA;AGAA;;KGtEA;AGAA,EGyEA,QGAA,EGAU,SGAC,IGAD,EGAO,SGAP,GGAA;WGET,IGAC,CGAA,YGAD,CGAc,IGAC,CGAA,KGAD,CGAO,IGAP,CGAd,EGA4B,SGA5B,EGFS;EGAA,CGzEV;AGAA,EG6EA,MGAA,EGAQ,SGAC,IGAD,EGAO,QGAP,GGAA;WGEP,IGAC,CGAA,UGAD,CGAY,IGAC,CGAA,KGAD,CGAO,IGAP,CGAZ,EGA0B,QGA1B,EGFO;EGAA,CG7ER;AGAA,EGkFA,UGAA,EGAY,SGAC,IGAD,EGAO,QGAP,GGAA;AGEX,QGAA,mBGAA;AGAA,IGAA,IGAe,CGAI,IGAC,CGAA,YGAD,CGAc,QGAd,CGAJ,IGA+B,CGAI,IGAC,CGAA,YGAD,CGAc,IGAd,CGAlD;AGAA,aGAO,IGAP,CGAA;KGAA;AGEA,SGAA,eGAA;;6BGAA;AGEC,MGAA,IGAgB,MGAA,KGAY,MGA5B;AGAA,iBGAA;OGAA;AGEA,MGAA,IGAG,MGAA,CGAO,MGAP,KGAmB,QGAnB,IGA+B,IGAC,CGAA,UGAD,CGAY,MGAZ,CGAlC;AGEC,QGAA,IGAK,CGAA,GGAA,CGAL,GGAY,MGAZ,CGFD;OGAA,MGAA;AGQC,QGAA,MGAA,GGAS,IGAK,CGAA,GGAA,CGAd,CGAA;AGEA,QGAA,IGAG,MGAA,CGAO,MGAP,KGAmB,QGAnB,IGA+B,IGAC,CGAA,UGAD,CGAY,MGAZ,CGAlC;AGEC,UGAA,IGAK,CGAA,GGAA,CGAL,GGAY,IGAC,CGAA,KGAD,CGAO,MGAP,CGAZ,CGFD;SGAA,MGAA;AGMC,UGAA,IGAC,CGAA,UGAD,CGAY,MGAZ,EGAoB,MGApB,CGAA,CGND;SGVD;OGJD;AGAA,KGFA;WGwBA,KG1BW;EGAA,CGlFZ;AGAA,EG+GA,UGAA,EGAY,SGAC,GGAD,EGAM,MGAN,GGAA;AGEX,QGAA,uDGAA;AGAA,IGAA,OGAA,GGAU,EGAV,CGAA;AGEA,SGAA,cGAA;0BGAA;AGEC,MGAA,OGAQ,CGAA,IGAA,CGAR,GGAgB,EGAhB,CGFD;AGAA,KGFA;AGAA,IGMA,OGAQ,CGAA,MGAA,CGAR,GGAkB,EGNlB,CGAA;AGAA,IGQA,OGRA,CGAA;AGSA,SGAA,UGAA;qBGAA;AGEC,MGAA,SGAA,GGAY,KGAZ,CGAA;AGEA,WGAA,cGAA;4BGAA;AGEC,QGAA,IGAA,CGAO,KGAK,CGAC,OGAN,CGAc,IGAd,CGAP;AGEC,UGAA,IGAA,GGAO,CGAC,IGAD,CGAP,CGFD;SGAA;AGIA,aGAA,2CGAA;yBGAA;AGEC,UGAA,IGAG,MGAA,CGAO,GGAP,KGAc,QGAjB;AGEC,YGAA,IGAG,GGAA,KGAO,GGAV;AGEC,cGAA,SGAA,GGAY,IGAZ,CGFD;aGFD;WGAA,MGMK,IGAG,GGAA,YGAe,MGAlB;AGEJ,YGAA,IGAG,GGAG,CGAC,IGAJ,CGAS,GGAT,CGAH;AGEC,cGAA,SGAA,GGAY,IGAZ,CGFD;aGFI;WGAA,MGMA,IGAG,GGAA,YGAe,QGAlB;AGEJ,YGAA,IGAG,GGAA,CGAI,GGAJ,CGAH;AGEC,cGAA,SGAA,GGAY,IGAZ,CGFD;aGFI;WGAA,MGAA;AGQJ,kBGAM,KGAA,CGAM,kEGAN,CGAN,CGRI;WGZL;AGuBA,UGAA,IGAG,SGAH;AGEC,YGAA,OGAQ,CGAA,IGAA,CGAM,CGAA,GGAA,CGAd,GGAqB,GGArB,CGAA;AGAA,YGEA,YGFA,CGFD;WGzBD;AGAA,SGND;AGAA,OGFA;AGAA,MGuCA,OGAQ,CGAA,MGAA,CGAQ,CGAA,GGAA,CGAhB,GGAuB,GGvCvB,CGFD;AGAA,KGTA;WGoDA,QGtDW;EGAA,CG/GZ;CAJD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/string.js b/node_modules/utila/scripts/js/lib/string.js
new file mode 100644
index 000000000..d49a48ea2
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/string.js
@@ -0,0 +1,15 @@
+module.exports = {
+  pad: function(n, width, z) {
+    if (z == null) {
+      z = '0';
+    }
+    n = n + '';
+    if (n.length >= width) {
+      return n;
+    } else {
+      return new Array(width - n.length + 1).join(z) + n;
+    }
+  }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string.js","sourceRoot":"..\\..","sources":["coffee\\lib\\string.coffee"],"names":[],"mappings":"AIAA,MIAM,CIAC,OIAP,GIKC;AIAA,EIAA,GIAA,EIAK,SIAC,CIAD,EIAI,KIAJ,EIAW,CIAX,GIAA;;MIAW,IIAI;KIEnB;AIAA,IIAA,CIAA,GIAI,CIAA,GIAI,EIAR,CIAA;AIEA,IIAA,IIAG,CIAC,CIAC,MIAF,IIAY,KIAf;aIEC,EIFD;KIAA,MIAA;aIMK,IIAA,KIAA,CIAM,KIAA,GIAQ,CIAC,CIAC,MIAV,GIAmB,CIAzB,CIA2B,CIAC,IIA5B,CIAiC,CIAjC,CIAJ,GIA0C,EIN3C;KIJI;EIAA,CIAL;CALD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/lib/utila.js b/node_modules/utila/scripts/js/lib/utila.js
new file mode 100644
index 000000000..c81012b0a
--- /dev/null
+++ b/node_modules/utila/scripts/js/lib/utila.js
@@ -0,0 +1,11 @@
+var utila;
+
+module.exports = utila = {
+  array: require('./array'),
+  classic: require('./classic'),
+  object: require('./object'),
+  string: require('./string'),
+  Emitter: require('./Emitter')
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utila.js","sourceRoot":"..\\..","sources":["coffee\\lib\\utila.coffee"],"names":[],"mappings":"AAAA,IAAA,KAAA;;AKAA,MKAM,CKAC,OKAP,GKAiB,KKAA,GKEhB;AKAA,EKAA,KKAA,EKAO,OKAA,CKAQ,SKAR,CKAP;AKAA,EKCA,OKAA,EKAS,OKAA,CKAQ,WKAR,CKDT;AKAA,EKEA,MKAA,EKAQ,OKAA,CKAQ,UKAR,CKFR;AKAA,EKGA,MKAA,EKAQ,OKAA,CKAQ,UKAR,CKHR;AKAA,EKIA,OKAA,EKAS,OKAA,CKAQ,WKAR,CKJT;CAFD,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n","module.exports = utila =\n\n\tarray: require './array'\n\tclassic: require './classic'\n\tobject: require './object'\n\tstring: require './string'\n\tEmitter: require './Emitter'"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/test/_prepare.js b/node_modules/utila/scripts/js/test/_prepare.js
new file mode 100644
index 000000000..0489e2e58
--- /dev/null
+++ b/node_modules/utila/scripts/js/test/_prepare.js
@@ -0,0 +1,9 @@
+var path, pathToLib;
+
+path = require('path');
+
+pathToLib = path.resolve(__dirname, '../lib');
+
+require('little-popo')(pathToLib);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_prepare.js","sourceRoot":"..\\..","sources":["coffee\\test\\_prepare.coffee"],"names":[],"mappings":"AAAA,IAAA,eAAA;;ASAA,ISAA,GSAO,OSAA,CSAQ,MSAR,CAAP,CAAA;;ASEA,SSAA,GSAY,ISAI,CSAC,OSAL,CSAa,SSAb,ESAwB,QSAxB,CAFZ,CAAA;;ASIA,OSAA,CSAQ,aSAR,CSAA,CSAuB,SSAvB,CAJA,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n","module.exports = utila =\n\n\tarray: require './array'\n\tclassic: require './classic'\n\tobject: require './object'\n\tstring: require './string'\n\tEmitter: require './Emitter'","module.exports = common =\n\n\t###\n\tChecks to see if o is an object, and it isn't an instance\n\tof some class.\n\t###\n\tisBareObject: (o) ->\n\n\t\tif o? and o.constructor is Object\n\n\t\t\treturn true\n\n\t\tfalse\n\n\t###\n\tReturns type of an object, including:\n\tundefined, null, string, number, array,\n\targuments, element, textnode, whitespace, and object\n\t###\n\ttypeOf: (item) ->\n\n\t\treturn 'null' if item is null\n\n\t\treturn typeof item if typeof item isnt 'object'\n\n\t\treturn 'array' if Array.isArray item\n\n\t\t# From MooTools\n\t\t# - do we even need this?\n\t\tif item.nodeName\n\n\t\t\tif item.nodeType is 1 then return 'element'\n\t\t\tif item.nodeType is 3 then return (/\\S/).test(item.nodeValue) ? 'textnode' : 'whitespace'\n\n\t\telse if typeof item.length is 'number'\n\n\t\t\tif item.callee then return 'arguments'\n\n\t\treturn typeof item\n\n\t# Deep clone of any variable.\n\t# From MooTools\n\tclone: (item, includePrototype = false) ->\n\n\t\tswitch common.typeOf item\n\n\t\t\twhen 'array' then return common._cloneArray item, includePrototype\n\n\t\t\twhen 'object' then return common._cloneObject item, includePrototype\n\n\t\t\telse return item\n\n\t###\n\tDeep clone of an object.\n\tFrom MooTools\n\t###\n\t_cloneObject: (o, includePrototype = false) ->\n\n\t\tif common.isBareObject o\n\n\t\t\tclone = {}\n\n\t\t\tfor key of o\n\n\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\treturn clone\n\n\t\telse\n\n\t\t\treturn o unless includePrototype\n\n\t\t\treturn o if o instanceof Function\n\n\t\t\tclone = Object.create o.constructor.prototype\n\n\t\t\tfor key of o\n\n\t\t\t\tif o.hasOwnProperty key\n\n\t\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\tclone\n\n\t###\n\tDeep clone of an array.\n\tFrom MooTools\n\t###\n\t_cloneArray: (a, includePrototype = false) ->\n\n\t\ti = a.length\n\n\t\tclone = new Array i\n\n\t\twhile i--\n\n\t\t\tclone[i] = common.clone a[i], includePrototype\n\n\t\tclone","require './_prepare'\n\narray = mod 'array'\n\ntest 'from', ->\n\n\tarray.from([1]).should.be.an.instanceOf Array\n\tarray.from([1])[0].should.equal 1\n\n# test 'clone', ->\n\n# \ta = [0, 1, 2]\n\n# \tb = array.clone a\n\n# \tb[0].should.equal 0\n# \tb[1].should.equal 1\n\n# \tb[0] = 3\n\n# \ta[0].should.equal 0\n\ntest 'pluck', ->\n\n\ta = [0, 1, 2, 3]\n\n\tafter = array.pluck a, 1\n\n\tafter.length.should.equal 3\n\n\tafter[0].should.equal 0\n\tafter[1].should.equal 2\n\tafter[2].should.equal 3\n\tafter.should.equal a\n\ntest 'pluckMultiple', ->\n\n\ta = [0, 1, 2, 3, 4, 5, 6]\n\n\tarray.pluckMultiple a, [0, 4, 2, 6]\n\n\ta.length.should.equal 3\n\ta[0].should.equal 1\n\ta[1].should.equal 3\n\ta[2].should.equal 5\n\ntest 'pluckItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 4\n\n\tarray.pluckItem([1], 2).length.should.equal 1\n\n\ntest 'pluckOneItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckOneItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 2\n\ta[4].should.equal 4\n\ta[5].should.equal 2\n\n\ta = [1, 2]\n\n\tarray.pluckOneItem a, 1\n\n\ta.length.should.equal 1\n\ta[0].should.equal 2\n\n\tarray.pluckOneItem([], 1).length.should.equal 0\n\n\tarray.pluckOneItem([1], 2).length.should.equal 1\n\ntest 'plcukByCallback', ->\n\n\ta = [0, 1, 2, 3]\n\n\tarray.pluckByCallback a, (val, i) ->\n\n\t\treturn yes if val is 2\n\n\t\treturn no\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ntest 'injectByCallback', ->\n\n\tshouldInject = (valA, valB, toInject) ->\n\n\t\tunless valA?\n\n\t\t\treturn yes if toInject <= valB\n\n\t\t\treturn no\n\n\t\tunless valB?\n\n\t\t\treturn yes if valA <= toInject\n\n\t\t\treturn no\n\n\t\treturn yes if valA <= toInject <= valB\n\n\t\treturn no\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 0, shouldInject\n\n\ta[0].should.equal 0\n\ta[1].should.equal 0.5\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 2.7, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.7\n\ta[5].should.equal 2.75\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 3.2, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.75\n\ta[6].should.equal 3\n\ta[7].should.equal 3.2","require './_prepare'\n\nobject = mod 'object'\n\ntest 'isBareObject', ->\n\n\tobject.isBareObject('a').should.equal false\n\n\tobject.isBareObject({'a': 'a'}).should.equal true\n\ntest 'typeOf', ->\n\n\tobject.typeOf('s').should.equal 'string'\n\tobject.typeOf(0).should.equal 'number'\n\tobject.typeOf(false).should.equal 'boolean'\n\tobject.typeOf({}).should.equal 'object'\n\tobject.typeOf(arguments).should.equal 'arguments'\n\tobject.typeOf([]).should.equal 'array'\n\ntest 'empty', ->\n\n\to =\n\n\t\ta: 1\n\t\tb: 2\n\n\n\tobject.empty o\n\n\to.should.not.have.property 'a'\n\to.should.not.have.property 'b'\n\ntest 'fastEmpty', ->\n\n\to =\n\t\ta: 1\n\t\tb: 2\n\n\n\tobject.fastEmpty o\n\n\to.should.not.have.property 'a'\n\to.should.not.have.property 'b'\n\ntest 'clone', ->\n\n\tobject.clone([1])[0].should.equal 1\n\tobject.clone({a:1}).a.should.equal 1\n\n\to = {a: 1}\n\n\tobject.clone(o).should.not.equal o\n\ntest 'clone [include prototype]', ->\n\n\tclass C\n\n\t\tconstructor: (@a) ->\n\n\t\tsayA: -> @a + 'a'\n\n\ta = new C 'a'\n\n\ta.sayA().should.equal 'aa'\n\n\tb = object.clone a, yes\n\n\tb.should.not.equal a\n\n\tb.constructor.should.equal C\n\n\tb.a.should.equal 'a'\n\n\tb.a = 'a2'\n\n\tb.sayA().should.equal 'a2a'\n\ntest 'clone [without prototype]', ->\n\n\tclass C\n\n\t\tconstructor: (@a) ->\n\n\t\tsayA: -> @a + 'a'\n\n\ta = new C 'a'\n\n\ta.sayA().should.equal 'aa'\n\n\tb = object.clone a, no\n\n\tb.should.equal a\n\ntest 'overrideOnto [basic]', ->\n\n\tonto =\n\t\ta: 'a'\n\t\tb:\n\t\t\tc: 'c'\n\t\t\td:\n\t\t\t\te: 'e'\n\n\twhat =\n\t\ta: 'a2'\n\t\tb:\n\t\t\tc: 'c2'\n\t\t\td:\n\t\t\t\tf: 'f2'\n\n\tobject.overrideOnto onto, what\n\n\tonto.a.should.equal 'a2'\n\tonto.b.should.have.property 'c'\n\tonto.b.c.should.equal 'c2'\n\tonto.b.d.should.not.have.property 'f'\n\tonto.b.d.e.should.equal 'e'\n\ntest 'override', ->\n\n\tonto =\n\n\t\ta: 'a'\n\n\t\tb:\n\n\t\t\tc: 'c'\n\n\t\t\td:\n\n\t\t\t\te: 'e'\n\n\twhat =\n\n\t\ta: 'a2'\n\n\t\tb:\n\n\t\t\tc: 'c2'\n\n\t\t\td:\n\n\t\t\t\tf: 'f2'\n\n\n\tonto2 = object.override onto, what\n\n\tonto2.a.should.equal 'a2'\n\tonto2.b.should.have.property 'c'\n\tonto2.b.c.should.equal 'c2'\n\tonto2.b.d.should.not.have.property 'f'\n\tonto2.b.d.e.should.equal 'e'\n\n\tonto.should.not.equal onto2\n\ndo ->\n\n\twhat =\n\n\t\ta: 'a2'\n\n\t\tc: ->\n\n\t\tz: 'z'\n\n\t\ty:\n\n\t\t\ta: 'a'\n\n\tonto =\n\n\t\ta: 'a'\n\n\t\tb: 'b'\n\n\ttest 'appendOnto [basic]', ->\n\n\t\tobject.appendOnto onto, what\n\n\t\tonto.a.should.equal 'a2'\n\t\tonto.b.should.equal 'b'\n\t\tonto.z.should.equal 'z'\n\n\ttest \"appendOnto [shallow copies instances]\", ->\n\n\t\tonto.c.should.be.instanceof Function\n\t\tonto.c.should.equal what.c\n\n\n\ttest \"appendOnto [clones objects]\", ->\n\n\t\tonto.should.have.property 'y'\n\t\tonto.y.a.should.equal 'a'\n\t\tonto.y.should.not.equal what.y\n\ntest 'groupProps', ->\n\n\tobj =\n\n\t\ta1: '1'\n\t\ta2: '2'\n\n\t\tb1: '1'\n\t\tb2: '2'\n\n\t\tc1: '1'\n\t\tc2: '2'\n\n\t\trest1: '1'\n\t\trest2: '2'\n\n\tgroups = object.groupProps obj,\n\n\t\ta: ['a1', 'a2']\n\n\t\tb: [/^b[0-9]+$/]\n\n\t\tc: (key) -> key[0] is 'c'\n\n\tgroups.a.should.have.property 'a1'\n\tgroups.a.a1.should.equal '1'\n\n\tgroups.a.should.have.property 'a2'\n\n\tgroups.b.should.have.property 'b1'\n\tgroups.b.should.have.property 'b2'\n\n\tgroups.c.should.have.property 'c1'\n\tgroups.c.should.have.property 'c2'\n\n\tgroups.rest.should.have.property 'rest1'\n\tgroups.rest.should.have.property 'rest1'\n\n\tgroups.rest.should.not.have.property 'c1'","path = require 'path'\n\npathToLib = path.resolve __dirname, '../lib'\n\nrequire('little-popo')(pathToLib)"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/test/array.js b/node_modules/utila/scripts/js/test/array.js
new file mode 100644
index 000000000..febdfaa57
--- /dev/null
+++ b/node_modules/utila/scripts/js/test/array.js
@@ -0,0 +1,115 @@
+var array;
+
+require('./_prepare');
+
+array = mod('array');
+
+test('from', function() {
+  array.from([1]).should.be.an.instanceOf(Array);
+  return array.from([1])[0].should.equal(1);
+});
+
+test('pluck', function() {
+  var a, after;
+  a = [0, 1, 2, 3];
+  after = array.pluck(a, 1);
+  after.length.should.equal(3);
+  after[0].should.equal(0);
+  after[1].should.equal(2);
+  after[2].should.equal(3);
+  return after.should.equal(a);
+});
+
+test('pluckMultiple', function() {
+  var a;
+  a = [0, 1, 2, 3, 4, 5, 6];
+  array.pluckMultiple(a, [0, 4, 2, 6]);
+  a.length.should.equal(3);
+  a[0].should.equal(1);
+  a[1].should.equal(3);
+  return a[2].should.equal(5);
+});
+
+test('pluckItem', function() {
+  var a;
+  a = [0, 1, 2, 3, 2, 4, 2];
+  array.pluckItem(a, 2);
+  a[0].should.equal(0);
+  a[1].should.equal(1);
+  a[2].should.equal(3);
+  a[3].should.equal(4);
+  return array.pluckItem([1], 2).length.should.equal(1);
+});
+
+test('pluckOneItem', function() {
+  var a;
+  a = [0, 1, 2, 3, 2, 4, 2];
+  array.pluckOneItem(a, 2);
+  a[0].should.equal(0);
+  a[1].should.equal(1);
+  a[2].should.equal(3);
+  a[3].should.equal(2);
+  a[4].should.equal(4);
+  a[5].should.equal(2);
+  a = [1, 2];
+  array.pluckOneItem(a, 1);
+  a.length.should.equal(1);
+  a[0].should.equal(2);
+  array.pluckOneItem([], 1).length.should.equal(0);
+  return array.pluckOneItem([1], 2).length.should.equal(1);
+});
+
+test('plcukByCallback', function() {
+  var a;
+  a = [0, 1, 2, 3];
+  array.pluckByCallback(a, function(val, i) {
+    if (val === 2) {
+      return true;
+    }
+    return false;
+  });
+  a[0].should.equal(0);
+  a[1].should.equal(1);
+  return a[2].should.equal(3);
+});
+
+test('injectByCallback', function() {
+  var a, shouldInject;
+  shouldInject = function(valA, valB, toInject) {
+    if (valA == null) {
+      if (toInject <= valB) {
+        return true;
+      }
+      return false;
+    }
+    if (valB == null) {
+      if (valA <= toInject) {
+        return true;
+      }
+      return false;
+    }
+    if ((valA <= toInject && toInject <= valB)) {
+      return true;
+    }
+    return false;
+  };
+  a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3];
+  array.injectByCallback(a, 0, shouldInject);
+  a[0].should.equal(0);
+  a[1].should.equal(0.5);
+  a[7].should.equal(3);
+  a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3];
+  array.injectByCallback(a, 2.7, shouldInject);
+  a[0].should.equal(0.5);
+  a[4].should.equal(2.7);
+  a[5].should.equal(2.75);
+  a[7].should.equal(3);
+  a = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3];
+  array.injectByCallback(a, 3.2, shouldInject);
+  a[0].should.equal(0.5);
+  a[4].should.equal(2.75);
+  a[6].should.equal(3);
+  return a[7].should.equal(3.2);
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.js","sourceRoot":"..\\..","sources":["coffee\\test\\array.coffee"],"names":[],"mappings":"AAAA,IAAA,KAAA;;AOAA,OOAA,COAQ,YOAR,CAAA,CAAA;;AOEA,KOAA,GOAQ,GOAA,COAI,OOAJ,CAFR,CAAA;;AOIA,IOAA,COAK,MOAL,EOAa,SOAA,GOAA;AOEZ,EOAA,KOAK,COAC,IOAN,COAW,COAC,COAD,COAX,COAe,COAC,MOAM,COAC,EOAE,COAC,EOAE,COAC,UOA7B,COAwC,KOAxC,COAA,COAA;SOCA,KOAK,COAC,IOAN,COAW,COAC,COAD,COAX,COAgB,COAA,COAA,COAE,COAC,MOAM,COAC,KOA1B,COAgC,COAhC,EOHY;AOAA,COAb,CAJA,CAAA;;AOsBA,IOAA,COAK,OOAL,EOAc,SOAA,GOAA;AOEb,MOAA,QOAA;AOAA,EOAA,COAA,GOAI,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,COAJ,COAA;AOAA,EOEA,KOAA,GOAQ,KOAK,COAC,KOAN,COAY,COAZ,EOAe,COAf,COFR,COAA;AOAA,EOIA,KOAK,COAC,MOAM,COAC,MOAM,COAC,KOApB,COA0B,COA1B,COJA,COAA;AOAA,EOMA,KOAM,COAA,COAA,COAE,COAC,MOAM,COAC,KOAhB,COAsB,COAtB,CONA,COAA;AOAA,EOOA,KOAM,COAA,COAA,COAE,COAC,MOAM,COAC,KOAhB,COAsB,COAtB,COPA,COAA;AOAA,EOQA,KOAM,COAA,COAA,COAE,COAC,MOAM,COAC,KOAhB,COAsB,COAtB,CORA,COAA;SOSA,KOAK,COAC,MOAM,COAC,KOAb,COAmB,COAnB,EOXa;AOAA,COAd,CAtBA,CAAA;;AOmCA,IOAA,COAK,eOAL,EOAsB,SOAA,GOAA;AOErB,MOAA,COAA;AOAA,EOAA,COAA,GOAI,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,EOAa,COAb,EOAgB,COAhB,EOAmB,COAnB,COAJ,COAA;AOAA,EOEA,KOAK,COAC,aOAN,COAoB,COApB,EOAuB,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,COAvB,COFA,COAA;AOAA,EOIA,COAC,COAC,MOAM,COAC,MOAM,COAC,KOAhB,COAsB,COAtB,COJA,COAA;AOAA,EOKA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COLA,COAA;AOAA,EOMA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,CONA,COAA;SOOA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,EOTqB;AOAA,COAtB,CAnCA,CAAA;;AO8CA,IOAA,COAK,WOAL,EOAkB,SOAA,GOAA;AOEjB,MOAA,COAA;AOAA,EOAA,COAA,GOAI,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,EOAa,COAb,EOAgB,COAhB,EOAmB,COAnB,COAJ,COAA;AOAA,EOEA,KOAK,COAC,SOAN,COAgB,COAhB,EOAmB,COAnB,COFA,COAA;AOAA,EOIA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COJA,COAA;AOAA,EOKA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COLA,COAA;AOAA,EOMA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,CONA,COAA;AOAA,EOOA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COPA,COAA;SOSA,KOAK,COAC,SOAN,COAgB,COAC,COAD,COAhB,EOAqB,COArB,COAuB,COAC,MOAM,COAC,MOAM,COAC,KOAtC,COA4C,COA5C,EOXiB;AOAA,COAlB,CA9CA,CAAA;;AO4DA,IOAA,COAK,cOAL,EOAqB,SOAA,GOAA;AOEpB,MOAA,COAA;AOAA,EOAA,COAA,GOAI,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,EOAa,COAb,EOAgB,COAhB,EOAmB,COAnB,COAJ,COAA;AOAA,EOEA,KOAK,COAC,YOAN,COAmB,COAnB,EOAsB,COAtB,COFA,COAA;AOAA,EOIA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COJA,COAA;AOAA,EOKA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COLA,COAA;AOAA,EOMA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,CONA,COAA;AOAA,EOOA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COPA,COAA;AOAA,EOQA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,CORA,COAA;AOAA,EOSA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COTA,COAA;AOAA,EOWA,COAA,GOAI,COAC,COAD,EOAI,COAJ,COXJ,COAA;AOAA,EOaA,KOAK,COAC,YOAN,COAmB,COAnB,EOAsB,COAtB,CObA,COAA;AOAA,EOeA,COAC,COAC,MOAM,COAC,MOAM,COAC,KOAhB,COAsB,COAtB,COfA,COAA;AOAA,EOgBA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COhBA,COAA;AOAA,EOkBA,KOAK,COAC,YOAN,COAmB,EOAnB,EOAuB,COAvB,COAyB,COAC,MOAM,COAC,MOAM,COAC,KOAxC,COA8C,COA9C,COlBA,COAA;SOoBA,KOAK,COAC,YOAN,COAmB,COAC,COAD,COAnB,EOAwB,COAxB,COA0B,COAC,MOAM,COAC,MOAM,COAC,KOAzC,COA+C,COA/C,EOtBoB;AOAA,COArB,CA5DA,CAAA;;AOoFA,IOAA,COAK,iBOAL,EOAwB,SOAA,GOAA;AOEvB,MOAA,COAA;AOAA,EOAA,COAA,GOAI,COAC,COAD,EOAI,COAJ,EOAO,COAP,EOAU,COAV,COAJ,COAA;AOAA,EOEA,KOAK,COAC,eOAN,COAsB,COAtB,EOAyB,SOAC,GOAD,EOAM,COAN,GOAA;AOExB,IOAA,IOAc,GOAA,KOAO,COArB;AOAA,aOAO,IOAP,COAA;KOAA;AOEA,WOAO,KOAP,COJwB;EOAA,COAzB,COFA,COAA;AOAA,EOQA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,CORA,COAA;AOAA,EOSA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COTA,COAA;SOUA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,EOZuB;AOAA,COAxB,CApFA,CAAA;;AOkGA,IOAA,COAK,kBOAL,EOAyB,SOAA,GOAA;AOExB,MOAA,eOAA;AOAA,EOAA,YOAA,GOAe,SOAC,IOAD,EOAO,IOAP,EOAa,QOAb,GOAA;AOEd,IOAA,IOAO,YOAP;AOEC,MOAA,IOAc,QOAA,IOAY,IOA1B;AOAA,eOAO,IOAP,COAA;OOAA;AOEA,aOAO,KOAP,COJD;KOAA;AOMA,IOAA,IOAO,YOAP;AOEC,MOAA,IOAc,IOAA,IOAQ,QOAtB;AOAA,eOAO,IOAP,COAA;OOAA;AOEA,aOAO,KOAP,COJD;KONA;AOYA,IOAA,IOAc,COAA,IOAA,IOAQ,QOAR,IOAQ,QOAR,IOAoB,IOApB,COAd;AOAA,aOAO,IOAP,COAA;KOZA;AOcA,WOAO,KOAP,COhBc;EOAA,COAf,COAA;AOAA,EOkBA,COAA,GOAI,COAC,GOAD,EOAM,COAN,EOAS,GOAT,EOAc,GOAd,EOAmB,IOAnB,EOAyB,IOAzB,EOA+B,COA/B,COlBJ,COAA;AOAA,EOoBA,KOAK,COAC,gBOAN,COAuB,COAvB,EOA0B,COA1B,EOA6B,YOA7B,COpBA,COAA;AOAA,EOsBA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COtBA,COAA;AOAA,EOuBA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,GOAlB,COvBA,COAA;AOAA,EOwBA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COxBA,COAA;AOAA,EO0BA,COAA,GOAI,COAC,GOAD,EOAM,COAN,EOAS,GOAT,EOAc,GOAd,EOAmB,IOAnB,EOAyB,IOAzB,EOA+B,COA/B,CO1BJ,COAA;AOAA,EO4BA,KOAK,COAC,gBOAN,COAuB,COAvB,EOA0B,GOA1B,EOA+B,YOA/B,CO5BA,COAA;AOAA,EO8BA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,GOAlB,CO9BA,COAA;AOAA,EO+BA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,GOAlB,CO/BA,COAA;AOAA,EOgCA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,IOAlB,COhCA,COAA;AOAA,EOiCA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COjCA,COAA;AOAA,EOmCA,COAA,GOAI,COAC,GOAD,EOAM,COAN,EOAS,GOAT,EOAc,GOAd,EOAmB,IOAnB,EOAyB,IOAzB,EOA+B,COA/B,COnCJ,COAA;AOAA,EOqCA,KOAK,COAC,gBOAN,COAuB,COAvB,EOA0B,GOA1B,EOA+B,YOA/B,COrCA,COAA;AOAA,EOuCA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,GOAlB,COvCA,COAA;AOAA,EOwCA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,IOAlB,COxCA,COAA;AOAA,EOyCA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,COAlB,COzCA,COAA;SO0CA,COAE,COAA,COAA,COAE,COAC,MOAM,COAC,KOAZ,COAkB,GOAlB,EO5CwB;AOAA,COAzB,CAlGA,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n","module.exports = utila =\n\n\tarray: require './array'\n\tclassic: require './classic'\n\tobject: require './object'\n\tstring: require './string'\n\tEmitter: require './Emitter'","module.exports = common =\n\n\t###\n\tChecks to see if o is an object, and it isn't an instance\n\tof some class.\n\t###\n\tisBareObject: (o) ->\n\n\t\tif o? and o.constructor is Object\n\n\t\t\treturn true\n\n\t\tfalse\n\n\t###\n\tReturns type of an object, including:\n\tundefined, null, string, number, array,\n\targuments, element, textnode, whitespace, and object\n\t###\n\ttypeOf: (item) ->\n\n\t\treturn 'null' if item is null\n\n\t\treturn typeof item if typeof item isnt 'object'\n\n\t\treturn 'array' if Array.isArray item\n\n\t\t# From MooTools\n\t\t# - do we even need this?\n\t\tif item.nodeName\n\n\t\t\tif item.nodeType is 1 then return 'element'\n\t\t\tif item.nodeType is 3 then return (/\\S/).test(item.nodeValue) ? 'textnode' : 'whitespace'\n\n\t\telse if typeof item.length is 'number'\n\n\t\t\tif item.callee then return 'arguments'\n\n\t\treturn typeof item\n\n\t# Deep clone of any variable.\n\t# From MooTools\n\tclone: (item, includePrototype = false) ->\n\n\t\tswitch common.typeOf item\n\n\t\t\twhen 'array' then return common._cloneArray item, includePrototype\n\n\t\t\twhen 'object' then return common._cloneObject item, includePrototype\n\n\t\t\telse return item\n\n\t###\n\tDeep clone of an object.\n\tFrom MooTools\n\t###\n\t_cloneObject: (o, includePrototype = false) ->\n\n\t\tif common.isBareObject o\n\n\t\t\tclone = {}\n\n\t\t\tfor key of o\n\n\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\treturn clone\n\n\t\telse\n\n\t\t\treturn o unless includePrototype\n\n\t\t\treturn o if o instanceof Function\n\n\t\t\tclone = Object.create o.constructor.prototype\n\n\t\t\tfor key of o\n\n\t\t\t\tif o.hasOwnProperty key\n\n\t\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\tclone\n\n\t###\n\tDeep clone of an array.\n\tFrom MooTools\n\t###\n\t_cloneArray: (a, includePrototype = false) ->\n\n\t\ti = a.length\n\n\t\tclone = new Array i\n\n\t\twhile i--\n\n\t\t\tclone[i] = common.clone a[i], includePrototype\n\n\t\tclone","require './_prepare'\n\narray = mod 'array'\n\ntest 'from', ->\n\n\tarray.from([1]).should.be.an.instanceOf Array\n\tarray.from([1])[0].should.equal 1\n\n# test 'clone', ->\n\n# \ta = [0, 1, 2]\n\n# \tb = array.clone a\n\n# \tb[0].should.equal 0\n# \tb[1].should.equal 1\n\n# \tb[0] = 3\n\n# \ta[0].should.equal 0\n\ntest 'pluck', ->\n\n\ta = [0, 1, 2, 3]\n\n\tafter = array.pluck a, 1\n\n\tafter.length.should.equal 3\n\n\tafter[0].should.equal 0\n\tafter[1].should.equal 2\n\tafter[2].should.equal 3\n\tafter.should.equal a\n\ntest 'pluckMultiple', ->\n\n\ta = [0, 1, 2, 3, 4, 5, 6]\n\n\tarray.pluckMultiple a, [0, 4, 2, 6]\n\n\ta.length.should.equal 3\n\ta[0].should.equal 1\n\ta[1].should.equal 3\n\ta[2].should.equal 5\n\ntest 'pluckItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 4\n\n\tarray.pluckItem([1], 2).length.should.equal 1\n\n\ntest 'pluckOneItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckOneItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 2\n\ta[4].should.equal 4\n\ta[5].should.equal 2\n\n\ta = [1, 2]\n\n\tarray.pluckOneItem a, 1\n\n\ta.length.should.equal 1\n\ta[0].should.equal 2\n\n\tarray.pluckOneItem([], 1).length.should.equal 0\n\n\tarray.pluckOneItem([1], 2).length.should.equal 1\n\ntest 'plcukByCallback', ->\n\n\ta = [0, 1, 2, 3]\n\n\tarray.pluckByCallback a, (val, i) ->\n\n\t\treturn yes if val is 2\n\n\t\treturn no\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ntest 'injectByCallback', ->\n\n\tshouldInject = (valA, valB, toInject) ->\n\n\t\tunless valA?\n\n\t\t\treturn yes if toInject <= valB\n\n\t\t\treturn no\n\n\t\tunless valB?\n\n\t\t\treturn yes if valA <= toInject\n\n\t\t\treturn no\n\n\t\treturn yes if valA <= toInject <= valB\n\n\t\treturn no\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 0, shouldInject\n\n\ta[0].should.equal 0\n\ta[1].should.equal 0.5\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 2.7, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.7\n\ta[5].should.equal 2.75\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 3.2, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.75\n\ta[6].should.equal 3\n\ta[7].should.equal 3.2"]}
\ No newline at end of file
diff --git a/node_modules/utila/scripts/js/test/object.js b/node_modules/utila/scripts/js/test/object.js
new file mode 100644
index 000000000..a430c616d
--- /dev/null
+++ b/node_modules/utila/scripts/js/test/object.js
@@ -0,0 +1,220 @@
+var object;
+
+require('./_prepare');
+
+object = mod('object');
+
+test('isBareObject', function() {
+  object.isBareObject('a').should.equal(false);
+  return object.isBareObject({
+    'a': 'a'
+  }).should.equal(true);
+});
+
+test('typeOf', function() {
+  object.typeOf('s').should.equal('string');
+  object.typeOf(0).should.equal('number');
+  object.typeOf(false).should.equal('boolean');
+  object.typeOf({}).should.equal('object');
+  object.typeOf(arguments).should.equal('arguments');
+  return object.typeOf([]).should.equal('array');
+});
+
+test('empty', function() {
+  var o;
+  o = {
+    a: 1,
+    b: 2
+  };
+  object.empty(o);
+  o.should.not.have.property('a');
+  return o.should.not.have.property('b');
+});
+
+test('fastEmpty', function() {
+  var o;
+  o = {
+    a: 1,
+    b: 2
+  };
+  object.fastEmpty(o);
+  o.should.not.have.property('a');
+  return o.should.not.have.property('b');
+});
+
+test('clone', function() {
+  var o;
+  object.clone([1])[0].should.equal(1);
+  object.clone({
+    a: 1
+  }).a.should.equal(1);
+  o = {
+    a: 1
+  };
+  return object.clone(o).should.not.equal(o);
+});
+
+test('clone [include prototype]', function() {
+  var C, a, b;
+  C = (function() {
+    function C(a) {
+      this.a = a;
+    }
+
+    C.prototype.sayA = function() {
+      return this.a + 'a';
+    };
+
+    return C;
+
+  })();
+  a = new C('a');
+  a.sayA().should.equal('aa');
+  b = object.clone(a, true);
+  b.should.not.equal(a);
+  b.constructor.should.equal(C);
+  b.a.should.equal('a');
+  b.a = 'a2';
+  return b.sayA().should.equal('a2a');
+});
+
+test('clone [without prototype]', function() {
+  var C, a, b;
+  C = (function() {
+    function C(a) {
+      this.a = a;
+    }
+
+    C.prototype.sayA = function() {
+      return this.a + 'a';
+    };
+
+    return C;
+
+  })();
+  a = new C('a');
+  a.sayA().should.equal('aa');
+  b = object.clone(a, false);
+  return b.should.equal(a);
+});
+
+test('overrideOnto [basic]', function() {
+  var onto, what;
+  onto = {
+    a: 'a',
+    b: {
+      c: 'c',
+      d: {
+        e: 'e'
+      }
+    }
+  };
+  what = {
+    a: 'a2',
+    b: {
+      c: 'c2',
+      d: {
+        f: 'f2'
+      }
+    }
+  };
+  object.overrideOnto(onto, what);
+  onto.a.should.equal('a2');
+  onto.b.should.have.property('c');
+  onto.b.c.should.equal('c2');
+  onto.b.d.should.not.have.property('f');
+  return onto.b.d.e.should.equal('e');
+});
+
+test('override', function() {
+  var onto, onto2, what;
+  onto = {
+    a: 'a',
+    b: {
+      c: 'c',
+      d: {
+        e: 'e'
+      }
+    }
+  };
+  what = {
+    a: 'a2',
+    b: {
+      c: 'c2',
+      d: {
+        f: 'f2'
+      }
+    }
+  };
+  onto2 = object.override(onto, what);
+  onto2.a.should.equal('a2');
+  onto2.b.should.have.property('c');
+  onto2.b.c.should.equal('c2');
+  onto2.b.d.should.not.have.property('f');
+  onto2.b.d.e.should.equal('e');
+  return onto.should.not.equal(onto2);
+});
+
+(function() {
+  var onto, what;
+  what = {
+    a: 'a2',
+    c: function() {},
+    z: 'z',
+    y: {
+      a: 'a'
+    }
+  };
+  onto = {
+    a: 'a',
+    b: 'b'
+  };
+  test('appendOnto [basic]', function() {
+    object.appendOnto(onto, what);
+    onto.a.should.equal('a2');
+    onto.b.should.equal('b');
+    return onto.z.should.equal('z');
+  });
+  test("appendOnto [shallow copies instances]", function() {
+    onto.c.should.be["instanceof"](Function);
+    return onto.c.should.equal(what.c);
+  });
+  return test("appendOnto [clones objects]", function() {
+    onto.should.have.property('y');
+    onto.y.a.should.equal('a');
+    return onto.y.should.not.equal(what.y);
+  });
+})();
+
+test('groupProps', function() {
+  var groups, obj;
+  obj = {
+    a1: '1',
+    a2: '2',
+    b1: '1',
+    b2: '2',
+    c1: '1',
+    c2: '2',
+    rest1: '1',
+    rest2: '2'
+  };
+  groups = object.groupProps(obj, {
+    a: ['a1', 'a2'],
+    b: [/^b[0-9]+$/],
+    c: function(key) {
+      return key[0] === 'c';
+    }
+  });
+  groups.a.should.have.property('a1');
+  groups.a.a1.should.equal('1');
+  groups.a.should.have.property('a2');
+  groups.b.should.have.property('b1');
+  groups.b.should.have.property('b2');
+  groups.c.should.have.property('c1');
+  groups.c.should.have.property('c2');
+  groups.rest.should.have.property('rest1');
+  groups.rest.should.have.property('rest1');
+  return groups.rest.should.not.have.property('c1');
+});
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.js","sourceRoot":"..\\..","sources":["coffee\\test\\object.coffee"],"names":[],"mappings":"AAAA,IAAA,MAAA;;AQAA,OQAA,CQAQ,YQAR,CAAA,CAAA;;AQEA,MQAA,GQAS,GQAA,CQAI,QQAJ,CAFT,CAAA;;AQIA,IQAA,CQAK,cQAL,EQAqB,SQAA,GQAA;AQEpB,EQAA,MQAM,CQAC,YQAP,CQAoB,GQApB,CQAwB,CQAC,MQAM,CQAC,KQAhC,CQAsC,KQAtC,CQAA,CQAA;SQEA,MQAM,CQAC,YQAP,CQAoB;AQAA,IQAC,GQAA,EQAK,GQAN;GQApB,CQA+B,CQAC,MQAM,CQAC,KQAvC,CQA6C,IQA7C,EQJoB;AQAA,CQArB,CAJA,CAAA;;AQUA,IQAA,CQAK,QQAL,EQAe,SQAA,GQAA;AQEd,EQAA,MQAM,CQAC,MQAP,CQAc,GQAd,CQAkB,CQAC,MQAM,CQAC,KQA1B,CQAgC,QQAhC,CQAA,CQAA;AQAA,EQCA,MQAM,CQAC,MQAP,CQAc,CQAd,CQAgB,CQAC,MQAM,CQAC,KQAxB,CQA8B,QQA9B,CQDA,CQAA;AQAA,EQEA,MQAM,CQAC,MQAP,CQAc,KQAd,CQAoB,CQAC,MQAM,CQAC,KQA5B,CQAkC,SQAlC,CQFA,CQAA;AQAA,EQGA,MQAM,CQAC,MQAP,CQAc,EQAd,CQAiB,CQAC,MQAM,CQAC,KQAzB,CQA+B,QQA/B,CQHA,CQAA;AQAA,EQIA,MQAM,CQAC,MQAP,CQAc,SQAd,CQAwB,CQAC,MQAM,CQAC,KQAhC,CQAsC,WQAtC,CQJA,CQAA;SQKA,MQAM,CQAC,MQAP,CQAc,EQAd,CQAiB,CQAC,MQAM,CQAC,KQAzB,CQA+B,OQA/B,EQPc;AQAA,CQAf,CAVA,CAAA;;AQmBA,IQAA,CQAK,OQAL,EQAc,SQAA,GQAA;AQEb,MQAA,CQAA;AQAA,EQAA,CQAA,GQEC;AQAA,IQAA,CQAA,EQAG,CQAH;AQAA,IQCA,CQAA,EQAG,CQDH;GQFD,CQAA;AQAA,EQMA,MQAM,CQAC,KQAP,CQAa,CQAb,CQNA,CQAA;AQAA,EQQA,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQAlB,CQA2B,GQA3B,CQRA,CQAA;SQSA,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQAlB,CQA2B,GQA3B,EQXa;AQAA,CQAd,CAnBA,CAAA;;AQgCA,IQAA,CQAK,WQAL,EQAkB,SQAA,GQAA;AQEjB,MQAA,CQAA;AQAA,EQAA,CQAA,GQCC;AQAA,IQAA,CQAA,EQAG,CQAH;AQAA,IQCA,CQAA,EQAG,CQDH;GQDD,CQAA;AQAA,EQKA,MQAM,CQAC,SQAP,CQAiB,CQAjB,CQLA,CQAA;AQAA,EQOA,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQAlB,CQA2B,GQA3B,CQPA,CQAA;SQQA,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQAlB,CQA2B,GQA3B,EQViB;AQAA,CQAlB,CAhCA,CAAA;;AQ4CA,IQAA,CQAK,OQAL,EQAc,SQAA,GQAA;AQEb,MQAA,CQAA;AQAA,EQAA,MQAM,CQAC,KQAP,CQAa,CQAC,CQAD,CQAb,CQAkB,CQAA,CQAA,CQAE,CQAC,MQAM,CQAC,KQA5B,CQAkC,CQAlC,CQAA,CQAA;AQAA,EQCA,MQAM,CQAC,KQAP,CQAa;AQAA,IQAC,CQAA,EQAE,CQAH;GQAb,CQAmB,CQAC,CQAC,CQAC,MQAM,CQAC,KQA7B,CQAmC,CQAnC,CQDA,CQAA;AQAA,EQGA,CQAA,GQAI;AQAA,IQAC,CQAA,EQAG,CQAJ;GQHJ,CQAA;SQKA,MQAM,CQAC,KQAP,CQAa,CQAb,CQAe,CQAC,MQAM,CQAC,GQAG,CQAC,KQA3B,CQAiC,CQAjC,EQPa;AQAA,CQAd,CA5CA,CAAA;;AQqDA,IQAA,CQAK,2BQAL,EQAkC,SQAA,GQAA;AQEjC,MQAA,OQAA;AQAA,EQAM;AQEQ,IQAA,WQAE,CQAF,GQAA;AQAM,MQAL,IQAC,CQAA,IQAA,CQAI,CQAN;IQAA,CQAb;;AQAA,gBQEA,IQAA,GQAM,SQAA,GQAA;aQAG,IQAC,CQAA,CQAD,GQAK,IQAR;IQAA,CQFN,CQAA;;aQAA;;MQFD,CQAA;AQAA,EQMA,CQAA,GQAQ,IQAA,CQAA,CQAE,GQAF,CQNR,CQAA;AQAA,EQQA,CQAC,CQAC,IQAF,CQAA,CQAQ,CQAC,MQAM,CQAC,KQAhB,CQAsB,IQAtB,CQRA,CQAA;AQAA,EQUA,CQAA,GQAI,MQAM,CQAC,KQAP,CQAa,CQAb,EQAgB,IQAhB,CQVJ,CQAA;AQAA,EQYA,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,KQAb,CQAmB,CQAnB,CQZA,CQAA;AQAA,EQcA,CQAC,CQAC,WQAW,CQAC,MQAM,CQAC,KQArB,CQA2B,CQA3B,CQdA,CQAA;AQAA,EQgBA,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAX,CQAiB,GQAjB,CQhBA,CQAA;AQAA,EQkBA,CQAC,CQAC,CQAF,GQAM,IQlBN,CQAA;SQoBA,CQAC,CQAC,IQAF,CQAA,CQAQ,CQAC,MQAM,CQAC,KQAhB,CQAsB,KQAtB,EQtBiC;AQAA,CQAlC,CArDA,CAAA;;AQ6EA,IQAA,CQAK,2BQAL,EQAkC,SQAA,GQAA;AQEjC,MQAA,OQAA;AQAA,EQAM;AQEQ,IQAA,WQAE,CQAF,GQAA;AQAM,MQAL,IQAC,CQAA,IQAA,CQAI,CQAN;IQAA,CQAb;;AQAA,gBQEA,IQAA,GQAM,SQAA,GQAA;aQAG,IQAC,CQAA,CQAD,GQAK,IQAR;IQAA,CQFN,CQAA;;aQAA;;MQFD,CQAA;AQAA,EQMA,CQAA,GQAQ,IQAA,CQAA,CQAE,GQAF,CQNR,CQAA;AQAA,EQQA,CQAC,CQAC,IQAF,CQAA,CQAQ,CQAC,MQAM,CQAC,KQAhB,CQAsB,IQAtB,CQRA,CQAA;AQAA,EQUA,CQAA,GQAI,MQAM,CQAC,KQAP,CQAa,CQAb,EQAgB,KQAhB,CQVJ,CQAA;SQYA,CQAC,CQAC,MQAM,CQAC,KQAT,CQAe,CQAf,EQdiC;AQAA,CQAlC,CA7EA,CAAA;;AQ6FA,IQAA,CQAK,sBQAL,EQA6B,SQAA,GQAA;AQE5B,MQAA,UQAA;AQAA,EQAA,IQAA,GQCC;AQAA,IQAA,CQAA,EQAG,GQAH;AQAA,IQCA,CQAA,EQCC;AQAA,MQAA,CQAA,EQAG,GQAH;AQAA,MQCA,CQAA,EQCC;AQAA,QQAA,CQAA,EQAG,GQAH;OQFD;KQFD;GQDD,CQAA;AQAA,EQOA,IQAA,GQCC;AQAA,IQAA,CQAA,EQAG,IQAH;AQAA,IQCA,CQAA,EQCC;AQAA,MQAA,CQAA,EQAG,IQAH;AQAA,MQCA,CQAA,EQCC;AQAA,QQAA,CQAA,EQAG,IQAH;OQFD;KQFD;GQRD,CQAA;AQAA,EQcA,MQAM,CQAC,YQAP,CQAoB,IQApB,EQA0B,IQA1B,CQdA,CQAA;AQAA,EQgBA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,KQAd,CQAoB,IQApB,CQhBA,CQAA;AQAA,EQiBA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQAnB,CQA4B,GQA5B,CQjBA,CQAA;AQAA,EQkBA,IQAI,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAhB,CQAsB,IQAtB,CQlBA,CQAA;AQAA,EQmBA,IQAI,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQAzB,CQAkC,GQAlC,CQnBA,CQAA;SQoBA,IQAI,CQAC,CQAC,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAlB,CQAwB,GQAxB,EQtB4B;AQAA,CQA7B,CA7FA,CAAA;;AQqHA,IQAA,CQAK,UQAL,EQAiB,SQAA,GQAA;AQEhB,MQAA,iBQAA;AQAA,EQAA,IQAA,GQEC;AQAA,IQAA,CQAA,EQAG,GQAH;AQAA,IQEA,CQAA,EQEC;AQAA,MQAA,CQAA,EQAG,GQAH;AQAA,MQEA,CQAA,EQEC;AQAA,QQAA,CQAA,EQAG,GQAH;OQJD;KQJD;GQFD,CQAA;AQAA,EQYA,IQAA,GQEC;AQAA,IQAA,CQAA,EQAG,IQAH;AQAA,IQEA,CQAA,EQEC;AQAA,MQAA,CQAA,EQAG,IQAH;AQAA,MQEA,CQAA,EQEC;AQAA,QQAA,CQAA,EQAG,IQAH;OQJD;KQJD;GQdD,CQAA;AQAA,EQyBA,KQAA,GQAQ,MQAM,CQAC,QQAP,CQAgB,IQAhB,EQAsB,IQAtB,CQzBR,CQAA;AQAA,EQ2BA,KQAK,CQAC,CQAC,CQAC,MQAM,CQAC,KQAf,CQAqB,IQArB,CQ3BA,CQAA;AQAA,EQ4BA,KQAK,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQApB,CQA6B,GQA7B,CQ5BA,CQAA;AQAA,EQ6BA,KQAK,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAjB,CQAuB,IQAvB,CQ7BA,CQAA;AQAA,EQ8BA,KQAK,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQA1B,CQAmC,GQAnC,CQ9BA,CQAA;AQAA,EQ+BA,KQAK,CQAC,CQAC,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAnB,CQAyB,GQAzB,CQ/BA,CQAA;SQiCA,IQAI,CQAC,MQAM,CQAC,GQAG,CQAC,KQAhB,CQAsB,KQAtB,EQnCgB;AQAA,CQAjB,CArHA,CAAA;;AQ0JG,CQAA,SQAA,GQAA;AQEF,MQAA,UQAA;AQAA,EQAA,IQAA,GQEC;AQAA,IQAA,CQAA,EQAG,IQAH;AQAA,IQEA,CQAA,EQAG,SQAA,GQAA,CQFH;AQAA,IQIA,CQAA,EQAG,GQJH;AQAA,IQMA,CQAA,EQEC;AQAA,MQAA,CQAA,EQAG,GQAH;KQRD;GQFD,CQAA;AQAA,EQYA,IQAA,GQEC;AQAA,IQAA,CQAA,EQAG,GQAH;AQAA,IQEA,CQAA,EQAG,GQFH;GQdD,CQAA;AQAA,EQkBA,IQAA,CQAK,oBQAL,EQA2B,SQAA,GQAA;AQE1B,IQAA,MQAM,CQAC,UQAP,CQAkB,IQAlB,EQAwB,IQAxB,CQAA,CQAA;AQAA,IQEA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,KQAd,CQAoB,IQApB,CQFA,CQAA;AQAA,IQGA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,KQAd,CQAoB,GQApB,CQHA,CQAA;WQIA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,KQAd,CQAoB,GQApB,EQN0B;EQAA,CQA3B,CQlBA,CQAA;AQAA,EQ0BA,IQAA,CQAK,uCQAL,EQA8C,SQAA,GQAA;AQE7C,IQAA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,EQAE,CQAC,YQAD,CQAhB,CQA4B,QQA5B,CQAA,CQAA;WQCA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,KQAd,CQAoB,IQAI,CQAC,CQAzB,EQH6C;EQAA,CQA9C,CQ1BA,CQAA;SQgCA,IQAA,CQAK,6BQAL,EQAoC,SQAA,GQAA;AQEnC,IQAA,IQAI,CQAC,MQAM,CQAC,IQAI,CQAC,QQAjB,CQA0B,GQA1B,CQAA,CQAA;AQAA,IQCA,IQAI,CQAC,CQAC,CQAC,CQAC,CQAC,MQAM,CQAC,KQAhB,CQAsB,GQAtB,CQDA,CQAA;WQEA,IQAI,CQAC,CQAC,CQAC,MQAM,CQAC,GQAG,CQAC,KQAlB,CQAwB,IQAI,CQAC,CQA7B,EQJmC;EQAA,CQApC,EQlCE;AQAA,CQAA,CQAH,CQAA,CA1JA,CAAA;;AQkMA,IQAA,CQAK,YQAL,EQAmB,SQAA,GQAA;AQElB,MQAA,WQAA;AQAA,EQAA,GQAA,GQEC;AQAA,IQAA,EQAA,EQAI,GQAJ;AQAA,IQCA,EQAA,EQAI,GQDJ;AQAA,IQGA,EQAA,EQAI,GQHJ;AQAA,IQIA,EQAA,EQAI,GQJJ;AQAA,IQMA,EQAA,EQAI,GQNJ;AQAA,IQOA,EQAA,EQAI,GQPJ;AQAA,IQSA,KQAA,EQAO,GQTP;AQAA,IQUA,KQAA,EQAO,GQVP;GQFD,CQAA;AQAA,EQcA,MQAA,GQAS,MQAM,CQAC,UQAP,CQAkB,GQAlB,EQER;AQAA,IQAA,CQAA,EQAG,CQAC,IQAD,EQAO,IQAP,CQAH;AQAA,IQEA,CQAA,EQAG,CQAC,WQAD,CQFH;AQAA,IQIA,CQAA,EQAG,SQAC,GQAD,GQAA;aQAS,GQAI,CQAA,CQAA,CQAJ,KQAU,IQAnB;IQAA,CQJH;GQFQ,CQdT,CQAA;AQAA,EQsBA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQtBA,CQAA;AQAA,EQuBA,MQAM,CQAC,CQAC,CQAC,EQAE,CQAC,MQAM,CQAC,KQAnB,CQAyB,GQAzB,CQvBA,CQAA;AQAA,EQyBA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQzBA,CQAA;AQAA,EQ2BA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQ3BA,CQAA;AQAA,EQ4BA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQ5BA,CQAA;AQAA,EQ8BA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQ9BA,CQAA;AQAA,EQ+BA,MQAM,CQAC,CQAC,CQAC,MQAM,CQAC,IQAI,CQAC,QQArB,CQA8B,IQA9B,CQ/BA,CQAA;AQAA,EQiCA,MQAM,CQAC,IQAI,CQAC,MQAM,CQAC,IQAI,CQAC,QQAxB,CQAiC,OQAjC,CQjCA,CQAA;AQAA,EQkCA,MQAM,CQAC,IQAI,CQAC,MQAM,CQAC,IQAI,CQAC,QQAxB,CQAiC,OQAjC,CQlCA,CQAA;SQoCA,MQAM,CQAC,IQAI,CQAC,MQAM,CQAC,GQAG,CQAC,IQAI,CQAC,QQA5B,CQAqC,IQArC,EQtCkB;AQAA,CQAnB,CAlMA,CAAA","sourcesContent":["module.exports = array =\n\n\t###\n\tTries to turn anything into an array.\n\t###\n\tfrom: (r) ->\n\n\t\tArray::slice.call r\n\n\t###\n\tClone of an array. Properties will be shallow copies.\n\t###\n\tsimpleClone: (a) ->\n\n\t\ta.slice 0\n\n\tshallowEqual: (a1, a2) ->\n\n\t\treturn no unless Array.isArray(a1) and Array.isArray(a2) and a1.length is a2.length\n\n\t\tfor val, i in a1\n\n\t\t\treturn no unless a2[i] is val\n\n\t\tyes\n\n\tpluck: (a, i) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tfor value, index in a\n\n\t\t\tif index > i\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1\n\n\t\ta\n\n\tpluckItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif value is item\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\ta.length = a.length - removed if removed > 0\n\n\t\ta\n\n\tpluckOneItem: (a, item) ->\n\n\t\treturn a if a.length < 1\n\n\t\treached = no\n\n\t\tfor value, index in a\n\n\t\t\tif not reached\n\n\t\t\t\tif value is item\n\n\t\t\t\t\treached = yes\n\n\t\t\t\t\tcontinue\n\n\t\t\telse\n\n\t\t\t\ta[index - 1] = a[index]\n\n\t\ta.length = a.length - 1 if reached\n\n\t\ta\n\n\tpluckByCallback: (a, cb) ->\n\n\t\treturn a if a.length < 1\n\n\t\tremoved = 0\n\n\t\tfor value, index in a\n\n\t\t\tif cb value, index\n\n\t\t\t\tremoved++\n\n\t\t\t\tcontinue\n\n\t\t\tif removed isnt 0\n\n\t\t\t\ta[index - removed] = a[index]\n\n\t\tif removed > 0\n\n\t\t\ta.length = a.length - removed\n\n\t\ta\n\n\tpluckMultiple: (array, indexesToRemove) ->\n\n\t\treturn array if array.length < 1\n\n\t\tremovedSoFar = 0\n\n\t\tindexesToRemove.sort()\n\n\t\tfor i in indexesToRemove\n\n\t\t\t@pluck array, i - removedSoFar\n\n\t\t\tremovedSoFar++\n\n\t\tarray\n\n\tinjectByCallback: (a, toInject, shouldInject) ->\n\n\t\tvalA = null\n\n\t\tvalB = null\n\n\t\tlen = a.length\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\n\t\tfor val, i in a\n\n\t\t\tvalA = valB\n\n\t\t\tvalB = val\n\n\t\t\tif shouldInject valA, valB, toInject\n\n\t\t\t\treturn a.splice i, 0, toInject\n\n\t\ta.push toInject\n\n\t\ta\n\n\tinjectInIndex: (a, index, toInject) ->\n\n\t\tlen = a.length\n\n\t\ti = index\n\n\t\tif len < 1\n\n\t\t\ta.push toInject\n\n\t\t\treturn a\n\n\t\ttoPut = toInject\n\n\t\ttoPutNext = null\n\n\t\t`for(; i <= len; i++){\n\n\t\t\ttoPutNext = a[i];\n\n\t\t\ta[i] = toPut;\n\n\t\t\ttoPut = toPutNext;\n\n\t\t}`\n\n\t\t# a[i] = toPut\n\n\t\tnull","module.exports = classic = {}\n\n# Little helper for mixins from CoffeeScript FAQ,\n# courtesy of Sethaurus (http://github.com/sethaurus)\nclassic.implement = (mixins..., classReference) ->\n\n\tfor mixin in mixins\n\n\t\tclassProto = classReference::\n\n\t\tfor member of mixin::\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference\n\nclassic.mix = (mixins..., classReference) ->\n\n\tclassProto = classReference::\n\n\tclassReference.__mixinCloners = []\n\n\tclassReference.__applyClonersFor = (instance, args = null) ->\n\n\t\tfor cloner in classReference.__mixinCloners\n\n\t\t\tcloner.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinInitializers = []\n\n\tclassReference.__initMixinsFor = (instance, args = null) ->\n\n\t\tfor initializer in classReference.__mixinInitializers\n\n\t\t\tinitializer.apply instance, args\n\n\t\treturn\n\n\tclassReference.__mixinQuitters = []\n\n\tclassReference.__applyQuittersFor = (instance, args = null) ->\n\n\t\tfor quitter in classReference.__mixinQuitters\n\n\t\t\tquitter.apply instance, args\n\n\t\treturn\n\n\tfor mixin in mixins\n\n\t\tunless mixin.constructor instanceof Function\n\n\t\t\tthrow Error \"Mixin should be a function\"\n\n\t\tfor member of mixin::\n\n\t\t\tif member.substr(0, 11) is '__initMixin'\n\n\t\t\t\tclassReference.__mixinInitializers.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 11) is '__clonerFor'\n\n\t\t\t\tclassReference.__mixinCloners.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\telse if member.substr(0, 12) is '__quitterFor'\n\n\t\t\t\tclassReference.__mixinQuitters.push mixin::[member]\n\n\t\t\t\tcontinue\n\n\t\t\tunless Object.getOwnPropertyDescriptor classProto, member\n\n\t\t\t\tdesc = Object.getOwnPropertyDescriptor mixin::, member\n\n\t\t\t\tObject.defineProperty classProto, member, desc\n\n\tclassReference","array = require './array'\r\n\r\nmodule.exports = class Emitter\r\n\r\n\tconstructor: ->\r\n\r\n\t\t@_listeners = {}\r\n\r\n\t\t@_listenersForAnyEvent = []\r\n\r\n\t\t@_disabledEmitters = {}\r\n\r\n\ton: (eventName, listener) ->\r\n\r\n\t\tunless @_listeners[eventName]?\r\n\r\n\t\t\t@_listeners[eventName] = []\r\n\r\n\t\t@_listeners[eventName].push listener\r\n\r\n\t\t@\r\n\r\n\tonce: (eventName, listener) ->\r\n\r\n\t\tran = no\r\n\r\n\t\tcb = =>\r\n\r\n\t\t\treturn if ran\r\n\r\n\t\t\tran = yes\r\n\r\n\t\t\tdo listener\r\n\r\n\t\t\tsetTimeout =>\r\n\r\n\t\t\t\t@removeEvent eventName, cb\r\n\r\n\t\t\t, 0\r\n\r\n\t\t@on eventName, cb\r\n\r\n\t\t@\r\n\r\n\tonAnyEvent: (listener) ->\r\n\r\n\t\t@_listenersForAnyEvent.push listener\r\n\r\n\t\t@\r\n\r\n\tremoveEvent: (eventName, listener) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\tarray.pluckOneItem @_listeners[eventName], listener\r\n\r\n\t\t@\r\n\r\n\tremoveListeners: (eventName) ->\r\n\r\n\t\treturn @ unless @_listeners[eventName]?\r\n\r\n\t\t@_listeners[eventName].length = 0\r\n\r\n\t\t@\r\n\r\n\tremoveAllListeners: ->\r\n\r\n\t\tfor name, listeners of @_listeners\r\n\r\n\t\t\tlisteners.length = 0\r\n\r\n\t\t@\r\n\r\n\t_emit: (eventName, data) ->\r\n\r\n\t\tfor listener in @_listenersForAnyEvent\r\n\r\n\t\t\tlistener.call @, data, eventName\r\n\r\n\t\treturn unless @_listeners[eventName]?\r\n\r\n\t\tfor listener in @_listeners[eventName]\r\n\r\n\t\t\tlistener.call @, data\r\n\r\n\t\treturn\r\n\r\n\t# this makes sure that all the calls to this class's method 'fnName'\r\n\t# are throttled\r\n\t_throttleEmitterMethod: (fnName, time = 1000) ->\r\n\r\n\t\toriginalFn = @[fnName]\r\n\r\n\t\tif typeof originalFn isnt 'function'\r\n\r\n\t\t\tthrow Error \"this class does not have a method called '#{fnName}'\"\r\n\r\n\t\tlastCallArgs = null\r\n\t\tpending = no\r\n\t\ttimer = null\r\n\r\n\t\t@[fnName] = =>\r\n\r\n\t\t\tlastCallArgs = arguments\r\n\r\n\t\t\tdo pend\r\n\r\n\t\tpend = =>\r\n\r\n\t\t\tif pending\r\n\r\n\t\t\t\tclearTimeout timer\r\n\r\n\t\t\ttimer = setTimeout runIt, time\r\n\r\n\t\t\tpending = yes\r\n\r\n\t\trunIt = =>\r\n\r\n\t\t\tpending = no\r\n\r\n\t\t\toriginalFn.apply @, lastCallArgs\r\n\r\n\t_disableEmitter: (fnName) ->\r\n\r\n\t\tif @_disabledEmitters[fnName]?\r\n\r\n\t\t\tthrow Error \"#{fnName} is already a disabled emitter\"\r\n\r\n\t\t@_disabledEmitters[fnName] = @[fnName]\r\n\r\n\t\t@[fnName] = ->\r\n\r\n\t_enableEmitter: (fnName) ->\r\n\r\n\t\tfn = @_disabledEmitters[fnName]\r\n\r\n\t\tunless fn?\r\n\r\n\t\t\tthrow Error \"#{fnName} is not a disabled emitter\"\r\n\r\n\t\t@[fnName] = fn\r\n\r\n\t\tdelete @_disabledEmitters[fnName]","_common = require './_common'\n\nmodule.exports = object =\n\n\tisBareObject: _common.isBareObject.bind _common\n\n\t###\n\tif object is an instance of a class\n\t###\n\tisInstance: (what) ->\n\n\t\tnot @isBareObject what\n\n\t###\n\tAlias to _common.typeOf\n\t###\n\ttypeOf: _common.typeOf.bind _common\n\n\t###\n\tAlias to _common.clone\n\t###\n\tclone: _common.clone.bind _common\n\n\t###\n\tEmpties an object of its properties.\n\t###\n\tempty: (o) ->\n\n\t\tfor prop of o\n\n\t\t\tdelete o[prop] if o.hasOwnProperty prop\n\n\t\to\n\n\t###\n\tEmpties an object. Doesn't check for hasOwnProperty, so it's a tiny\n\tbit faster. Use it for plain objects.\n\t###\n\tfastEmpty: (o) ->\n\n\t\tdelete o[property] for property of o\n\n\t\to\n\n\t###\n\tOverrides values fomr `newValues` on `base`, as long as they\n\talready exist in base.\n\t###\n\toverrideOnto: (base, newValues) ->\n\n\t\treturn base if not @isBareObject(newValues) or not @isBareObject(base)\n\n\t\tfor key, oldVal of base\n\n\t\t\tnewVal = newValues[key]\n\n\t\t\tcontinue if newVal is undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t# newVal is a plain object\n\t\t\telse\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@overrideOnto oldVal, newVal\n\t\tbase\n\n\t###\n\tTakes a clone of 'base' and runs #overrideOnto on it\n\t###\n\toverride: (base, newValues) ->\n\n\t\t@overrideOnto @clone(base), newValues\n\n\tappend: (base, toAppend) ->\n\n\t\t@appendOnto @clone(base), toAppend\n\n\t# Deep appends values from `toAppend` to `base`\n\tappendOnto: (base, toAppend) ->\n\n\t\treturn base if not @isBareObject(toAppend) or not @isBareObject(base)\n\n\t\tfor own key, newVal of toAppend\n\n\t\t\tcontinue unless newVal isnt undefined\n\n\t\t\tif typeof newVal isnt 'object' or @isInstance newVal\n\n\t\t\t\tbase[key] = newVal\n\n\t\t\telse\n\n\t\t\t\t# newVal is a bare object\n\n\t\t\t\toldVal = base[key]\n\n\t\t\t\tif typeof oldVal isnt 'object' or @isInstance oldVal\n\n\t\t\t\t\tbase[key] = @clone newVal\n\n\t\t\t\telse\n\n\t\t\t\t\t@appendOnto oldVal, newVal\n\n\t\tbase\n\n\t# Groups\n\tgroupProps: (obj, groups) ->\n\n\t\tgrouped = {}\n\n\t\tfor name, defs of groups\n\n\t\t\tgrouped[name] = {}\n\n\t\tgrouped['rest'] = {}\n\n\t\t`top: //`\n\t\tfor key, val of obj\n\n\t\t\tshouldAdd = no\n\n\t\t\tfor name, defs of groups\n\n\t\t\t\tunless Array.isArray defs\n\n\t\t\t\t\tdefs = [defs]\n\n\t\t\t\tfor def in defs\n\n\t\t\t\t\tif typeof def is 'string'\n\n\t\t\t\t\t\tif key is def\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof RegExp\n\n\t\t\t\t\t\tif def.test key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse if def instanceof Function\n\n\t\t\t\t\t\tif def key\n\n\t\t\t\t\t\t\tshouldAdd = yes\n\n\t\t\t\t\telse\n\n\t\t\t\t\t\tthrow Error 'Group definitions must either\n\t\t\t\t\t\tbe strings, regexes, or functions.'\n\n\t\t\t\t\tif shouldAdd\n\n\t\t\t\t\t\tgrouped[name][key] = val\n\n\t\t\t\t\t\t`continue top`\n\n\t\t\tgrouped['rest'][key] = val\n\n\t\tgrouped","module.exports =\r\n\r\n\t# pads a number with leading zeroes\r\n\t#\r\n\t# http://stackoverflow.com/a/10073788/607997\r\n\tpad: (n, width, z = '0') ->\r\n\r\n\t\tn = n + ''\r\n\r\n\t\tif n.length >= width\r\n\r\n\t\t\tn\r\n\r\n\t\telse\r\n\r\n\t\t\tnew Array(width - n.length + 1).join(z) + n","module.exports = utila =\n\n\tarray: require './array'\n\tclassic: require './classic'\n\tobject: require './object'\n\tstring: require './string'\n\tEmitter: require './Emitter'","module.exports = common =\n\n\t###\n\tChecks to see if o is an object, and it isn't an instance\n\tof some class.\n\t###\n\tisBareObject: (o) ->\n\n\t\tif o? and o.constructor is Object\n\n\t\t\treturn true\n\n\t\tfalse\n\n\t###\n\tReturns type of an object, including:\n\tundefined, null, string, number, array,\n\targuments, element, textnode, whitespace, and object\n\t###\n\ttypeOf: (item) ->\n\n\t\treturn 'null' if item is null\n\n\t\treturn typeof item if typeof item isnt 'object'\n\n\t\treturn 'array' if Array.isArray item\n\n\t\t# From MooTools\n\t\t# - do we even need this?\n\t\tif item.nodeName\n\n\t\t\tif item.nodeType is 1 then return 'element'\n\t\t\tif item.nodeType is 3 then return (/\\S/).test(item.nodeValue) ? 'textnode' : 'whitespace'\n\n\t\telse if typeof item.length is 'number'\n\n\t\t\tif item.callee then return 'arguments'\n\n\t\treturn typeof item\n\n\t# Deep clone of any variable.\n\t# From MooTools\n\tclone: (item, includePrototype = false) ->\n\n\t\tswitch common.typeOf item\n\n\t\t\twhen 'array' then return common._cloneArray item, includePrototype\n\n\t\t\twhen 'object' then return common._cloneObject item, includePrototype\n\n\t\t\telse return item\n\n\t###\n\tDeep clone of an object.\n\tFrom MooTools\n\t###\n\t_cloneObject: (o, includePrototype = false) ->\n\n\t\tif common.isBareObject o\n\n\t\t\tclone = {}\n\n\t\t\tfor key of o\n\n\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\treturn clone\n\n\t\telse\n\n\t\t\treturn o unless includePrototype\n\n\t\t\treturn o if o instanceof Function\n\n\t\t\tclone = Object.create o.constructor.prototype\n\n\t\t\tfor key of o\n\n\t\t\t\tif o.hasOwnProperty key\n\n\t\t\t\t\tclone[key] = common.clone o[key], includePrototype\n\n\t\t\tclone\n\n\t###\n\tDeep clone of an array.\n\tFrom MooTools\n\t###\n\t_cloneArray: (a, includePrototype = false) ->\n\n\t\ti = a.length\n\n\t\tclone = new Array i\n\n\t\twhile i--\n\n\t\t\tclone[i] = common.clone a[i], includePrototype\n\n\t\tclone","require './_prepare'\n\narray = mod 'array'\n\ntest 'from', ->\n\n\tarray.from([1]).should.be.an.instanceOf Array\n\tarray.from([1])[0].should.equal 1\n\n# test 'clone', ->\n\n# \ta = [0, 1, 2]\n\n# \tb = array.clone a\n\n# \tb[0].should.equal 0\n# \tb[1].should.equal 1\n\n# \tb[0] = 3\n\n# \ta[0].should.equal 0\n\ntest 'pluck', ->\n\n\ta = [0, 1, 2, 3]\n\n\tafter = array.pluck a, 1\n\n\tafter.length.should.equal 3\n\n\tafter[0].should.equal 0\n\tafter[1].should.equal 2\n\tafter[2].should.equal 3\n\tafter.should.equal a\n\ntest 'pluckMultiple', ->\n\n\ta = [0, 1, 2, 3, 4, 5, 6]\n\n\tarray.pluckMultiple a, [0, 4, 2, 6]\n\n\ta.length.should.equal 3\n\ta[0].should.equal 1\n\ta[1].should.equal 3\n\ta[2].should.equal 5\n\ntest 'pluckItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 4\n\n\tarray.pluckItem([1], 2).length.should.equal 1\n\n\ntest 'pluckOneItem', ->\n\n\ta = [0, 1, 2, 3, 2, 4, 2]\n\n\tarray.pluckOneItem a, 2\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ta[3].should.equal 2\n\ta[4].should.equal 4\n\ta[5].should.equal 2\n\n\ta = [1, 2]\n\n\tarray.pluckOneItem a, 1\n\n\ta.length.should.equal 1\n\ta[0].should.equal 2\n\n\tarray.pluckOneItem([], 1).length.should.equal 0\n\n\tarray.pluckOneItem([1], 2).length.should.equal 1\n\ntest 'plcukByCallback', ->\n\n\ta = [0, 1, 2, 3]\n\n\tarray.pluckByCallback a, (val, i) ->\n\n\t\treturn yes if val is 2\n\n\t\treturn no\n\n\ta[0].should.equal 0\n\ta[1].should.equal 1\n\ta[2].should.equal 3\n\ntest 'injectByCallback', ->\n\n\tshouldInject = (valA, valB, toInject) ->\n\n\t\tunless valA?\n\n\t\t\treturn yes if toInject <= valB\n\n\t\t\treturn no\n\n\t\tunless valB?\n\n\t\t\treturn yes if valA <= toInject\n\n\t\t\treturn no\n\n\t\treturn yes if valA <= toInject <= valB\n\n\t\treturn no\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 0, shouldInject\n\n\ta[0].should.equal 0\n\ta[1].should.equal 0.5\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 2.7, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.7\n\ta[5].should.equal 2.75\n\ta[7].should.equal 3\n\n\ta = [0.5, 1, 2.5, 2.5, 2.75, 2.75, 3]\n\n\tarray.injectByCallback a, 3.2, shouldInject\n\n\ta[0].should.equal 0.5\n\ta[4].should.equal 2.75\n\ta[6].should.equal 3\n\ta[7].should.equal 3.2","require './_prepare'\n\nobject = mod 'object'\n\ntest 'isBareObject', ->\n\n\tobject.isBareObject('a').should.equal false\n\n\tobject.isBareObject({'a': 'a'}).should.equal true\n\ntest 'typeOf', ->\n\n\tobject.typeOf('s').should.equal 'string'\n\tobject.typeOf(0).should.equal 'number'\n\tobject.typeOf(false).should.equal 'boolean'\n\tobject.typeOf({}).should.equal 'object'\n\tobject.typeOf(arguments).should.equal 'arguments'\n\tobject.typeOf([]).should.equal 'array'\n\ntest 'empty', ->\n\n\to =\n\n\t\ta: 1\n\t\tb: 2\n\n\n\tobject.empty o\n\n\to.should.not.have.property 'a'\n\to.should.not.have.property 'b'\n\ntest 'fastEmpty', ->\n\n\to =\n\t\ta: 1\n\t\tb: 2\n\n\n\tobject.fastEmpty o\n\n\to.should.not.have.property 'a'\n\to.should.not.have.property 'b'\n\ntest 'clone', ->\n\n\tobject.clone([1])[0].should.equal 1\n\tobject.clone({a:1}).a.should.equal 1\n\n\to = {a: 1}\n\n\tobject.clone(o).should.not.equal o\n\ntest 'clone [include prototype]', ->\n\n\tclass C\n\n\t\tconstructor: (@a) ->\n\n\t\tsayA: -> @a + 'a'\n\n\ta = new C 'a'\n\n\ta.sayA().should.equal 'aa'\n\n\tb = object.clone a, yes\n\n\tb.should.not.equal a\n\n\tb.constructor.should.equal C\n\n\tb.a.should.equal 'a'\n\n\tb.a = 'a2'\n\n\tb.sayA().should.equal 'a2a'\n\ntest 'clone [without prototype]', ->\n\n\tclass C\n\n\t\tconstructor: (@a) ->\n\n\t\tsayA: -> @a + 'a'\n\n\ta = new C 'a'\n\n\ta.sayA().should.equal 'aa'\n\n\tb = object.clone a, no\n\n\tb.should.equal a\n\ntest 'overrideOnto [basic]', ->\n\n\tonto =\n\t\ta: 'a'\n\t\tb:\n\t\t\tc: 'c'\n\t\t\td:\n\t\t\t\te: 'e'\n\n\twhat =\n\t\ta: 'a2'\n\t\tb:\n\t\t\tc: 'c2'\n\t\t\td:\n\t\t\t\tf: 'f2'\n\n\tobject.overrideOnto onto, what\n\n\tonto.a.should.equal 'a2'\n\tonto.b.should.have.property 'c'\n\tonto.b.c.should.equal 'c2'\n\tonto.b.d.should.not.have.property 'f'\n\tonto.b.d.e.should.equal 'e'\n\ntest 'override', ->\n\n\tonto =\n\n\t\ta: 'a'\n\n\t\tb:\n\n\t\t\tc: 'c'\n\n\t\t\td:\n\n\t\t\t\te: 'e'\n\n\twhat =\n\n\t\ta: 'a2'\n\n\t\tb:\n\n\t\t\tc: 'c2'\n\n\t\t\td:\n\n\t\t\t\tf: 'f2'\n\n\n\tonto2 = object.override onto, what\n\n\tonto2.a.should.equal 'a2'\n\tonto2.b.should.have.property 'c'\n\tonto2.b.c.should.equal 'c2'\n\tonto2.b.d.should.not.have.property 'f'\n\tonto2.b.d.e.should.equal 'e'\n\n\tonto.should.not.equal onto2\n\ndo ->\n\n\twhat =\n\n\t\ta: 'a2'\n\n\t\tc: ->\n\n\t\tz: 'z'\n\n\t\ty:\n\n\t\t\ta: 'a'\n\n\tonto =\n\n\t\ta: 'a'\n\n\t\tb: 'b'\n\n\ttest 'appendOnto [basic]', ->\n\n\t\tobject.appendOnto onto, what\n\n\t\tonto.a.should.equal 'a2'\n\t\tonto.b.should.equal 'b'\n\t\tonto.z.should.equal 'z'\n\n\ttest \"appendOnto [shallow copies instances]\", ->\n\n\t\tonto.c.should.be.instanceof Function\n\t\tonto.c.should.equal what.c\n\n\n\ttest \"appendOnto [clones objects]\", ->\n\n\t\tonto.should.have.property 'y'\n\t\tonto.y.a.should.equal 'a'\n\t\tonto.y.should.not.equal what.y\n\ntest 'groupProps', ->\n\n\tobj =\n\n\t\ta1: '1'\n\t\ta2: '2'\n\n\t\tb1: '1'\n\t\tb2: '2'\n\n\t\tc1: '1'\n\t\tc2: '2'\n\n\t\trest1: '1'\n\t\trest2: '2'\n\n\tgroups = object.groupProps obj,\n\n\t\ta: ['a1', 'a2']\n\n\t\tb: [/^b[0-9]+$/]\n\n\t\tc: (key) -> key[0] is 'c'\n\n\tgroups.a.should.have.property 'a1'\n\tgroups.a.a1.should.equal '1'\n\n\tgroups.a.should.have.property 'a2'\n\n\tgroups.b.should.have.property 'b1'\n\tgroups.b.should.have.property 'b2'\n\n\tgroups.c.should.have.property 'c1'\n\tgroups.c.should.have.property 'c2'\n\n\tgroups.rest.should.have.property 'rest1'\n\tgroups.rest.should.have.property 'rest1'\n\n\tgroups.rest.should.not.have.property 'c1'"]}
\ No newline at end of file