diff --git a/components/assets/icons.html b/components/assets/icons.html new file mode 100644 index 00000000..83f05bcf --- /dev/null +++ b/components/assets/icons.html @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/components/perf-lib/frame-tester.html b/components/perf-lib/frame-tester.html new file mode 100644 index 00000000..4c76577d --- /dev/null +++ b/components/perf-lib/frame-tester.html @@ -0,0 +1,252 @@ + + + \ No newline at end of file diff --git a/components/perf-lib/perf.js b/components/perf-lib/perf.js new file mode 100644 index 00000000..ba07651b --- /dev/null +++ b/components/perf-lib/perf.js @@ -0,0 +1,40 @@ +// x-browser compat. +if (!window.performance) { + var start = Date.now(); + // only at millisecond precision + window.performance = {now: function(){ return Date.now() - start }}; +} + +console.perf = function() { + if (console.timeline) { + console.timeline(); + } + console.profile(); + console.perf.time = performance.now(); +}; + +console.perfEnd = function() { + if (window.WebComponents) { + // TODO(sjmiles): we need some kind of 'whenReady' or other signal + // that will work if this function is called after the event has fired + addEventListener('WebComponentsReady', function() { + console._perfEnd(); + }); + } else { + console._perfEnd(); + } +}; + +console._perfEnd = function() { + // force layout + document.body.offsetWidth; + var time = performance.now() - console.perf.time; + console.profileEnd(); + if (console.timeline) { + console.timelineEnd(); + } + document.title = time.toFixed(1) + 'ms: ' + document.title; + if (window.top !== window) { + window.top.postMessage(time + 'ms', '*'); + } +}; diff --git a/components/perf-lib/polymer/annotations.html b/components/perf-lib/polymer/annotations.html new file mode 100644 index 00000000..c9f1a472 --- /dev/null +++ b/components/perf-lib/polymer/annotations.html @@ -0,0 +1,126 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/base.html b/components/perf-lib/polymer/base.html new file mode 100644 index 00000000..de5046c1 --- /dev/null +++ b/components/perf-lib/polymer/base.html @@ -0,0 +1,82 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/bindings.html b/components/perf-lib/polymer/bindings.html new file mode 100644 index 00000000..a474e3c8 --- /dev/null +++ b/components/perf-lib/polymer/bindings.html @@ -0,0 +1,147 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/data.html b/components/perf-lib/polymer/data.html new file mode 100644 index 00000000..f09629b5 --- /dev/null +++ b/components/perf-lib/polymer/data.html @@ -0,0 +1,322 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/events.html b/components/perf-lib/polymer/events.html new file mode 100644 index 00000000..3abde55e --- /dev/null +++ b/components/perf-lib/polymer/events.html @@ -0,0 +1,38 @@ + diff --git a/components/perf-lib/polymer/experimental.html b/components/perf-lib/polymer/experimental.html new file mode 100644 index 00000000..e102dc39 --- /dev/null +++ b/components/perf-lib/polymer/experimental.html @@ -0,0 +1,4 @@ + diff --git a/components/perf-lib/polymer/lang.html b/components/perf-lib/polymer/lang.html new file mode 100644 index 00000000..d07d87b7 --- /dev/null +++ b/components/perf-lib/polymer/lang.html @@ -0,0 +1,41 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/layout.html b/components/perf-lib/polymer/layout.html new file mode 100644 index 00000000..46dec0ac --- /dev/null +++ b/components/perf-lib/polymer/layout.html @@ -0,0 +1,278 @@ + + \ No newline at end of file diff --git a/components/perf-lib/polymer/polymer.html b/components/perf-lib/polymer/polymer.html new file mode 100644 index 00000000..a72fb82d --- /dev/null +++ b/components/perf-lib/polymer/polymer.html @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/components/perf-lib/polymer/template.html b/components/perf-lib/polymer/template.html new file mode 100644 index 00000000..680ed34f --- /dev/null +++ b/components/perf-lib/polymer/template.html @@ -0,0 +1,83 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/util.html b/components/perf-lib/polymer/util.html new file mode 100644 index 00000000..9d2b4e51 --- /dev/null +++ b/components/perf-lib/polymer/util.html @@ -0,0 +1,36 @@ + \ No newline at end of file diff --git a/components/perf-lib/polymer/utils.html b/components/perf-lib/polymer/utils.html new file mode 100644 index 00000000..b6930edc --- /dev/null +++ b/components/perf-lib/polymer/utils.html @@ -0,0 +1,14 @@ + \ No newline at end of file diff --git a/components/polymer/README.md b/components/polymer/README.md new file mode 100644 index 00000000..d5e91d33 --- /dev/null +++ b/components/polymer/README.md @@ -0,0 +1 @@ +Mutation-2: 01: As with 00, but eschew normative ShadowDOM. \ No newline at end of file diff --git a/components/polymer/assets/icons.html b/components/polymer/assets/icons.html new file mode 100644 index 00000000..fee7e4e4 --- /dev/null +++ b/components/polymer/assets/icons.html @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/components/polymer/bower.json b/components/polymer/bower.json new file mode 100644 index 00000000..e69de29b diff --git a/components/polymer/build.bat b/components/polymer/build.bat new file mode 100644 index 00000000..a42dcce9 --- /dev/null +++ b/components/polymer/build.bat @@ -0,0 +1,2 @@ +START /B vulcanize polymer.html --inline -output dist/polymer.html +START /B vulcanize data.html --inline -output dist/data.html \ No newline at end of file diff --git a/components/polymer/data.html b/components/polymer/data.html new file mode 100644 index 00000000..988e420e --- /dev/null +++ b/components/polymer/data.html @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/components/polymer/dist/data.html b/components/polymer/dist/data.html new file mode 100644 index 00000000..9f1dd6e3 --- /dev/null +++ b/components/polymer/dist/data.html @@ -0,0 +1,592 @@ + \ No newline at end of file diff --git a/components/polymer/dist/data.html.gz b/components/polymer/dist/data.html.gz new file mode 100644 index 00000000..db4a5d66 Binary files /dev/null and b/components/polymer/dist/data.html.gz differ diff --git a/components/polymer/dist/data.js b/components/polymer/dist/data.js new file mode 100644 index 00000000..07ca473c --- /dev/null +++ b/components/polymer/dist/data.js @@ -0,0 +1,589 @@ + + /* + * Needs new name. + * + * Provides a data-binding API, by which a getter/setter pair + * can be constructed in one of two imperative modes: + * + * bindMethod(property, methodName): constructs a getter/setter pair and a + * backing store for the given property; calls the method when the setter + * is invoked and the value has changed from what is in the backing store. + * + * bindProperty(property, path): constructs a getter/setter pair that + * forwards data access to a property on another object. + * + * This feature also supports a `bind` object, which contains expressions + * that are deconstructed into `bindMethod` or `bindProperty` calls, or + * into a `multiBinding` construct. `multiBinding` constructs support + * multiple side-effects. + * + * bind { + * // if `method` is the name of a method on the current object, a + * // `bindMethod` call is made to define `property` as described above. + * property: 'method' + * // if the value is not the name of a method, it's assumed to be the + * // name in the `$` hash that maps to an element. + * // If no target property is specified, `textContent` is assumed to + * // be the backing-store for `property2` accessors. + * property2: 'elementId' + * // If a path is provided, that element is dereferenced from $ as before, + * // but the full path is used for the backing-store. + * // This declaration binds property3 to $.elementId.value + * property3: 'elementId.value' + * // If the specified property is also `published`, a multi-binding + * // construct is created which sends a change notification in addition + * // to whatever user side-effect is specified. + * publishedProperty: + * // Specify multiple side-effects directly as an array. Only one + * // callback method is allowed. + * property4: [ + * 'nameOfMethod', + * 'elementId', + * 'elementId.property', + * ... + * ] + * } + * + * Methods bound into multi-bind contexts support a validation feature. If + * the method returns a value that does not === undefined side-effects are + * prevented, and the triggering property is set to the returned value, and + * a new round of side-effects is initiated. + * + * Multi-bind = multiple side-effects for one signal. + * Note: `signal` today is `set-trap`, should we generalize? + * Side-effects can be registered by multiple subsystems: + * - bind feature + * - bind-annotations feature + * - computed feature + * - published feature + * We need to accumulate all side-effects for a particular property + * before constructing the handler. + * + */ + Base.addFeature({ + + // per prototype + + // TODO(sjmiles): initialization of `_propertyEffects` and the + // `addPropertyEffect` itself are really the domain of bind-effects + // but these things needs to happen before bind-effects itself initializes. + // We need to factor bind-effects into before and after features instead + // and let this feature be for dealing with `bind` object. + + register: function(prototype) { + prototype._addPropertyBindEffects(); + }, + + // TODO(sjmiles): really ad hoc self-modifying code + // to resolve initialization ordering around optional + // module + addPropertyEffect: function(property, kind, effect) { + // prepare storage on first invocation + this._propertyEffects = {}; + // add the effect + this._addPropertyEffect(property, kind, effect); + // subsequent invocations skip preparation step implementation + this.addPropertyEffect = this._addPropertyEffect; + }, + + _addPropertyEffect: function(property, kind, effect) { + var fx = this._propertyEffects[property]; + if (!fx) { + fx = this._propertyEffects[property] = []; + } + fx.push({ + kind: kind, + effect: effect + }); + }, + + _addPropertyBindEffects: function() { + for (var n in this.bind) { + var bind = this.bind[n]; + if (typeof bind === 'object') { + // multiplexed definition + for (var nn in bind) { + this._addPropertyBindEffect(n, bind[nn]); + } + } else { + // single definition + this._addPropertyBindEffect(n, bind); + } + } + }, + + _addPropertyBindEffect: function(property, bindEffect) { + this.addPropertyEffect(property, 'bind', bindEffect); + } + + }); + +// TODO(sjmiles): this code was ported from an earlier mutation and needs +// a cleanup to cleave closer to neoprene MO + +/* + +Scans a template to produce an annotation map that stores expression metadata +and information that can be used to associate that metadata with the +corresponding nodes in a template instance. + +Supported annotations are: + + * id attributes + * binding annotations in text nodes + * double-mustache expressions: {{expression}} + * double-bracket expressions: [[expression]] + * binding annotations in attributes + * attribute-bind expressions: name="{{expression}} || [[expression]]" + * property-bind expressions: name*="{{expression}} || [[expression]]" + * property-bind expressions: name:="expression" + * event annotations + * event delegation directives: on-="expression" + +Generated data-structure: + + [ + { + id: '', + events: [ + { + mode: ['auto'|''], + name: '' + value: '' + }, ... + ], + bindings: [ + { + kind: ['text'|'attribute'|'property'], + mode: ['auto'|''], + name: '' + value: '' + }, ... + ], + // TODO(sjmiles): confusingly, this is annotation-parent, not node-parent + parent: , + index: + }, + ... + ] + +TODO(sjmiles): this module should produce either syntactic metadata +(e.g. double-mustache, double-bracket, star-attr), or semantic metadata +(e.g. manual-bind, auto-bind, property-bind). Right now it's half and half. + +*/ + + Base.addFeature({ + + // instance-time + + findAnnotatedNode: function(root, annote) { + if (!annote.parent) { + return root; + } + var parent = this.findAnnotatedNode(root, annote.parent); + // enforce locality. + var nodes = (parent === this) ? parent.childNodes : + (parent.lightChildren || parent.childNodes); + return nodes[annote.index]; + }, + + // registration-time + + register: function(prototype) { + if (prototype._template) { + prototype.parseAnnotations(prototype._template) + } + }, + + parseAnnotations: function(template) { + // TODO(sjmiles): it's not a map, per se + var map = []; + this._parseNodeAnnotations(template.content, map); + if (map.length) { + template.map = map; + } + return template.map; + }, + + _parseNodeAnnotations: function(node, map) { + return node.nodeType === Node.TEXT_NODE ? + this._parseTextNodeAnnotation(node, map) : + this._parseElementAnnotations(node, map); + }, + + _parseTextNodeAnnotation: function(node, map) { + var v = node.textContent, escape = v.slice(0, 2); + if (escape === '{{' || escape === '[[') { + var annotation = { + bindings: [{ + kind: 'text', + mode: escape === '{{' ? 'auto' : '', + value: v.slice(2, -2) + }] + }; + map.push(annotation); + return annotation; + } + }, + + _parseElementAnnotations: function(node, map) { + var annote = { + bindings: [], + events: [] + }; + this._parseChildNodesAnnotations(node, annote, map); + if (node.attributes) { + this._parseNodeAttributeAnnotations(node, annote, map); + } + if (annote.bindings.length || annote.events.length || annote.id) { + map.push(annote); + } + return annote; + }, + + _parseChildNodesAnnotations: function(root, annotation, map) { + if (root.firstChild) { + for (var i=0, node=root.firstChild; node; node=node.nextSibling, i++) { + var childAnnotation = this._parseNodeAnnotations(node, map); + if (childAnnotation) { + childAnnotation.parent = annotation; + childAnnotation.index = i; + } + } + } + }, + + _parseNodeAttributeAnnotations: function(node, annotation) { + for (var i=0, a; (a=node.attributes[i]); i++) { + var n = a.name, v = a.value; + // id + if (n === 'id') { + annotation.id = v; + } + // on-* (event) + else if (n.slice(0, 3) === 'on-') { + annotation.events.push({ + name: n.slice(3), + value: v + }); + } + // other attribute + else { + var b = this._parseNodeAttributeAnnotation(node, n, v); + if (b) { + annotation.bindings.push(b); + } + } + } + }, + + _parseNodeAttributeAnnotation: function(node, n, v) { + var escape = v.slice(0, 2), lastChar = n[n.length-1]; + var kind = 'attribute', mode = ''; + if (lastChar === '*' || lastChar === ':') { + n = n.slice(0, -1); + kind = 'property'; + mode = 'auto'; + } + if (escape === '{{') { + mode = 'auto'; + v = v.slice(2, -2); + } + if (escape === '[[') { + mode = 'manual'; + v = v.slice(2, -2); + } + if (mode) { + if (n === 'style') { + kind = 'style'; + } + return { + kind: kind, + mode: mode, + name: n, + value: v + }; + } + } + + }); + + /* + * Parses the annotations map created by `annotations` features to perform + * declarative desugaring. + * + * Depends on `annotations` feature and `bind` feature. + * + * Two tasks are supported: + * + * - nodes with 'id' are described in a virtual annotation map at + * registration time. This map is then concretized per instance. + * + * - Simple mustache expressions consisting of a single property name + * in a `textContent` context are bound using `bind` features + * `bindMethod`. In this mode, the bound method is constructed at + * registration time, so marshaling is done done via the concretized + * `_nodes` at every access. + * + * TODO(sjmiles): ph3ar general confusion between registration and + * instance time tasks. Is there a cleaner way to disambiguate? + */ + Base.addFeature({ + + // registration-time + + register: function(prototype) { + if (prototype._template && prototype._template.map) { + this._preprocessBindAnnotations(prototype, prototype._template.map); + } + }, + + // construct binding meta-data at *registration* time + _preprocessBindAnnotations: function(prototype, map) { + // create a virtual annotation map, must be concretized at instance time + prototype._nodes = []; + // process annotations that have been parsed from template + map.forEach(function(annotation) { + // where to find the node in the concretized map + var index = prototype._nodes.push(annotation) - 1; + // TODO(sjmiles): we need to support multi-bind, right now you only get + // one (not including kind === `id`) + annotation.bindings.forEach(function(binding) { + prototype._bindAnnotationBinding(binding, index); + }); + }); + }, + + _bindAnnotationBinding: function(binding, index) { + // add to the list of property side-effects + binding.index = index; + this.addPropertyEffect(binding.value, 'annotation', binding); + } + + }); + + Base.addFeature({ + + /* computed property feature */ + + computed: { + }, + + register: function(prototype) { + prototype.defineComputedProperties(prototype.computed); + }, + + defineComputedProperties: function(computed) { + for (var n in computed) { + this.defineComputedProperty(n, computed[n]); + } + }, + + defineComputedProperty: function(name, expression) { + var index = expression.indexOf('('); + var method = expression.slice(0, index); + var args = expression.slice(index + 1, -1).replace(/ /g, '').split(','); + console.log('%c on [%s] compute [%s] via [%s]', 'color: green', args[0], name, method); + this.addPropertyEffect(args[0], 'compute', { + property: name, + method: method + }); + /* + this.compoundWatch(args, function() { + Polymer.log.watches && console.log('[compute] [%s]', name, arguments); + this[name] = method.apply(this, arguments); + }); + */ + } + + }); + + Base.addFeature({ + + // per instance + + init: function() { + this._data = Object.create(null); + }, + + _setupBindListeners: function() { + var bl = this._bindListeners; + for (var n in bl) { + bl[n].targets.forEach(function(target) { + this._setupBindListener(n, target); + }, this); + } + }, + + _setupBindListener: function(property, target) { + //console.log('[bind]: [%s][%s] listening for [%s][%s-changed]', this.localName, property, target.id || target.index, target.property); + var host = this, property; + var node = target.id ? this.$[target.id] : this._nodes[target.index]; + node.addEventListener(target.property + '-changed', function(e) { + //console.log('[bind]:[%s] heard [%s-changed] this.[%s] = [%s]', host.localName, source, property, e.detail); + host[property] = e.detail; + }); + }, + + _notifyChange: function(property) { + this.fire(property + '-changed', this[property], null, false); + }, + + _setData: function(property, value) { + var old = this._data[property]; + if (old !== value) { + this._data[property] = value; + } + return old; + }, + + // per prototype + + register: function(prototype) { + prototype._bindListeners = {}; + prototype._createBindings(); + }, + + _createBindings: function() { + //console.group(this.name); + var fx = this._propertyEffects; + for (var n in fx) { + //console.group(n); + var compiledEffects = fx[n].map(function(x) { + return this._buildEffect(n, x); + }, this); + this._bindPropertyEffects(n, compiledEffects); + //console.log(fxt.join('\n')); + //console.groupEnd(); + } + //console.groupEnd(); + }, + + _buildEffect: function(property, fx) { + return this['_' + fx.kind + 'EffectBuilder'](property, fx.effect); + }, + + _bindEffectBuilder: function(source, effect) { + // TODO(sjmiles): validation system requires a blessed + // validator effect which needs to be processed first. + /* + if (typeof this[effect] === 'function') { + return [ + 'var validated = this.' + effect + '(value, old)', + 'if (validated !== undefined) {', + ' // recurse', + ' this[property] = validated;', + ' return;', + '}' + ].join('\n'); + } + */ + // + // TODO(sjmiles): try/catch is temporary + //try { + if (typeof this[effect] === 'function') { + return 'this.' + effect + '(this._data.' + source + ', old);' + } + //} catch(x) {} + // + var paths = effect.split('.'); + var id = paths.shift(); + var property = paths.join('.'); + // + if (property) { + // TODO(sjmiles): awkward: store data for instance-time listeners. + // _addBindListener is in bind.html, if we did the path processing + // in that module we could contain all the listener logic there too. + this._addBindListener(source, id, property); + } else { + property = 'textContent'; + } + // + return 'this.$.' + id + '.' + property + ' = ' + + 'this._data.' + source + ';' + }, + + _bindPropertyEffects: function(property, effects) { + var defun = { + get: function() { + return this._data[property]; + } + } + if (effects.length) { + // combine effects + effects = effects.join('\n\t\t'); + // construct effector + var effector = '_' + property + 'Effector'; + this[effector] = new Function('old', effects); + // construct setter body + var body = '\tvar old = this._setData(\'' + property + '\', value);\n' + + '\tif (value !== old) {\n' + + '\t\tthis.' + effector + '(old);\n' + + '\t}'; + var setter = new Function('value', body); + // ReadOnly properties have a private setter only + if (this.isReadOnlyProperty(property)) { + this['_set_' + property] = setter; + } + // other properties have a proper setter + else { + defun.set = setter; + } + } + Object.defineProperty(this, property, defun); + //var prop = Object.getOwnPropertyDescriptor(this, property); + //console.log(prop.set ? prop.set.toString() : '(read-only)'); + }, + + _notifyEffectBuilder: function(source) { + return 'this._notifyChange(\'' + source + '\')'; + }, + + _computeEffectBuilder: function(source, effect) { + return 'this.' + effect.property + + ' = this.' + effect.method + '(this._data.' + source + ');'; + }, + + _annotationEffectBuilder: function(source, binding) { + var target = binding.name || 'textContent'; + if (binding.kind !== 'text' && binding.kind !== 'attribute') { + console.warn(binding.kind); + return; + } + if (target !== 'textContent') { + this._addAnnotatedListener(source, binding.index, target); + } + return this._bindAnnotationProperty(source, target, binding.index); + }, + + _bindAnnotationProperty: function(source, target, index) { + return 'this._nodes[' + index + '].' + target + + ' = this._data.' + source + ';'; + }, + + _addBindListener: function(source, id, property) { + var bl = this._requireBindListeners(source); + bl.targets.push({ + id: id, + property: property + }); + }, + + _addAnnotatedListener: function(source, index, property) { + var bl = this._requireBindListeners(source); + bl.targets.push({ + index: index, + property: property + }); + }, + + _requireBindListeners: function(source) { + var bl = this._bindListeners[source]; + if (!bl) { + bl = this._bindListeners[source] = {targets: []}; + } + return bl; + } + +}); diff --git a/components/polymer/dist/data.min.html b/components/polymer/dist/data.min.html new file mode 100644 index 00000000..e8f536b2 --- /dev/null +++ b/components/polymer/dist/data.min.html @@ -0,0 +1 @@ + diff --git a/components/polymer/dist/polymer.html.gz b/components/polymer/dist/polymer.html.gz new file mode 100644 index 00000000..861d97f2 Binary files /dev/null and b/components/polymer/dist/polymer.html.gz differ diff --git a/components/polymer/dist/polymer.js b/components/polymer/dist/polymer.js new file mode 100644 index 00000000..fce539cc --- /dev/null +++ b/components/polymer/dist/polymer.js @@ -0,0 +1,812 @@ + // a tiny bit of sugar for `document.currentScript.ownerDocument` + // sadly `import` is reserved, so we need another name or + // you have to refer to this value `window.import` + Object.defineProperty(window, 'import', { + enumerable: true, + configurable: true, + get: function() { + return (document._currentScript || document.currentScript).ownerDocument; + } + }); + + // copy own properties from 'api' to 'prototype, with name hinting for 'super' + function extend(prototype, api) { + if (prototype && api) { + // use only own properties of 'api' + Object.getOwnPropertyNames(api).forEach(function(n) { + // acquire property descriptor + var pd = Object.getOwnPropertyDescriptor(api, n); + if (pd) { + // clone property via descriptor + Object.defineProperty(prototype, n, pd); + // cache name-of-method for 'super' engine + /* + if (typeof pd.value == 'function') { + // hint the 'super' engine + pd.value.nom = n; + } + */ + } + }); + } + return prototype; + }; + + Event.prototype.keys = { + ESC_KEY: 27, + ENTER_KEY: 13 + }; + + Base = { + + // (semi-)pluggable features for Base + _features: [], + + addFeature: function(feature) { + this._features.push(feature); + extend(Base, feature); + delete Base.init; + delete Base.register; + }, + + registerCallback: function() { + // `this` context is a prototype, not an instance + var prototype = this; + this.registerFeatures(prototype); + this.registered(prototype); + }, + + registered: function(prototype) { + // for overriding + }, + + registerFeatures: function(prototype) { + var f$ = this._features; + for (var i=0, n=f$.length; i: , + * ... + * + * // `foo` property can be assigned via attribute, will be deserialized to + * // the specified data-type. All `published` properties have this behavior. + * foo: String, + * + * // `bar` property has additional behavior specifiers. + * // type: type for (de-)serialization + * // notify: true to send a signal when a value is set to this property + * // reflect: true to serialize the property to an attribute + * // readOnly: if true, the property has no setter + * bar: { + * type: Boolean, + * notify: true + * } + * } + * + */ + Base.addFeature({ + + published: { + }, + + nob: Object.create(null), + + register: function(prototype) { + // TODO(sjmiles): improve layering + if (prototype.addPropertyEffect) { + for (var n in prototype.published) { + if (prototype.isNotifyProperty(n)) { + prototype.addPropertyEffect(n, 'notify'); + } + } + } + }, + + getPublishInfo: function(property) { + var p = this.published[property]; + if (typeof(p) === 'function') { + p = this.published[property] = { + type: p + }; + } + return p || Base.nob; + }, + + getPublishedPropertyType: function(property) { + return this.getPublishInfo(property).type; + }, + + isReadOnlyProperty: function(property) { + return this.getPublishInfo(property).readOnly; + }, + + isNotifyProperty: function(property) { + return this.getPublishInfo(property).notify; + }, + + isReflectedProperty: function(property) { + return this.getPublishInfo(property).reflect; + } + + }); + + /* + * Support for `hostAttributes` property. + * + * `hostAttributes` is a space separated string of attributes to + * install on every instance. + * + * There is room for addition `attributes` features, namely: + * + * - potentially automatic handling of attributeChanged + * - capturing initial configuration values from attributes + * + */ + Base.addFeature({ + + init: function() { + if (this.hostAttributes) { + this.cloneAttributes(this, this.hostAttributes); + } + }, + + cloneAttributes: function(node, attr$) { + attr$.split(' ').forEach(function(a) { + node.setAttribute(a, ''); + }); + } + + }); + + /* + * Support for `published` property. + * + * `published` object maps the names of attributes that the user + * wants mapped as inputs to properties to the data-type of that property. + * + * This feature overwrites `attributeChanged` to support automatic + * propagation of attribute values at run-time. + * + * Static values in attributes at creation time can be captured by + * `takeAttributes`. + * + * Example: + * + * published: { + * // values set to index attribute are converted to Number and propagated + * // to index property + * index: Number, + * // values set to label attribute are propagated to index property + * label: String + * } + * + * Supported types: + * + * - Number + * - Boolean + * - String + * - Object (JSON) + * - Array (JSON) + * - Date + * + */ + Base.addFeature({ + + /* attribute publishing feature, requires `published` feature */ + + takeAttributes: function() { + for (var n in this.published) { + this.attributeChanged(n); + } + }, + + attributeChanged: function(name) { + var type = this.getPublishedPropertyType(name); + if (type) { + this.deserialize(name, type); + } + }, + + deserialize: function(name, type) { + var value = this.getAttribute(name); + switch(type) { + + case Number: + value = Number(value) || this[name]; + break; + + case Boolean: + value = this.hasAttribute(name); + break; + + case Object: + case Array: + try { + value = JSON.parse(value); + } catch(x) { + return; + } + break; + + case Date: + value = Date.parse(value); + break; + + case String: + default: + break; + + } + this[name] = value; + } + + }); + + Base.addFeature({ + + register: function(prototype) { + var script = (document._currentScript || document.currentScript); + var prev = script.previousElementSibling; + if (prev && prev.localName === 'template') { + prototype._template = prev; + // TODO(sjmiles): probably should be it's own feature + //this.decorateTemplateNodes(prototype._template.content, + //prototype.name); + } + }, + + /*decorateTemplateNodes: function(root, name) { + for (var node = root.firstElementChild; node; + node = node.nextElementSibling) { + node.setAttribute(name, ''); + this.decorateTemplateNodes(node, name); + } + },*/ + + stampTemplate: function(template) { + this._stampTemplate(template || this._template, this.root); + // TODO(sjmiles): hello prollyfill + if (window.CustomElements && CustomElements.upgradeSubtree) { + CustomElements.upgradeSubtree(this.root); + } + }, + + _stampTemplate: function(template, target) { + // TODO(sorvell): light dom children will invalidate annotations. + target.insertBefore(this.instanceTemplate(template), + target.firstElementChild); + }, + + instanceTemplate: function(template) { + return document.importNode(template.content, true); + } + + }); + + Base.addFeature({ + + // TODO(sjmiles): ad-hoc signal for `ShadowDOM-lite-enhanced` nodes + isHost: true, + + register: function(prototype) { + var t = prototype._template; + // TODO(sorvell): is qsa is wrong here due to distribution? + // TODO(sjmiles): No element should ever actually stamp a node + // into it's composed tree, so I believe this is actually correct. + // However, I wonder if it's more efficient to capture during annotation + // parsing, since the parse step does a tree walk in any case, and the + // tree is smaller before element expansion. + prototype._useContent = Boolean(t && t.content.querySelector('content')); + }, + + poolContent: function() { + // pool the light dom + var pool = document.createDocumentFragment(); + while (this.firstChild) { + pool.appendChild(this.firstChild); + } + this.contentPool = pool; + // capture lightChildren to help reify dom scoping + this.lightChildren = + Array.prototype.slice.call(this.contentPool.childNodes, 0); + }, + + distributeContent: function() { + var content, pool = this.contentPool; + // replace with nodes teleported from pool + while (content = this.querySelector('content')) { + var select = content.getAttribute('select'); + var frag = pool; + if (select) { + frag = document.createDocumentFragment(); + // TODO(sjmiles): diverges from ShadowDOM spec behavior: ShadowDOM + // only selects top level nodes from pool. Iterate children and match + // manually instead. + var nodes = pool.querySelectorAll(select); + for (var i=0, l=nodes.length; i="expression" + +Generated data-structure: + + [ + { + id: '', + events: [ + { + mode: ['auto'|''], + name: '' + value: '' + }, ... + ], + bindings: [ + { + kind: ['text'|'attribute'|'property'], + mode: ['auto'|''], + name: '' + value: '' + }, ... + ], + // TODO(sjmiles): confusingly, this is annotation-parent, not node-parent + parent: , + index: + }, + ... + ] + +TODO(sjmiles): this module should produce either syntactic metadata +(e.g. double-mustache, double-bracket, star-attr), or semantic metadata +(e.g. manual-bind, auto-bind, property-bind). Right now it's half and half. + +*/ + + Base.addFeature({ + + // instance-time + + findAnnotatedNode: function(root, annote) { + if (!annote.parent) { + return root; + } + var parent = this.findAnnotatedNode(root, annote.parent); + // enforce locality. + var nodes = (parent === this) ? parent.childNodes : + (parent.lightChildren || parent.childNodes); + return nodes[annote.index]; + }, + + // registration-time + + register: function(prototype) { + if (prototype._template) { + prototype.parseAnnotations(prototype._template) + } + }, + + parseAnnotations: function(template) { + // TODO(sjmiles): it's not a map, per se + var map = []; + this._parseNodeAnnotations(template.content, map); + if (map.length) { + template.map = map; + } + return template.map; + }, + + _parseNodeAnnotations: function(node, map) { + return node.nodeType === Node.TEXT_NODE ? + this._parseTextNodeAnnotation(node, map) : + this._parseElementAnnotations(node, map); + }, + + _parseTextNodeAnnotation: function(node, map) { + var v = node.textContent, escape = v.slice(0, 2); + if (escape === '{{' || escape === '[[') { + var annotation = { + bindings: [{ + kind: 'text', + mode: escape === '{{' ? 'auto' : '', + value: v.slice(2, -2) + }] + }; + map.push(annotation); + return annotation; + } + }, + + _parseElementAnnotations: function(node, map) { + var annote = { + bindings: [], + events: [] + }; + this._parseChildNodesAnnotations(node, annote, map); + if (node.attributes) { + this._parseNodeAttributeAnnotations(node, annote, map); + } + if (annote.bindings.length || annote.events.length || annote.id) { + map.push(annote); + } + return annote; + }, + + _parseChildNodesAnnotations: function(root, annotation, map) { + if (root.firstChild) { + for (var i=0, node=root.firstChild; node; node=node.nextSibling, i++) { + var childAnnotation = this._parseNodeAnnotations(node, map); + if (childAnnotation) { + childAnnotation.parent = annotation; + childAnnotation.index = i; + } + } + } + }, + + _parseNodeAttributeAnnotations: function(node, annotation) { + for (var i=0, a; (a=node.attributes[i]); i++) { + var n = a.name, v = a.value; + // id + if (n === 'id') { + annotation.id = v; + } + // on-* (event) + else if (n.slice(0, 3) === 'on-') { + annotation.events.push({ + name: n.slice(3), + value: v + }); + } + // other attribute + else { + var b = this._parseNodeAttributeAnnotation(node, n, v); + if (b) { + annotation.bindings.push(b); + } + } + } + }, + + _parseNodeAttributeAnnotation: function(node, n, v) { + var escape = v.slice(0, 2), lastChar = n[n.length-1]; + var kind = 'attribute', mode = ''; + if (lastChar === '*' || lastChar === ':') { + n = n.slice(0, -1); + kind = 'property'; + mode = 'auto'; + } + if (escape === '{{') { + mode = 'auto'; + v = v.slice(2, -2); + } + if (escape === '[[') { + mode = 'manual'; + v = v.slice(2, -2); + } + if (mode) { + if (n === 'style') { + kind = 'style'; + } + return { + kind: kind, + mode: mode, + name: n, + value: v + }; + } + } + + }); + + // depends on `annotations` feature + + Base.addFeature({ + + $$: function(slctr) { + return this.root.querySelector(slctr); + }, + + // construct $ map (id based) + _marshalNodeReferences: function() { + this.$ = {}; + var map = this._template && this._template.map; + if (map) { + map.forEach(function(annotation) { + var id = annotation.id; + if (id) { + this.$[id] = this.findAnnotatedNode(this.root, annotation); + } + }, this); + } + }, + + // concretize `_nodes` map (annotation based) + _marshalAnnotatedNodes: function() { + if (this._nodes) { + this._nodes = this._nodes.map(function(a) { + return this.findAnnotatedNode(this.root, a); + }, this); + } + } + + }); + + Base.addFeature({ + + listeners: {}, + + init: function() { + }, + + // TODO(sjmiles): support for '.' notation requires 'nodes' feature + listenListeners: function() { + for (var key in this.listeners) { + var node = this, name = key; + if (name.indexOf('.') >= 0) { + name = name.split('.'); + node = this.$[name[0]]; + name = name[1]; + } + this.listen(node, name, this.listeners[key]); + } + }, + + listen: function(node, eventName, methodName) { + node.addEventListener(eventName, function(e) { + this[methodName](e, e.detail); + }.bind(this)); + }, + + // TODO(sjmiles): use a dictionary for options after `detail` + fire: function(type, detail, onNode, bubbles, cancelable) { + var node = onNode || this; + var detail = (detail === null || detail === undefined) ? {} : detail; + var event = new CustomEvent(type, { + bubbles: bubbles !== undefined ? bubbles : true, + cancelable: cancelable !== undefined ? cancelable : true, + detail: detail + }); + node.dispatchEvent(event); + return event; + } + + }); + + Base.addFeature({ + + keyPresses: {}, + + listenKeyPresses: function() { + // for..in here to gate empty keyPresses object (iterates once or never) + for (var n in this.keyPresses) { + // only get here if there is something in keyPresses + this.addEventListener('keypress', this.keyPressesFeatureHandler); + // map string keys to numeric codes + for (n in this.keyPresses) { + if (typeof n === 'string') { + this.keyPresses[Event.prototype.keys[n]] = this.keyPresses[n]; + } + } + break; + } + }, + + keyPressesFeatureHandler: function(e) { + var method = this.keyPresses[e.keyCode]; + if (method && this[method]) { + return this[method](e.keyCode, e); + } + } + + }); + + /* + * Parses the annotations map created by `annotations` features to support + * declarative events. + * + * Depends on `annotations` and `events` features. + * + */ + Base.addFeature({ + + // instance-time + + _setupAnnotatedListeners: function() { + var map = this._template.map; + if (map) { + map.forEach(function(annotation) { + var events = annotation.events; + if (events && events.length) { + var node = this.findAnnotatedNode(this.root, annotation); + events.forEach(function(e) { + //console.log('[%s] listening for [%s] on [%s]', e.value, e.name, node.localName); + this.listen(node, e.name, e.value); + }, this) + } + }, this); + } + } + + }); + + Base.addFeature({ + + async: function(method) { + var handled = false; + var handle = function() { + if (!handled) { + handled = true; + method.call(this); + } + }.bind(this); + // minimize latency by racing requests + setTimeout(handle); + requestAnimationFrame(handle); + }, + + toggleAttribute: function(name, value) { + this[value ? 'setAttribute' : 'removeAttribute'](name, ''); + }, + + attributeFollows: function(name, neo, old) { + if (old) { + old.removeAttribute(name); + } + if (neo) { + neo.setAttribute(name, ''); + } + } + + }); + + // TODO(sjmiles): hack + Base.originalInitFeatures = Base.initFeatures; + + Base.addFeature({ + + initFeatures: function() { + this.originalInitFeatures(this); + this.features(); + }, + + features: function() { + this.defaultFeatures(); + }, + + defaultFeatures: function() { + if (this._useContent) { + this.poolContent(); + } + if (this._template) { + this.stampTemplate(); + this._marshalNodeReferences(); + this._marshalAnnotatedNodes(); + this._setupAnnotatedListeners(); + if (this._setupBindListeners) { + this._setupBindListeners(); + } + } + this.listenListeners(); + this.listenKeyPresses(); + if (this._useContent) { + this.distributeContent(); + } + this.takeAttributes(); + } + + }); + + Polymer.noFeatures = function() { + }; + + Polymer.defaultFeatures = Base.defaultFeatures; + diff --git a/components/polymer/dist/polymer.min.html b/components/polymer/dist/polymer.min.html new file mode 100644 index 00000000..9db14e59 --- /dev/null +++ b/components/polymer/dist/polymer.min.html @@ -0,0 +1,278 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/components/polymer/explainer/Explaner.md b/components/polymer/explainer/Explaner.md new file mode 100644 index 00000000..63f62709 --- /dev/null +++ b/components/polymer/explainer/Explaner.md @@ -0,0 +1,323 @@ +# Polymer (Neoprene) + +## Raw Custom Elements + +Custom Elements are a powerful emerging web standard that allows developers to create their own elements by attaching a class to a tag-name. + +### document.registerElement + +The native API is very simple, it looks something like this: + +```js +document.registerElement(, {prototype: Object[, extends: String]}); +``` + +### Typical Boilerplate + +There is a little bit of work one has to do to set up the class with the right prototypes and so on to construct a Custom Element. Here is an typical example (using ES5 syntax): + +```js +var ctor = function() { + return document.createElement('x-custom'); +}; +ctor.prototype = Object.create(HTMLElement.prototype); +ctor.prototype.constructor = ctor; +ctor.prototype.createdCallback = function() { + this.innerHTML = 'Hello World, I am a Custom Element!'; +} +document.registerElement('x-custom', ctor); +``` + +### Reluctant Polymer() Abstraction + +By principle, Polymer team tries to avoid abstracting DOM APIs, especially new ones. But in this case we finally decided the ergonomic benefit was worth it. By wrapping `registerElement` in our own function, we can reduce the above boilerplate to: + +```js +var ctor = Polymer({ + name: 'x-custom', + created: function() { + this.innerHTML = 'Hello World, I am a Custom Element!'; + } +}); +``` + +### Polymer() Does a Bit More + +You might notice the `Polymer()` invocation defines `created` instead of `createdCallback`. This is a feature of `Polymer.Base`, a tiny prototype that `Polymer()` adds to your prototype chain as it's handling the boilerplate above. `Polymer.Base` hooks the standard Custom Element lifecycle callbacks to provide helper implementations. The hooks in turn call shorter-named lifecycle methods on your prototype. + +- `created` instead of `createdCallback` +- `attached` instead of `attachedCallback` +- `detached` instead of `detachedCallback` +- `attributeChanged` instead of `attributeChangedCallback` + +You can always fallback to using the low-level methods if you wish (iow, you could simply implement `createdCallback` in your prototype). + +`Polymer.Base` also implements `registerCallback` on your prototype. `Polymer()` calls `registerCallback` which allows `Polymer.Base` to supply a layering system for Polymer abstractions so that no element needs to pay for features it doesn't use. + +## Features + +By default, the default Polymer distribution include several features. Although `Polymer.Base` itself is tiny, if you examine `Polymer.Base` you will probably see several methods that have been plugged-in to that prototype by feature definitions. The next few sections will explain these features and why we include them in the default set. Keep in mind that it's entirely possible to construct custom feature sets, or even use a trivial, featureless form of `Polymer()`. + +### Feature: _published_ + +The first feature implements support for the `published` property. By placing a object-valued `published` property on your prototype, let's you define various aspects of your custom-elements public API. + +By itself, the `published` feature **doesn't do anything**. It only provides API for asking questions about these special properties (see [link to docs] for details). + +```js +Polymer({ + + name: 'x-custom', + + published: { + user: String, + isHappy: Boolean, + count: { + type: Number, + readOnly: true, + notify: true + } + }, + + created: function() { + this.innerHTML = 'Hello World, I am a Custom Element!'; + } + +}); +``` + +Remember that the fields assigned to `count`, such as `readOnly` and `notify` don't do anything by themselves, it requires other features to give them life. + +### Feature: _attributes_ + +Many custom elements want to support configuration using HTML attributes. Custom Elements provides the `attributeChanged` callback gives us the raw API for this ability, but then we have to deal with initialization and type conversion (attributes are always strings). Here is an example of a custom element that supports a `user` attribute using the raw API. + +```js + Polymer({ + + name: 'x-custom', + + created: function() { + // handle any initial value + this.attributeChanged('user'); + // render + this.innerHTML = 'Hello World, my user is ' + (this.user || 'nobody') + '.'; + }, + + attributeChanged: function(name) { + switch(name) { + case 'user': + // pretty easy since user is a String, for other types + // we have to do more work + if (this.hasAttribute('user')) { + this.user = this.getAttribute('user'); + } + break; + } + } + + }); +``` + +Although it's relatively simple, having to write this code becomes annoying when working with multiple attributes or non-String types. It's also not very DRY. + +Instead, Polymer's `attributes` feature handles this work for you (using the `published` feature data). If an attribute is set that matches a property listed in the `published` object, the value is captured into the matching property. Strings are automatically converted to the published type. + +The type system includes support for Object values expressed as JSON, or Date objects expressed as any Date-parsable string representation. Boolean properties are mapped to Boolean attributes, in other words, if the attribute exists at all, it's value is true, regardless of it's string-value (and the value is only false if the attribute does not exist). + +Here is the equivalent of the above code, taking advantage of the `attributes` feature. + +```html + + + +``` + +### [ToDoc] attributes:hostAttributes + +### Feature: _template_ + +HTML templates are an emerging web standard that we like to consider part of the Web Components family. Templates are a great way to provide archetypal DOM content for your custom element, and this is where the `template` feature comes in. + +As usual, we started by writing basic template support by hand. It generally looks something like this: + +```html + + + +``` + +Again, it's simple, but it's a common pattern, so the `template` feature does it automatically. By default it looks for a template as the first element before the script, so our code can look like this: + +```html + + + +``` + +### Feature: _annotations_ + +Most elements need to customize the DOM instanced from a template. For this reason, it's handy to encode markers into your template to indicate special nodes, attributes, or text. Polymer calls these markers _annotations_. The `annotations` feature scans the template (once per element, at registration time) and builds a data-structure into the prototype that identifies markers it finds in the DOM (see [link to docs] for details). Normally you do not need to work with this data directly, Polymer does it for you. + +### Feature: _annotations-nodes_ + +Traditionally, modifying DOM is done by querying for elements to manipulate. Here is an example: + +```html + + + +``` + +This example is very simple. But in real projects, repeating queries is inefficient, so query results are often stored (memoized). Also, as DOM composition becomes more tricky, crafting correct queries can be difficult. For these reasons, automatically capturing nodes makes a good feature. + +The `annotations-nodes` feature builds a map of instance nodes by `id` in `this.$` (using the `annotations` feature data). Here is how the `annotations-nodes` feature simplifies the above example. + +```html + + + +``` + +### Feature: _annotations-events_ + +Most elements also need to listen for events. The standard DOM method `addEventListener` provides the low-level support: + +```html + + + +``` + +Again, this is pretty simple, but it's so common that it's worth making even simpler. The `annotations-events` feature supports declaring event listeners directly in our template. + +Declaring listeners in the template is convenient, and also helps us decouple view from behavior. + +```html + + + +``` + +Notice that the `kickAction` method doesn't know anything about `button`. If we decided that kicking should be performed by a key-press, or a menu-item, the element code doesn't need to know. We can change the UI however we want. Also notice that by attaching the event declaratively, we have removed the need to give the button an id. + +### [ToDoc] events feature + +### [ToDoc] keys feature + +### [ToDoc] content feature + + diff --git a/components/polymer/explainer/data-bind.png b/components/polymer/explainer/data-bind.png new file mode 100644 index 00000000..c55816df Binary files /dev/null and b/components/polymer/explainer/data-bind.png differ diff --git a/components/polymer/explainer/data-bind.vsdx b/components/polymer/explainer/data-bind.vsdx new file mode 100644 index 00000000..e699a26b Binary files /dev/null and b/components/polymer/explainer/data-bind.vsdx differ diff --git a/components/polymer/explainer/samples.html b/components/polymer/explainer/samples.html new file mode 100644 index 00000000..896118ce --- /dev/null +++ b/components/polymer/explainer/samples.html @@ -0,0 +1,41 @@ + + + + + Explainer Samples + + + + + + + + + + + + + + + + + diff --git a/components/polymer/polymer.html b/components/polymer/polymer.html new file mode 100644 index 00000000..d0c91832 --- /dev/null +++ b/components/polymer/polymer.html @@ -0,0 +1,61 @@ + + + + + + + + + + + + + + + + diff --git a/components/polymer/src/base.html b/components/polymer/src/base.html new file mode 100644 index 00000000..e1c8a4d1 --- /dev/null +++ b/components/polymer/src/base.html @@ -0,0 +1,89 @@ + diff --git a/components/polymer/src/features/annotations-bind.html b/components/polymer/src/features/annotations-bind.html new file mode 100644 index 00000000..07cb048d --- /dev/null +++ b/components/polymer/src/features/annotations-bind.html @@ -0,0 +1,66 @@ + + + diff --git a/components/polymer/src/features/annotations-events.html b/components/polymer/src/features/annotations-events.html new file mode 100644 index 00000000..78895fe3 --- /dev/null +++ b/components/polymer/src/features/annotations-events.html @@ -0,0 +1,34 @@ + + + diff --git a/components/polymer/src/features/annotations-nodes.html b/components/polymer/src/features/annotations-nodes.html new file mode 100644 index 00000000..93deb795 --- /dev/null +++ b/components/polymer/src/features/annotations-nodes.html @@ -0,0 +1,36 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/annotations.html b/components/polymer/src/features/annotations.html new file mode 100644 index 00000000..419390cc --- /dev/null +++ b/components/polymer/src/features/annotations.html @@ -0,0 +1,226 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/attributes.html b/components/polymer/src/features/attributes.html new file mode 100644 index 00000000..2a4b1f0d --- /dev/null +++ b/components/polymer/src/features/attributes.html @@ -0,0 +1,115 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/bind-effects.html b/components/polymer/src/features/bind-effects.html new file mode 100644 index 00000000..0532db23 --- /dev/null +++ b/components/polymer/src/features/bind-effects.html @@ -0,0 +1,216 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/bind.html b/components/polymer/src/features/bind.html new file mode 100644 index 00000000..e6ab43f8 --- /dev/null +++ b/components/polymer/src/features/bind.html @@ -0,0 +1,115 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/computed.html b/components/polymer/src/features/computed.html new file mode 100644 index 00000000..283b97df --- /dev/null +++ b/components/polymer/src/features/computed.html @@ -0,0 +1,39 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/content.html b/components/polymer/src/features/content.html new file mode 100644 index 00000000..7c9ba013 --- /dev/null +++ b/components/polymer/src/features/content.html @@ -0,0 +1,54 @@ + diff --git a/components/polymer/src/features/events.html b/components/polymer/src/features/events.html new file mode 100644 index 00000000..3fa84cbf --- /dev/null +++ b/components/polymer/src/features/events.html @@ -0,0 +1,44 @@ + diff --git a/components/polymer/src/features/keys.html b/components/polymer/src/features/keys.html new file mode 100644 index 00000000..0c84e9f3 --- /dev/null +++ b/components/polymer/src/features/keys.html @@ -0,0 +1,31 @@ + diff --git a/components/polymer/src/features/layout.html b/components/polymer/src/features/layout.html new file mode 100644 index 00000000..41155f47 --- /dev/null +++ b/components/polymer/src/features/layout.html @@ -0,0 +1,287 @@ + + \ No newline at end of file diff --git a/components/polymer/src/features/log.html b/components/polymer/src/features/log.html new file mode 100644 index 00000000..9d0b4718 --- /dev/null +++ b/components/polymer/src/features/log.html @@ -0,0 +1,12 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/published.html b/components/polymer/src/features/published.html new file mode 100644 index 00000000..0b4aee4d --- /dev/null +++ b/components/polymer/src/features/published.html @@ -0,0 +1,90 @@ + \ No newline at end of file diff --git a/components/polymer/src/features/template.html b/components/polymer/src/features/template.html new file mode 100644 index 00000000..ee0d0f91 --- /dev/null +++ b/components/polymer/src/features/template.html @@ -0,0 +1,38 @@ + diff --git a/components/polymer/src/features/utils.html b/components/polymer/src/features/utils.html new file mode 100644 index 00000000..526c4e76 --- /dev/null +++ b/components/polymer/src/features/utils.html @@ -0,0 +1,42 @@ + \ No newline at end of file diff --git a/components/polymer/src/lang.html b/components/polymer/src/lang.html new file mode 100644 index 00000000..67b1f3d5 --- /dev/null +++ b/components/polymer/src/lang.html @@ -0,0 +1,42 @@ + \ No newline at end of file diff --git a/components/polymer/src/more-features/bind-effects-object.html b/components/polymer/src/more-features/bind-effects-object.html new file mode 100644 index 00000000..e6da46e8 --- /dev/null +++ b/components/polymer/src/more-features/bind-effects-object.html @@ -0,0 +1,118 @@ + diff --git a/components/polymer/src/more-features/extends.html b/components/polymer/src/more-features/extends.html new file mode 100644 index 00000000..5a7a7401 --- /dev/null +++ b/components/polymer/src/more-features/extends.html @@ -0,0 +1,63 @@ + diff --git a/components/polymer/src/more-features/polymer-shadow.html b/components/polymer/src/more-features/polymer-shadow.html new file mode 100644 index 00000000..c91d80b7 --- /dev/null +++ b/components/polymer/src/more-features/polymer-shadow.html @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/components/polymer/src/more-features/ready.html b/components/polymer/src/more-features/ready.html new file mode 100644 index 00000000..3fb52080 --- /dev/null +++ b/components/polymer/src/more-features/ready.html @@ -0,0 +1,120 @@ + diff --git a/components/polymer/src/more-features/shadow-layout.html b/components/polymer/src/more-features/shadow-layout.html new file mode 100644 index 00000000..804a64d9 --- /dev/null +++ b/components/polymer/src/more-features/shadow-layout.html @@ -0,0 +1,286 @@ + + \ No newline at end of file diff --git a/components/polymer/src/more-features/shadow-styler.html b/components/polymer/src/more-features/shadow-styler.html new file mode 100644 index 00000000..46c4c742 --- /dev/null +++ b/components/polymer/src/more-features/shadow-styler.html @@ -0,0 +1,63 @@ + \ No newline at end of file diff --git a/components/polymer/src/more-features/shadow.html b/components/polymer/src/more-features/shadow.html new file mode 100644 index 00000000..3017ead4 --- /dev/null +++ b/components/polymer/src/more-features/shadow.html @@ -0,0 +1,9 @@ + \ No newline at end of file diff --git a/components/polymer/src/polymer.html b/components/polymer/src/polymer.html new file mode 100644 index 00000000..714f7c04 --- /dev/null +++ b/components/polymer/src/polymer.html @@ -0,0 +1,17 @@ + + + + \ No newline at end of file diff --git a/components/polymer/test/assets/Beaker2.jpg b/components/polymer/test/assets/Beaker2.jpg new file mode 100644 index 00000000..96fe8504 Binary files /dev/null and b/components/polymer/test/assets/Beaker2.jpg differ diff --git a/components/polymer/test/assets/test-style-path.html b/components/polymer/test/assets/test-style-path.html new file mode 100644 index 00000000..06f6feae --- /dev/null +++ b/components/polymer/test/assets/test-style-path.html @@ -0,0 +1,5 @@ + diff --git a/components/polymer/test/compat/polymer-smoke-elements.html b/components/polymer/test/compat/polymer-smoke-elements.html new file mode 100644 index 00000000..dc20cfc7 --- /dev/null +++ b/components/polymer/test/compat/polymer-smoke-elements.html @@ -0,0 +1,310 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/components/polymer/test/compat/polymer-smoke-polyfill.html b/components/polymer/test/compat/polymer-smoke-polyfill.html new file mode 100644 index 00000000..066d0006 --- /dev/null +++ b/components/polymer/test/compat/polymer-smoke-polyfill.html @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/components/polymer/test/elements-smoke.html b/components/polymer/test/elements-smoke.html new file mode 100644 index 00000000..b9cb5235 --- /dev/null +++ b/components/polymer/test/elements-smoke.html @@ -0,0 +1,155 @@ + + + + + + + + + + + + + + + + + + +

Hello World

+ + + + + + + + + + + +
+ Foo +
+ + Dialog + Pop +
+ + + + + +
+

Two

+
+ + + + + + + +
+ Nest +
+
+
+ Close +
+ + + + + +
+ Nest 2 +
+
+
+ Close +
+ + + + + + +

Alpha

+

Beta

+

Gamma

+ +
+ Close +
+ + + + \ No newline at end of file diff --git a/components/polymer/test/index.html b/components/polymer/test/index.html new file mode 100644 index 00000000..0528639e --- /dev/null +++ b/components/polymer/test/index.html @@ -0,0 +1,14 @@ + + + + + + + + + + diff --git a/components/polymer/test/polymer-smoke.html b/components/polymer/test/polymer-smoke.html new file mode 100644 index 00000000..e38d95fe --- /dev/null +++ b/components/polymer/test/polymer-smoke.html @@ -0,0 +1,337 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +Heya + + + + diff --git a/components/polymer/test/style-path-smoke.html b/components/polymer/test/style-path-smoke.html new file mode 100644 index 00000000..c2d1d815 --- /dev/null +++ b/components/polymer/test/style-path-smoke.html @@ -0,0 +1,6 @@ + + + + + + diff --git a/components/polymer/test/unit/base.html b/components/polymer/test/unit/base.html new file mode 100644 index 00000000..1eed661c --- /dev/null +++ b/components/polymer/test/unit/base.html @@ -0,0 +1,171 @@ + + + + + + + + + + + + diff --git a/components/vulcanize/.gitignore b/components/vulcanize/.gitignore new file mode 100644 index 00000000..3c3629e6 --- /dev/null +++ b/components/vulcanize/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/components/vulcanize/bin/vulcanize b/components/vulcanize/bin/vulcanize new file mode 100644 index 00000000..73fcc4c9 --- /dev/null +++ b/components/vulcanize/bin/vulcanize @@ -0,0 +1,111 @@ +#!/usr/bin/env node +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +var path = require('path'); +var fs = require('fs'); +var nopt = require('nopt'); +var vulcan = require('../lib/vulcan.js'); + +var pkg = require('../package.json'); + +var help = [ + 'vulcanize: Concatenate a set of Web Components into one file', + '', + 'Usage:', + ' vulcanize [OPTIONS] *', + '', + 'Options:', + ' --output, -o: Output file name (defaults to vulcanized.html)', + ' --verbose, -v: More verbose logging', + ' --help, -h, -?: Print this message', + ' --config: Read the given config file', + ' --strip, -s: Remove comments and empty text nodes', + ' --abspath, -p: Specify site root. Resolve paths to absolute paths based on site root', + ' --csp: Extract inline scripts to a separate file (uses .js)', + ' --inline: The opposite of CSP mode, inline all assets (script and css) into the document', + ' --csp --inline: Bundle all javascript (inline and external) into .js', + ' --version, -V: print version information', + ' --no-strip-excludes: Keep imports excluded from inlining', + ' --no-update-notifier: disable "update vulcanize" checks', + '', + 'Config:', + ' JSON file for additional options', + '', + ' {', + ' "excludes": {', + ' "imports": [ "regex-to-exclude" ],', + ' "styles": [ "regex-to-exclude" ],', + ' "scripts": [ "regex-to-exclude" ],', + ' }', + ' }' +]; + +function printHelp() { + console.log(help.join('\n')); + process.exit(0); +} + +var options = nopt( + { + 'config': path, + 'csp': Boolean, + 'help': Boolean, + 'inline': Boolean, + 'output': path, + 'abspath': path, + 'strip': Boolean, + 'verbose': Boolean, + 'version': Boolean + }, + { + '?': ['--help'], + 'h': ['--help'], + 'o': ['--output'], + 'p': ['--abspath'], + 's': ['--strip'], + 'v': ['--verbose'], + 'V': ['--version'] + } +); + +if (options.help || process.argv.length === 2) { + printHelp(); +} + +if (options.version) { + console.log('vulcanize %s', pkg.version); + process.exit(0); +} + +if (options['update-notifier'] !== false) { + (function() { + try { + require('update-notifier')({ + packageName: pkg.name, + packageVersion: pkg.version + }).notify(); + } catch(_) {} + })(); +} + +var argv = options.argv.remain; + +if (argv[0]) { + options.input = path.resolve(argv[0]); +} + +vulcan.setOptions(options, function(err) { + if (err) { + console.error(err); + process.exit(1); + } + vulcan.processDocument(); +}); diff --git a/components/vulcanize/example/.gitignore b/components/vulcanize/example/.gitignore new file mode 100644 index 00000000..ea761525 --- /dev/null +++ b/components/vulcanize/example/.gitignore @@ -0,0 +1,2 @@ +bower_components +vulcanized* diff --git a/components/vulcanize/example/absolutes.html b/components/vulcanize/example/absolutes.html new file mode 100644 index 00000000..9fc1e647 --- /dev/null +++ b/components/vulcanize/example/absolutes.html @@ -0,0 +1,12 @@ + + + + diff --git a/components/vulcanize/example/config.json b/components/vulcanize/example/config.json new file mode 100644 index 00000000..c14e920a --- /dev/null +++ b/components/vulcanize/example/config.json @@ -0,0 +1,5 @@ +{ + "excludes": { + "imports": ["polymer.html$"] + } +} diff --git a/components/vulcanize/example/empty.css b/components/vulcanize/example/empty.css new file mode 100644 index 00000000..f296c848 --- /dev/null +++ b/components/vulcanize/example/empty.css @@ -0,0 +1,10 @@ +/* + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + diff --git a/components/vulcanize/example/import-test.css b/components/vulcanize/example/import-test.css new file mode 100644 index 00000000..4fcaf887 --- /dev/null +++ b/components/vulcanize/example/import-test.css @@ -0,0 +1,15 @@ +/* + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +:host([type="platform"]) { background-color: red; } +:host([type="core"]) { background-color: red; } +:host([type="elements"]) { background-color: red; } +polyfill-next-selector { content: ':host header'; } +polyfill-next-selector { content: 'I WIN'; } diff --git a/components/vulcanize/example/import-test.html b/components/vulcanize/example/import-test.html new file mode 100644 index 00000000..605a9956 --- /dev/null +++ b/components/vulcanize/example/import-test.html @@ -0,0 +1,58 @@ + + + + + + + + diff --git a/components/vulcanize/example/index.html b/components/vulcanize/example/index.html new file mode 100644 index 00000000..b551d2c8 --- /dev/null +++ b/components/vulcanize/example/index.html @@ -0,0 +1,33 @@ + + + + + + Vulcanizer Test + + + + + + + Hello Import! + + + + + + + + + + diff --git a/components/vulcanize/example/sub-import/sub-import.html b/components/vulcanize/example/sub-import/sub-import.html new file mode 100644 index 00000000..2297ecc6 --- /dev/null +++ b/components/vulcanize/example/sub-import/sub-import.html @@ -0,0 +1,23 @@ + + + + + + diff --git a/components/vulcanize/lib/constants.js b/components/vulcanize/lib/constants.js new file mode 100644 index 00000000..b18e1a8e --- /dev/null +++ b/components/vulcanize/lib/constants.js @@ -0,0 +1,32 @@ +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +var JS = 'script:not([type]), script[type="text/javascript"]'; +var URL_ATTR = ['href', 'src', 'action', 'style']; + +module.exports = { + EOL: require('os').EOL, + ELEMENTS: 'polymer-element:not([assetpath])', + ELEMENTS_NOSCRIPT: 'polymer-element[noscript]', + ABS_URL: /(^data:)|(^http[s]?:)|(^\/)|(^mailto:)/, + REMOTE_ABS_URL: /(^http[s]?\:)|(^\/\/)/, + IMPORTS: 'link[rel="import"][href]', + URL: /url\([^)]*\)/g, + URL_ATTR: URL_ATTR, + URL_ATTR_SEL: '[' + URL_ATTR.join('],[') + ']', + URL_TEMPLATE: '{{.*}}', + JS: JS, + JS_SRC: JS.split(',').map(function(s){ return s + '[src]'; }).join(','), + JS_INLINE: JS.split(',').map(function(s) { return s + ':not([src])'; }).join(','), + CSS: 'style:not([type]), style[type="text/css"]', + // Output match is [ 'Polymer(', NAME_OF_ELEMENT OR undefined, ',', { or ) ] + POLYMER_INVOCATION: /Polymer\(([^,{]+)?(,\s*)?({|\))/, + NEOPRENE_INVOCATION: /name:\s*['"]([^'"]*)['"]/ +}; diff --git a/components/vulcanize/lib/optparser.js b/components/vulcanize/lib/optparser.js new file mode 100644 index 00000000..ab069fba --- /dev/null +++ b/components/vulcanize/lib/optparser.js @@ -0,0 +1,104 @@ +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +var fs = require('fs'); +var path = require('path'); + +var CONSTANTS = require('./constants.js'); +var ABS_URL = CONSTANTS.ABS_URL; +var REMOTE_ABS_URL = CONSTANTS.REMOTE_ABS_URL; +var DEFAULT = 'vulcanized.html'; + +// validate options with boolean return +function processOptions(options, callback) { + var config = {}; + var excludes = { + imports: [], + scripts: [], + styles: [] + }; + + options = options || Object.create(null); + + if (options.config) { + var configBlob; + try { + // TODO(dfreedm): Make this async + configBlob = fs.readFileSync(options.config, 'utf8'); + } catch(e) { + return callback('Config file not found!'); + } + try { + config = JSON.parse(configBlob); + } catch(e) { + return callback('Malformed config JSON!'); + } + } + + options.input = options.input || config.input; + if (!options.input) { + return callback('No input file given!'); + } + + options.excludes = options.excludes || config.excludes; + if (options.excludes) { + var e = options.excludes; + try { + if (e.imports) { + e.imports.forEach(function(r) { + excludes.imports.push(new RegExp(r)); + }); + } + if (e.scripts) { + e.scripts.forEach(function(r) { + excludes.scripts.push(new RegExp(r)); + }); + } + if (e.styles) { + e.styles.forEach(function(r) { + excludes.styles.push(new RegExp(r)); + }); + } + } catch(_) { + return callback('Malformed import exclude config'); + } + } + + options.output = options.output || config.output; + if (!options.output) { + options.output = path.resolve(path.dirname(options.input), DEFAULT); + } + options.outputDir = path.dirname(options.output); + + options.csp = options.csp || config.csp; + if (options.csp) { + options.csp = options.output.replace(/\.html$/, '.js'); + } + + options.abspath = options.abspath || config.abspath; + if (options.abspath) { + options.abspath = path.resolve(options.abspath); + excludes.imports.push(REMOTE_ABS_URL); + excludes.scripts.push(REMOTE_ABS_URL); + excludes.styles.push(REMOTE_ABS_URL); + } else { + excludes.imports.push(ABS_URL); + excludes.scripts.push(ABS_URL); + excludes.styles.push(ABS_URL); + } + + options.excludes = excludes; + + options.keepExcludes = options['strip-excludes'] === false || config['strip-excludes'] === false; + + callback(null, options); +} + +exports.processOptions = processOptions; diff --git a/components/vulcanize/lib/pathresolver.js b/components/vulcanize/lib/pathresolver.js new file mode 100644 index 00000000..dc940fbf --- /dev/null +++ b/components/vulcanize/lib/pathresolver.js @@ -0,0 +1,84 @@ +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +var path = require('path'); +var constants = require('./constants.js'); +var utils = require('./utils.js'); +var setTextContent = utils.setTextContent; +var getTextContent = utils.getTextContent; + +function resolvePaths($, input, output, abspath) { + var assetPath; + if (abspath) { + assetPath = rebasePath(input, abspath); + } else { + assetPath = path.relative(output, input); + } + // make sure assetpath is a folder, but not root! + if (assetPath) { + assetPath = utils.unixPath(assetPath) + '/'; + } + // resolve attributes + $(constants.URL_ATTR_SEL).each(function() { + var el = $(this); + constants.URL_ATTR.forEach(function(a) { + var val = el.attr(a); + if (val) { + if (val.search(constants.URL_TEMPLATE) < 0) { + if (a === 'style') { + el.attr(a, rewriteURL(input, output, val, abspath)); + } else { + el.attr(a, rewriteRelPath(input, output, val, abspath)); + } + } + } + }); + }); + $(constants.CSS).each(function() { + var el = $(this); + var text = rewriteURL(input, output, getTextContent(el), abspath); + setTextContent(el, text); + }); + $(constants.ELEMENTS).each(function() { + $(this).attr('assetpath', assetPath); + }); +} + +function rebasePath(absolutePath, baselinePath) { + var absBase = new RegExp('^' + utils.escapeForRegExp(baselinePath)); + return absolutePath.replace(absBase, ''); +} + +function rewriteRelPath(inputPath, outputPath, rel, abspath) { + if (constants.ABS_URL.test(rel)) { + return rel; + } + + var abs = path.resolve(inputPath, rel); + + if (abspath) { + return utils.unixPath(rebasePath(abs, abspath)); + } + + var relPath = path.relative(outputPath, abs); + return utils.unixPath(relPath); +} + +function rewriteURL(inputPath, outputPath, cssText, abspath) { + return cssText.replace(constants.URL, function(match) { + var path = match.replace(/["']/g, "").slice(4, -1); + path = rewriteRelPath(inputPath, outputPath, path, abspath); + return 'url("' + path + '")'; + }); +} + +exports.resolvePaths = resolvePaths; +exports.rewriteRelPath = rewriteRelPath; +exports.rewriteURL = rewriteURL; diff --git a/components/vulcanize/lib/utils.js b/components/vulcanize/lib/utils.js new file mode 100644 index 00000000..d1aa8cf8 --- /dev/null +++ b/components/vulcanize/lib/utils.js @@ -0,0 +1,63 @@ +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +var path = require('path'); + +module.exports = { + // directly update the textnode child of '); + // clone attributes + styleEl.attr(el.attr()); + // don't set href or rel on the ', + '', + '', + '' + ].join('\n'); + + var expected = [ + '', + '', + '', + '', + '' + ].join('\n'); + + var expected2 = [ + '', + '', + '', + '', + '' + ].join('\n'); + + var actual; + var whacko = require('whacko'); + var $ = whacko.load(html); + + pathresolver.resolvePaths($, inputPath, outputPath); + + actual = $.html(); + assert.equal(actual, expected, 'relative'); + + $ = whacko.load(html); + + pathresolver.resolvePaths($, inputPath, outputPath, '/foo'); + + actual = $.html(); + assert.equal(actual, expected2, 'absolute'); + }); + +}); + +suite('Utils', function() { + var constants = require('../lib/constants.js'); + var utils = require('../lib/utils.js'); + + test('getTextContent', function() { + var whacko = require('whacko'); + var divEl = whacko('
some text!
'); + assert.equal(utils.getTextContent(divEl), 'some text!', 'a textnode child'); + var blankEl = whacko('
'); + assert.equal(utils.getTextContent(blankEl), '', 'no textnode children'); + }); + + test('setTextContent', function() { + var whacko = require('whacko'); + var divEl = whacko('
'); + utils.setTextContent(divEl, 'some text!'); + assert.equal(utils.getTextContent(divEl), 'some text!', 'create text node'); + utils.setTextContent(divEl, 'some text 2!'); + assert.equal(utils.getTextContent(divEl), 'some text 2!', 'override text node'); + }); + + test('unixPath', function() { + var pp = ['foo', 'bar', 'baz']; + var p = pp.join('/'); + var actual = utils.unixPath(p); + assert.equal(actual, p, 'started unix'); + var p2 = pp.join('\\'); + actual = utils.unixPath(p2, '\\'); + assert.equal(actual, p, 'windows path'); + }); + + test('escapeForRegExp', function() { + var actual = utils.escapeForRegExp('foo-bar'); + assert.equal(actual, 'foo\\-bar', 'element name'); + actual = utils.escapeForRegExp('foo/bar/baz'); + assert.equal(actual, 'foo\\/bar\\/baz', 'absolute path'); + }); + + test('Polymer Invocation', function() { + var polymer = constants.POLYMER_INVOCATION; + + function test(invocation, expected, msg) { + var matches = polymer.exec(invocation); + assert(matches, 'polymer invocation found'); + var replacement = utils.processPolymerInvocation('core-input', matches); + var actual = invocation.replace(matches[0], replacement); + assert.strictEqual(actual, expected, msg); + } + + test('Polymer(\'core-input\', {})', 'Polymer(\'core-input\', {})', 'full'); + test('Polymer(\'core-input\')', 'Polymer(\'core-input\')', 'name-only'); + test('Polymer()', 'Polymer(\'core-input\')', 'none'); + test('Polymer({})', 'Polymer(\'core-input\',{})', 'object-only'); + test('Polymer(p)', 'Polymer(\'core-input\',p)', 'indirect'); + + }); + + test('#82', function() { + var constants = require('../lib/constants.js'); + var whacko = require('whacko'); + var $ = whacko.load(''); + $(constants.JS_INLINE).each(function() { + var el = $(this); + var content = utils.getTextContent(el); + assert(content); + var parentElement = el.closest('polymer-element').get(0); + if (parentElement) { + var match = constants.POLYMER_INVOCATION.exec(content); + var elementName = $(parentElement).attr('name'); + if (match) { + var invocation = utils.processPolymerInvocation(elementName, match); + content = content.replace(match[0], invocation); + utils.setTextContent(el, content); + } + } + assert.equal(utils.getTextContent(el), '(function(){ Polymer(\'paper-button-base\',p);}()'); + }); + }); + + +}); + +suite('Optparser', function() { + var path = require('path'); + var optParser = require('../lib/optparser.js'); + var constants = require('../lib/constants.js'); + var ABS_URL = constants.ABS_URL; + var REMOTE_ABS_URL = constants.REMOTE_ABS_URL; + + function optParserTest(fn, opts, skipFail) { + if (typeof opts === 'undefined') { + opts = {input: path.resolve('index.html')}; + } + optParser.processOptions(opts, function(err, options) { + if (!skipFail) { + assert.equal(err, null); + } + fn(err, options); + }); + } + + test('Error on no input', function(done) { + optParserTest(function(err, options) { + assert.equal(err, 'No input file given!'); + done(); + }, null, true); + }); + + test('Defaults', function(done) { + optParserTest(function(err, options) { + assert.equal(options.input, path.resolve('index.html')); + assert.equal(options.output, path.resolve('vulcanized.html')); + assert.equal(options.outputDir, path.dirname(path.resolve('vulcanized.html'))); + assert(!options.csp); + assert(!options.abspath); + assert.deepEqual(options.excludes, {imports:[ABS_URL], scripts:[ABS_URL], styles:[ABS_URL]}); + done(); + }); + }); + + test('CSP', function(done) { + optParserTest(function(err, options) { + assert.equal(options.csp, path.resolve('vulcanized.js')); + done(); + }, {input: 'index.html', csp: true}); + }); + + test('output', function(done) { + optParserTest(function(err, options) { + assert.equal(options.output, path.resolve('build.html')); + assert.equal(options.csp, path.resolve('build.js')); + done(); + }, {input: path.resolve('index.html'), output: path.resolve('build.html'), csp: true}); + }); + + test('abspath', function(done) { + optParserTest(function(err, options) { + assert.equal(options.abspath, path.resolve('../')); + assert.deepEqual(options.excludes, {imports:[REMOTE_ABS_URL], scripts:[REMOTE_ABS_URL], styles:[REMOTE_ABS_URL]}); + done(); + }, {input: path.resolve('index.html'), abspath: path.resolve('../')}); + }); + + test('excludes', function(done) { + var excludes = { + imports: [ + '.*' + ] + }; + var expected = [/.*/, ABS_URL]; + + optParserTest(function(err, options) { + assert.deepEqual(options.excludes.imports, expected); + done(); + }, {input: path.resolve('index.html'), excludes: excludes}); + + }); + + test('config file', function(done) { + optParserTest(function(err, options) { + assert.equal(options.input, path.resolve('index.html')); + assert.equal(options.output, path.resolve('build.html')); + assert.equal(options.csp, path.resolve('build.js')); + assert(!options.abspath); + assert.deepEqual(options.excludes, {imports:[/.*/, ABS_URL], scripts:[ABS_URL], styles:[ABS_URL]}); +done(); + }, {config: path.resolve('test/config.json'), input: path.resolve('index.html'), output: path.resolve('build.html'), csp: true}); + }); + + test('report broken config file', function(done) { + optParserTest(function(err, options) { + assert.equal(err, 'Malformed config JSON!'); + done(); + }, {config: path.resolve('test/broken_config.json')}, true); + }); + +}); + +suite('Vulcan', function() { + var vulcan = require('../lib/vulcan.js'); + var outputPath = path.resolve('test/html/actual.html'); + var inputPath = path.resolve('test/html/default.html'); + + test('set options', function(done) { + var options = { + input: 'index.html' + }; + vulcan.setOptions(options, done); + }); + + function process(options, fn) { + var outputs = Object.create(null); + options.outputSrc = function(name, data, eop) { + if (!data) { + throw new Error("Writing empty data"); + } + outputs[name] = data; + }; + vulcan.setOptions(options, function(err) { + assert(!err); + vulcan.processDocument(); + Object.keys(outputs).forEach(function(o) { + assert.equal(typeof outputs[o], 'string', 'all buffers are closed'); + }); + fn(outputs); + }); + } + + test('defaults', function(done) { + var getTextContent = require('../lib/utils.js').getTextContent; + + process({input: inputPath, output: outputPath}, function(outputs) { + assert.equal(Object.keys(outputs).length, 1); + var vulcanized = outputs[outputPath]; + assert(vulcanized); + var $ = require('whacko').load(vulcanized); + assert.equal($('body > div[hidden]').length, 1, 'only one div[hidden]'); + assert.equal($('head > link[rel="import"]:not([href^="http://"])').length, 0, 'all relative imports removed'); + assert.equal($('polymer-element').length, 1, 'imports were deduplicated'); + assert.equal($('polymer-element').attr('noscript'), null, 'noscript removed'); + assert.equal(getTextContent($('polymer-element > script')), 'Polymer(\'my-element\');', 'polymer script included'); + assert.equal($('polymer-element > template > link').length, 0, 'external styles removed'); + assert.equal($('polymer-element > template > style').length, 1, 'styles inlined'); + assert.equal($('polymer-element > template > svg > *').length, 6, 'svg children propery nested'); + assert.equal($('polymer-element').attr('assetpath'), 'imports/', 'assetpath set'); + done(); + }); + }); + + test('CSP', function(done) { + + process({input: inputPath, output: outputPath, csp: true}, function(outputs) { + assert.equal(Object.keys(outputs).length, 2); + var vulcanized = outputs[outputPath]; + var vulcanizedJS = outputs[path.resolve(outputPath, '../actual.js')]; + assert(vulcanized); + assert(vulcanizedJS); + var $ = require('whacko').load(vulcanized); + assert($('body > script[src="actual.js"]'), 'vulcanized script in body'); + assert.equal($('body script:not([src])').length, 0, 'inline scripts removed'); + assert.equal(vulcanizedJS, 'Polymer(\'my-element\');', 'csp element script'); + done(); + }); + }); + + test('exclude', function(done) { + + var i = 3; + function reallyDone() { + if (--i === 0) { + done(); + } + } + + process({input: inputPath, output: outputPath, excludes: {imports: ['simple-import']}}, function(outputs) { + var vulcanized = outputs[outputPath]; + assert(vulcanized); + var $ = require('whacko').load(vulcanized); + assert.equal($('head > link[href="imports/simple-import.html"]').length, 0, 'import excluded'); + assert.equal($('head > link[rel="stylesheet"][href="imports/simple-style.css"]').length, 0, 'import content excluded'); + assert.equal($('head > link[href="http://example.com/foo/bar.html"]').length, 1, 'external import is not excluded'); + reallyDone(); + }); + + process({input: inputPath, output: outputPath, excludes: {styles: ['simple-style']}}, function(outputs) { + var vulcanized = outputs[outputPath]; + assert(vulcanized); + var $ = require('whacko').load(vulcanized); + assert.equal($('polymer-element[name="my-element"] > template > link[href="imports/simple-style.css"]').length, 1, 'style excluded'); + reallyDone(); + }); + + process({input: inputPath, output: outputPath, excludes: {imports: ['simple-import']}, 'strip-excludes': false}, function(outputs) { + var vulcanized = outputs[outputPath]; + assert(vulcanized); + var $ = require('whacko').load(vulcanized); + assert.equal($('link[href="imports/simple-import.html"]').length, 1, 'excluded import not stripped'); + reallyDone(); + }); + }); + +}); diff --git a/components/vulcanize/util/changelogs.sh b/components/vulcanize/util/changelogs.sh new file mode 100644 index 00000000..987678aa --- /dev/null +++ b/components/vulcanize/util/changelogs.sh @@ -0,0 +1,23 @@ +#!/bin/bash +# +# @license +# Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +# This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt +# The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt +# The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt +# Code distributed by Google as part of the polymer project is also +# subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt +# + +# tags sorted semver style +TAGS=($(git tag -l | sort -k1,1r -k2,2r -k3,3r -t.)) + +TO=(${TAGS[@]}) + +FROM=(${TAGS[@]:1}) +FROM+=(`git rev-list --max-parents=0 HEAD`) + +for i in ${!FROM[@]}; do + echo "### ${TO[$i]}" + git log ${FROM[$i]}..${TO[$i]} --pretty="- %s" +done diff --git a/components/web-component-tester/browser.js b/components/web-component-tester/browser.js new file mode 100644 index 00000000..8b5d7e7b --- /dev/null +++ b/components/web-component-tester/browser.js @@ -0,0 +1,7844 @@ +;(function(){ + +// CommonJS require() + +function require(p){ + var path = require.resolve(p) + , mod = require.modules[path]; + if (!mod) throw new Error('failed to require "' + p + '"'); + if (!mod.exports) { + mod.exports = {}; + mod.call(mod.exports, mod, mod.exports, require.relative(path)); + } + return mod.exports; + } + +require.modules = {}; + +require.resolve = function (path){ + var orig = path + , reg = path + '.js' + , index = path + '/index.js'; + return require.modules[reg] && reg + || require.modules[index] && index + || orig; + }; + +require.register = function (path, fn){ + require.modules[path] = fn; + }; + +require.relative = function (parent) { + return function(p){ + if ('.' != p.charAt(0)) return require(p); + + var path = parent.split('/') + , segs = p.split('/'); + path.pop(); + + for (var i = 0; i < segs.length; i++) { + var seg = segs[i]; + if ('..' == seg) path.pop(); + else if ('.' != seg) path.push(seg); + } + + return require(path.join('/')); + }; + }; + + +require.register("browser/debug.js", function(module, exports, require){ + +module.exports = function(type){ + return function(){ + } +}; + +}); // module: browser/debug.js + +require.register("browser/diff.js", function(module, exports, require){ +/* See LICENSE file for terms of use */ + +/* + * Text diff implementation. + * + * This library supports the following APIS: + * JsDiff.diffChars: Character by character diff + * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace + * JsDiff.diffLines: Line based diff + * + * JsDiff.diffCss: Diff targeted at CSS content + * + * These methods are based on the implementation proposed in + * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986). + * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927 + */ +var JsDiff = (function() { + /*jshint maxparams: 5*/ + function clonePath(path) { + return { newPos: path.newPos, components: path.components.slice(0) }; + } + function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + } + function escapeHTML(s) { + var n = s; + n = n.replace(/&/g, '&'); + n = n.replace(//g, '>'); + n = n.replace(/"/g, '"'); + + return n; + } + + var Diff = function(ignoreWhitespace) { + this.ignoreWhitespace = ignoreWhitespace; + }; + Diff.prototype = { + diff: function(oldString, newString) { + // Handle the identity case (this is due to unrolling editLength == 0 + if (newString === oldString) { + return [{ value: newString }]; + } + if (!newString) { + return [{ value: oldString, removed: true }]; + } + if (!oldString) { + return [{ value: newString, added: true }]; + } + + newString = this.tokenize(newString); + oldString = this.tokenize(oldString); + + var newLen = newString.length, oldLen = oldString.length; + var maxEditLength = newLen + oldLen; + var bestPath = [{ newPos: -1, components: [] }]; + + // Seed editLength = 0 + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) { + return bestPath[0].components; + } + + for (var editLength = 1; editLength <= maxEditLength; editLength++) { + for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) { + var basePath; + var addPath = bestPath[diagonalPath-1], + removePath = bestPath[diagonalPath+1]; + oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + // No one else is going to attempt to use this value, clear it + bestPath[diagonalPath-1] = undefined; + } + + var canAdd = addPath && addPath.newPos+1 < newLen; + var canRemove = removePath && 0 <= oldPos && oldPos < oldLen; + if (!canAdd && !canRemove) { + bestPath[diagonalPath] = undefined; + continue; + } + + // Select the diagonal that we want to branch from. We select the prior + // path whose position in the new string is the farthest from the origin + // and does not pass the bounds of the diff graph + if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) { + basePath = clonePath(removePath); + this.pushComponent(basePath.components, oldString[oldPos], undefined, true); + } else { + basePath = clonePath(addPath); + basePath.newPos++; + this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined); + } + + var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath); + + if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) { + return basePath.components; + } else { + bestPath[diagonalPath] = basePath; + } + } + } + }, + + pushComponent: function(components, value, added, removed) { + var last = components[components.length-1]; + if (last && last.added === added && last.removed === removed) { + // We need to clone here as the component clone operation is just + // as shallow array clone + components[components.length-1] = + {value: this.join(last.value, value), added: added, removed: removed }; + } else { + components.push({value: value, added: added, removed: removed }); + } + }, + extractCommon: function(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, + oldLen = oldString.length, + newPos = basePath.newPos, + oldPos = newPos - diagonalPath; + while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) { + newPos++; + oldPos++; + + this.pushComponent(basePath.components, newString[newPos], undefined, undefined); + } + basePath.newPos = newPos; + return oldPos; + }, + + equals: function(left, right) { + var reWhitespace = /\S/; + if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) { + return true; + } else { + return left === right; + } + }, + join: function(left, right) { + return left + right; + }, + tokenize: function(value) { + return value; + } + }; + + var CharDiff = new Diff(); + + var WordDiff = new Diff(true); + var WordWithSpaceDiff = new Diff(); + WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) { + return removeEmpty(value.split(/(\s+|\b)/)); + }; + + var CssDiff = new Diff(true); + CssDiff.tokenize = function(value) { + return removeEmpty(value.split(/([{}:;,]|\s+)/)); + }; + + var LineDiff = new Diff(); + LineDiff.tokenize = function(value) { + return value.split(/^/m); + }; + + return { + Diff: Diff, + + diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); }, + diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); }, + diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); }, + diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); }, + + diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); }, + + createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) { + var ret = []; + + ret.push('Index: ' + fileName); + ret.push('==================================================================='); + ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\t' + oldHeader)); + ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\t' + newHeader)); + + var diff = LineDiff.diff(oldStr, newStr); + if (!diff[diff.length-1].value) { + diff.pop(); // Remove trailing newline add + } + diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier + + function contextLines(lines) { + return lines.map(function(entry) { return ' ' + entry; }); + } + function eofNL(curRange, i, current) { + var last = diff[diff.length-2], + isLast = i === diff.length-2, + isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed); + + // Figure out if this is the last line for the given file and missing NL + if (!/\n$/.test(current.value) && (isLast || isLastOfType)) { + curRange.push('\\ No newline at end of file'); + } + } + + var oldRangeStart = 0, newRangeStart = 0, curRange = [], + oldLine = 1, newLine = 1; + for (var i = 0; i < diff.length; i++) { + var current = diff[i], + lines = current.lines || current.value.replace(/\n$/, '').split('\n'); + current.lines = lines; + + if (current.added || current.removed) { + if (!oldRangeStart) { + var prev = diff[i-1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + + if (prev) { + curRange = contextLines(prev.lines.slice(-4)); + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; })); + eofNL(curRange, i, current); + + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + if (oldRangeStart) { + // Close out any changes that have been output (or join overlapping) + if (lines.length <= 8 && i < diff.length-2) { + // Overlapping + curRange.push.apply(curRange, contextLines(lines)); + } else { + // end the range and output + var contextSize = Math.min(lines.length, 4); + ret.push( + '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize) + + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize) + + ' @@'); + ret.push.apply(ret, curRange); + ret.push.apply(ret, contextLines(lines.slice(0, contextSize))); + if (lines.length <= 4) { + eofNL(ret, i, current); + } + + oldRangeStart = 0; newRangeStart = 0; curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + } + + return ret.join('\n') + '\n'; + }, + + applyPatch: function(oldStr, uniDiff) { + var diffstr = uniDiff.split('\n'); + var diff = []; + var remEOFNL = false, + addEOFNL = false; + + for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) { + if(diffstr[i][0] === '@') { + var meh = diffstr[i].split(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/); + diff.unshift({ + start:meh[3], + oldlength:meh[2], + oldlines:[], + newlength:meh[4], + newlines:[] + }); + } else if(diffstr[i][0] === '+') { + diff[0].newlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === '-') { + diff[0].oldlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === ' ') { + diff[0].newlines.push(diffstr[i].substr(1)); + diff[0].oldlines.push(diffstr[i].substr(1)); + } else if(diffstr[i][0] === '\\') { + if (diffstr[i-1][0] === '+') { + remEOFNL = true; + } else if(diffstr[i-1][0] === '-') { + addEOFNL = true; + } + } + } + + var str = oldStr.split('\n'); + for (var i = diff.length - 1; i >= 0; i--) { + var d = diff[i]; + for (var j = 0; j < d.oldlength; j++) { + if(str[d.start-1+j] !== d.oldlines[j]) { + return false; + } + } + Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines)); + } + + if (remEOFNL) { + while (!str[str.length-1]) { + str.pop(); + } + } else if (addEOFNL) { + str.push(''); + } + return str.join('\n'); + }, + + convertChangesToXML: function(changes){ + var ret = []; + for ( var i = 0; i < changes.length; i++) { + var change = changes[i]; + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + + ret.push(escapeHTML(change.value)); + + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + } + return ret.join(''); + }, + + // See: http://code.google.com/p/google-diff-match-patch/wiki/API + convertChangesToDMP: function(changes){ + var ret = [], change; + for ( var i = 0; i < changes.length; i++) { + change = changes[i]; + ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]); + } + return ret; + } + }; +})(); + +if (typeof module !== 'undefined') { + module.exports = JsDiff; +} + +}); // module: browser/diff.js + +require.register("browser/events.js", function(module, exports, require){ + +/** + * Module exports. + */ + +exports.EventEmitter = EventEmitter; + +/** + * Check if `obj` is an array. + */ + +function isArray(obj) { + return '[object Array]' == {}.toString.call(obj); +} + +/** + * Event emitter constructor. + * + * @api public + */ + +function EventEmitter(){}; + +/** + * Adds a listener. + * + * @api public + */ + +EventEmitter.prototype.on = function (name, fn) { + if (!this.$events) { + this.$events = {}; + } + + if (!this.$events[name]) { + this.$events[name] = fn; + } else if (isArray(this.$events[name])) { + this.$events[name].push(fn); + } else { + this.$events[name] = [this.$events[name], fn]; + } + + return this; +}; + +EventEmitter.prototype.addListener = EventEmitter.prototype.on; + +/** + * Adds a volatile listener. + * + * @api public + */ + +EventEmitter.prototype.once = function (name, fn) { + var self = this; + + function on () { + self.removeListener(name, on); + fn.apply(this, arguments); + }; + + on.listener = fn; + this.on(name, on); + + return this; +}; + +/** + * Removes a listener. + * + * @api public + */ + +EventEmitter.prototype.removeListener = function (name, fn) { + if (this.$events && this.$events[name]) { + var list = this.$events[name]; + + if (isArray(list)) { + var pos = -1; + + for (var i = 0, l = list.length; i < l; i++) { + if (list[i] === fn || (list[i].listener && list[i].listener === fn)) { + pos = i; + break; + } + } + + if (pos < 0) { + return this; + } + + list.splice(pos, 1); + + if (!list.length) { + delete this.$events[name]; + } + } else if (list === fn || (list.listener && list.listener === fn)) { + delete this.$events[name]; + } + } + + return this; +}; + +/** + * Removes all listeners for an event. + * + * @api public + */ + +EventEmitter.prototype.removeAllListeners = function (name) { + if (name === undefined) { + this.$events = {}; + return this; + } + + if (this.$events && this.$events[name]) { + this.$events[name] = null; + } + + return this; +}; + +/** + * Gets all listeners for a certain event. + * + * @api public + */ + +EventEmitter.prototype.listeners = function (name) { + if (!this.$events) { + this.$events = {}; + } + + if (!this.$events[name]) { + this.$events[name] = []; + } + + if (!isArray(this.$events[name])) { + this.$events[name] = [this.$events[name]]; + } + + return this.$events[name]; +}; + +/** + * Emits an event. + * + * @api public + */ + +EventEmitter.prototype.emit = function (name) { + if (!this.$events) { + return false; + } + + var handler = this.$events[name]; + + if (!handler) { + return false; + } + + var args = [].slice.call(arguments, 1); + + if ('function' == typeof handler) { + handler.apply(this, args); + } else if (isArray(handler)) { + var listeners = handler.slice(); + + for (var i = 0, l = listeners.length; i < l; i++) { + listeners[i].apply(this, args); + } + } else { + return false; + } + + return true; +}; +}); // module: browser/events.js + +require.register("browser/fs.js", function(module, exports, require){ + +}); // module: browser/fs.js + +require.register("browser/path.js", function(module, exports, require){ + +}); // module: browser/path.js + +require.register("browser/progress.js", function(module, exports, require){ +/** + * Expose `Progress`. + */ + +module.exports = Progress; + +/** + * Initialize a new `Progress` indicator. + */ + +function Progress() { + this.percent = 0; + this.size(0); + this.fontSize(11); + this.font('helvetica, arial, sans-serif'); +} + +/** + * Set progress size to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.size = function(n){ + this._size = n; + return this; +}; + +/** + * Set text to `str`. + * + * @param {String} str + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.text = function(str){ + this._text = str; + return this; +}; + +/** + * Set font size to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + * @api public + */ + +Progress.prototype.fontSize = function(n){ + this._fontSize = n; + return this; +}; + +/** + * Set font `family`. + * + * @param {String} family + * @return {Progress} for chaining + */ + +Progress.prototype.font = function(family){ + this._font = family; + return this; +}; + +/** + * Update percentage to `n`. + * + * @param {Number} n + * @return {Progress} for chaining + */ + +Progress.prototype.update = function(n){ + this.percent = n; + return this; +}; + +/** + * Draw on `ctx`. + * + * @param {CanvasRenderingContext2d} ctx + * @return {Progress} for chaining + */ + +Progress.prototype.draw = function(ctx){ + try { + var percent = Math.min(this.percent, 100) + , size = this._size + , half = size / 2 + , x = half + , y = half + , rad = half - 1 + , fontSize = this._fontSize; + + ctx.font = fontSize + 'px ' + this._font; + + var angle = Math.PI * 2 * (percent / 100); + ctx.clearRect(0, 0, size, size); + + // outer circle + ctx.strokeStyle = '#9f9f9f'; + ctx.beginPath(); + ctx.arc(x, y, rad, 0, angle, false); + ctx.stroke(); + + // inner circle + ctx.strokeStyle = '#eee'; + ctx.beginPath(); + ctx.arc(x, y, rad - 1, 0, angle, true); + ctx.stroke(); + + // text + var text = this._text || (percent | 0) + '%' + , w = ctx.measureText(text).width; + + ctx.fillText( + text + , x - w / 2 + 1 + , y + fontSize / 2 - 1); + } catch (ex) {} //don't fail if we can't render progress + return this; +}; + +}); // module: browser/progress.js + +require.register("browser/tty.js", function(module, exports, require){ + +exports.isatty = function(){ + return true; +}; + +exports.getWindowSize = function(){ + if ('innerHeight' in global) { + return [global.innerHeight, global.innerWidth]; + } else { + // In a Web Worker, the DOM Window is not available. + return [640, 480]; + } +}; + +}); // module: browser/tty.js + +require.register("context.js", function(module, exports, require){ + +/** + * Expose `Context`. + */ + +module.exports = Context; + +/** + * Initialize a new `Context`. + * + * @api private + */ + +function Context(){} + +/** + * Set or get the context `Runnable` to `runnable`. + * + * @param {Runnable} runnable + * @return {Context} + * @api private + */ + +Context.prototype.runnable = function(runnable){ + if (0 == arguments.length) return this._runnable; + this.test = this._runnable = runnable; + return this; +}; + +/** + * Set test timeout `ms`. + * + * @param {Number} ms + * @return {Context} self + * @api private + */ + +Context.prototype.timeout = function(ms){ + if (arguments.length === 0) return this.runnable().timeout(); + this.runnable().timeout(ms); + return this; +}; + +/** + * Set test timeout `enabled`. + * + * @param {Boolean} enabled + * @return {Context} self + * @api private + */ + +Context.prototype.enableTimeouts = function (enabled) { + this.runnable().enableTimeouts(enabled); + return this; +}; + + +/** + * Set test slowness threshold `ms`. + * + * @param {Number} ms + * @return {Context} self + * @api private + */ + +Context.prototype.slow = function(ms){ + this.runnable().slow(ms); + return this; +}; + +/** + * Inspect the context void of `._runnable`. + * + * @return {String} + * @api private + */ + +Context.prototype.inspect = function(){ + return JSON.stringify(this, function(key, val){ + if ('_runnable' == key) return; + if ('test' == key) return; + return val; + }, 2); +}; + +}); // module: context.js + +require.register("hook.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Runnable = require('./runnable'); + +/** + * Expose `Hook`. + */ + +module.exports = Hook; + +/** + * Initialize a new `Hook` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Hook(title, fn) { + Runnable.call(this, title, fn); + this.type = 'hook'; +} + +/** + * Inherit from `Runnable.prototype`. + */ + +function F(){}; +F.prototype = Runnable.prototype; +Hook.prototype = new F; +Hook.prototype.constructor = Hook; + + +/** + * Get or set the test `err`. + * + * @param {Error} err + * @return {Error} + * @api public + */ + +Hook.prototype.error = function(err){ + if (0 == arguments.length) { + var err = this._error; + this._error = null; + return err; + } + + this._error = err; +}; + +}); // module: hook.js + +require.register("interfaces/bdd.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils'); + +/** + * BDD-style interface: + * + * describe('Array', function(){ + * describe('#indexOf()', function(){ + * it('should return -1 when not present', function(){ + * + * }); + * + * it('should return the index when present', function(){ + * + * }); + * }); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before running tests. + */ + + context.before = function(name, fn){ + suites[0].beforeAll(name, fn); + }; + + /** + * Execute after running tests. + */ + + context.after = function(name, fn){ + suites[0].afterAll(name, fn); + }; + + /** + * Execute before each test case. + */ + + context.beforeEach = function(name, fn){ + suites[0].beforeEach(name, fn); + }; + + /** + * Execute after each test case. + */ + + context.afterEach = function(name, fn){ + suites[0].afterEach(name, fn); + }; + + /** + * Describe a "suite" with the given `title` + * and callback `fn` containing nested suites + * and/or tests. + */ + + context.describe = context.context = function(title, fn){ + var suite = Suite.create(suites[0], title); + suite.file = file; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + return suite; + }; + + /** + * Pending describe. + */ + + context.xdescribe = + context.xcontext = + context.describe.skip = function(title, fn){ + var suite = Suite.create(suites[0], title); + suite.pending = true; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + }; + + /** + * Exclusive suite. + */ + + context.describe.only = function(title, fn){ + var suite = context.describe(title, fn); + mocha.grep(suite.fullTitle()); + return suite; + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.it = context.specify = function(title, fn){ + var suite = suites[0]; + if (suite.pending) var fn = null; + var test = new Test(title, fn); + test.file = file; + suite.addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.it.only = function(title, fn){ + var test = context.it(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + return test; + }; + + /** + * Pending test case. + */ + + context.xit = + context.xspecify = + context.it.skip = function(title){ + context.it(title); + }; + }); +}; + +}); // module: interfaces/bdd.js + +require.register("interfaces/exports.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test'); + +/** + * TDD-style interface: + * + * exports.Array = { + * '#indexOf()': { + * 'should return -1 when the value is not present': function(){ + * + * }, + * + * 'should return the correct index when the value is present': function(){ + * + * } + * } + * }; + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('require', visit); + + function visit(obj, file) { + var suite; + for (var key in obj) { + if ('function' == typeof obj[key]) { + var fn = obj[key]; + switch (key) { + case 'before': + suites[0].beforeAll(fn); + break; + case 'after': + suites[0].afterAll(fn); + break; + case 'beforeEach': + suites[0].beforeEach(fn); + break; + case 'afterEach': + suites[0].afterEach(fn); + break; + default: + var test = new Test(key, fn); + test.file = file; + suites[0].addTest(test); + } + } else { + var suite = Suite.create(suites[0], key); + suites.unshift(suite); + visit(obj[key]); + suites.shift(); + } + } + } +}; + +}); // module: interfaces/exports.js + +require.register("interfaces/index.js", function(module, exports, require){ + +exports.bdd = require('./bdd'); +exports.tdd = require('./tdd'); +exports.qunit = require('./qunit'); +exports.exports = require('./exports'); + +}); // module: interfaces/index.js + +require.register("interfaces/qunit.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils'); + +/** + * QUnit-style interface: + * + * suite('Array'); + * + * test('#length', function(){ + * var arr = [1,2,3]; + * ok(arr.length == 3); + * }); + * + * test('#indexOf()', function(){ + * var arr = [1,2,3]; + * ok(arr.indexOf(1) == 0); + * ok(arr.indexOf(2) == 1); + * ok(arr.indexOf(3) == 2); + * }); + * + * suite('String'); + * + * test('#length', function(){ + * ok('foo'.length == 3); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before running tests. + */ + + context.before = function(name, fn){ + suites[0].beforeAll(name, fn); + }; + + /** + * Execute after running tests. + */ + + context.after = function(name, fn){ + suites[0].afterAll(name, fn); + }; + + /** + * Execute before each test case. + */ + + context.beforeEach = function(name, fn){ + suites[0].beforeEach(name, fn); + }; + + /** + * Execute after each test case. + */ + + context.afterEach = function(name, fn){ + suites[0].afterEach(name, fn); + }; + + /** + * Describe a "suite" with the given `title`. + */ + + context.suite = function(title){ + if (suites.length > 1) suites.shift(); + var suite = Suite.create(suites[0], title); + suite.file = file; + suites.unshift(suite); + return suite; + }; + + /** + * Exclusive test-case. + */ + + context.suite.only = function(title, fn){ + var suite = context.suite(title, fn); + mocha.grep(suite.fullTitle()); + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.test = function(title, fn){ + var test = new Test(title, fn); + test.file = file; + suites[0].addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.test.only = function(title, fn){ + var test = context.test(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + }; + + /** + * Pending test case. + */ + + context.test.skip = function(title){ + context.test(title); + }; + }); +}; + +}); // module: interfaces/qunit.js + +require.register("interfaces/tdd.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Suite = require('../suite') + , Test = require('../test') + , utils = require('../utils');; + +/** + * TDD-style interface: + * + * suite('Array', function(){ + * suite('#indexOf()', function(){ + * suiteSetup(function(){ + * + * }); + * + * test('should return -1 when not present', function(){ + * + * }); + * + * test('should return the index when present', function(){ + * + * }); + * + * suiteTeardown(function(){ + * + * }); + * }); + * }); + * + */ + +module.exports = function(suite){ + var suites = [suite]; + + suite.on('pre-require', function(context, file, mocha){ + + /** + * Execute before each test case. + */ + + context.setup = function(name, fn){ + suites[0].beforeEach(name, fn); + }; + + /** + * Execute after each test case. + */ + + context.teardown = function(name, fn){ + suites[0].afterEach(name, fn); + }; + + /** + * Execute before the suite. + */ + + context.suiteSetup = function(name, fn){ + suites[0].beforeAll(name, fn); + }; + + /** + * Execute after the suite. + */ + + context.suiteTeardown = function(name, fn){ + suites[0].afterAll(name, fn); + }; + + /** + * Describe a "suite" with the given `title` + * and callback `fn` containing nested suites + * and/or tests. + */ + + context.suite = function(title, fn){ + var suite = Suite.create(suites[0], title); + suite.file = file; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + return suite; + }; + + /** + * Pending suite. + */ + context.suite.skip = function(title, fn) { + var suite = Suite.create(suites[0], title); + suite.pending = true; + suites.unshift(suite); + fn.call(suite); + suites.shift(); + }; + + /** + * Exclusive test-case. + */ + + context.suite.only = function(title, fn){ + var suite = context.suite(title, fn); + mocha.grep(suite.fullTitle()); + }; + + /** + * Describe a specification or test-case + * with the given `title` and callback `fn` + * acting as a thunk. + */ + + context.test = function(title, fn){ + var suite = suites[0]; + if (suite.pending) var fn = null; + var test = new Test(title, fn); + test.file = file; + suite.addTest(test); + return test; + }; + + /** + * Exclusive test-case. + */ + + context.test.only = function(title, fn){ + var test = context.test(title, fn); + var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$'; + mocha.grep(new RegExp(reString)); + }; + + /** + * Pending test case. + */ + + context.test.skip = function(title){ + context.test(title); + }; + }); +}; + +}); // module: interfaces/tdd.js + +require.register("mocha.js", function(module, exports, require){ +/*! + * mocha + * Copyright(c) 2011 TJ Holowaychuk + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var path = require('browser/path') + , utils = require('./utils'); + +/** + * Expose `Mocha`. + */ + +exports = module.exports = Mocha; + +/** + * To require local UIs and reporters when running in node. + */ + +if (typeof process !== 'undefined' && typeof process.cwd === 'function') { + var join = path.join + , cwd = process.cwd(); + module.paths.push(cwd, join(cwd, 'node_modules')); +} + +/** + * Expose internals. + */ + +exports.utils = utils; +exports.interfaces = require('./interfaces'); +exports.reporters = require('./reporters'); +exports.Runnable = require('./runnable'); +exports.Context = require('./context'); +exports.Runner = require('./runner'); +exports.Suite = require('./suite'); +exports.Hook = require('./hook'); +exports.Test = require('./test'); + +/** + * Return image `name` path. + * + * @param {String} name + * @return {String} + * @api private + */ + +function image(name) { + return __dirname + '/../images/' + name + '.png'; +} + +/** + * Setup mocha with `options`. + * + * Options: + * + * - `ui` name "bdd", "tdd", "exports" etc + * - `reporter` reporter instance, defaults to `mocha.reporters.spec` + * - `globals` array of accepted globals + * - `timeout` timeout in milliseconds + * - `bail` bail on the first test failure + * - `slow` milliseconds to wait before considering a test slow + * - `ignoreLeaks` ignore global leaks + * - `grep` string or regexp to filter tests with + * + * @param {Object} options + * @api public + */ + +function Mocha(options) { + options = options || {}; + this.files = []; + this.options = options; + this.grep(options.grep); + this.suite = new exports.Suite('', new exports.Context); + this.ui(options.ui); + this.bail(options.bail); + this.reporter(options.reporter); + if (null != options.timeout) this.timeout(options.timeout); + this.useColors(options.useColors) + if (options.enableTimeouts !== null) this.enableTimeouts(options.enableTimeouts); + if (options.slow) this.slow(options.slow); + + this.suite.on('pre-require', function (context) { + exports.afterEach = context.afterEach || context.teardown; + exports.after = context.after || context.suiteTeardown; + exports.beforeEach = context.beforeEach || context.setup; + exports.before = context.before || context.suiteSetup; + exports.describe = context.describe || context.suite; + exports.it = context.it || context.test; + exports.setup = context.setup || context.beforeEach; + exports.suiteSetup = context.suiteSetup || context.before; + exports.suiteTeardown = context.suiteTeardown || context.after; + exports.suite = context.suite || context.describe; + exports.teardown = context.teardown || context.afterEach; + exports.test = context.test || context.it; + }); +} + +/** + * Enable or disable bailing on the first failure. + * + * @param {Boolean} [bail] + * @api public + */ + +Mocha.prototype.bail = function(bail){ + if (0 == arguments.length) bail = true; + this.suite.bail(bail); + return this; +}; + +/** + * Add test `file`. + * + * @param {String} file + * @api public + */ + +Mocha.prototype.addFile = function(file){ + this.files.push(file); + return this; +}; + +/** + * Set reporter to `reporter`, defaults to "spec". + * + * @param {String|Function} reporter name or constructor + * @api public + */ + +Mocha.prototype.reporter = function(reporter){ + if ('function' == typeof reporter) { + this._reporter = reporter; + } else { + reporter = reporter || 'spec'; + var _reporter; + try { _reporter = require('./reporters/' + reporter); } catch (err) {}; + if (!_reporter) try { _reporter = require(reporter); } catch (err) {}; + if (!_reporter && reporter === 'teamcity') + console.warn('The Teamcity reporter was moved to a package named ' + + 'mocha-teamcity-reporter ' + + '(https://npmjs.org/package/mocha-teamcity-reporter).'); + if (!_reporter) throw new Error('invalid reporter "' + reporter + '"'); + this._reporter = _reporter; + } + return this; +}; + +/** + * Set test UI `name`, defaults to "bdd". + * + * @param {String} bdd + * @api public + */ + +Mocha.prototype.ui = function(name){ + name = name || 'bdd'; + this._ui = exports.interfaces[name]; + if (!this._ui) try { this._ui = require(name); } catch (err) {}; + if (!this._ui) throw new Error('invalid interface "' + name + '"'); + this._ui = this._ui(this.suite); + return this; +}; + +/** + * Load registered files. + * + * @api private + */ + +Mocha.prototype.loadFiles = function(fn){ + var self = this; + var suite = this.suite; + var pending = this.files.length; + this.files.forEach(function(file){ + file = path.resolve(file); + suite.emit('pre-require', global, file, self); + suite.emit('require', require(file), file, self); + suite.emit('post-require', global, file, self); + --pending || (fn && fn()); + }); +}; + +/** + * Enable growl support. + * + * @api private + */ + +Mocha.prototype._growl = function(runner, reporter) { + var notify = require('growl'); + + runner.on('end', function(){ + var stats = reporter.stats; + if (stats.failures) { + var msg = stats.failures + ' of ' + runner.total + ' tests failed'; + notify(msg, { name: 'mocha', title: 'Failed', image: image('error') }); + } else { + notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', { + name: 'mocha' + , title: 'Passed' + , image: image('ok') + }); + } + }); +}; + +/** + * Add regexp to grep, if `re` is a string it is escaped. + * + * @param {RegExp|String} re + * @return {Mocha} + * @api public + */ + +Mocha.prototype.grep = function(re){ + this.options.grep = 'string' == typeof re + ? new RegExp(utils.escapeRegexp(re)) + : re; + return this; +}; + +/** + * Invert `.grep()` matches. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.invert = function(){ + this.options.invert = true; + return this; +}; + +/** + * Ignore global leaks. + * + * @param {Boolean} ignore + * @return {Mocha} + * @api public + */ + +Mocha.prototype.ignoreLeaks = function(ignore){ + this.options.ignoreLeaks = !!ignore; + return this; +}; + +/** + * Enable global leak checking. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.checkLeaks = function(){ + this.options.ignoreLeaks = false; + return this; +}; + +/** + * Enable growl support. + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.growl = function(){ + this.options.growl = true; + return this; +}; + +/** + * Ignore `globals` array or string. + * + * @param {Array|String} globals + * @return {Mocha} + * @api public + */ + +Mocha.prototype.globals = function(globals){ + this.options.globals = (this.options.globals || []).concat(globals); + return this; +}; + +/** + * Emit color output. + * + * @param {Boolean} colors + * @return {Mocha} + * @api public + */ + +Mocha.prototype.useColors = function(colors){ + this.options.useColors = arguments.length && colors != undefined + ? colors + : true; + return this; +}; + +/** + * Use inline diffs rather than +/-. + * + * @param {Boolean} inlineDiffs + * @return {Mocha} + * @api public + */ + +Mocha.prototype.useInlineDiffs = function(inlineDiffs) { + this.options.useInlineDiffs = arguments.length && inlineDiffs != undefined + ? inlineDiffs + : false; + return this; +}; + +/** + * Set the timeout in milliseconds. + * + * @param {Number} timeout + * @return {Mocha} + * @api public + */ + +Mocha.prototype.timeout = function(timeout){ + this.suite.timeout(timeout); + return this; +}; + +/** + * Set slowness threshold in milliseconds. + * + * @param {Number} slow + * @return {Mocha} + * @api public + */ + +Mocha.prototype.slow = function(slow){ + this.suite.slow(slow); + return this; +}; + +/** + * Enable timeouts. + * + * @param {Boolean} enabled + * @return {Mocha} + * @api public + */ + +Mocha.prototype.enableTimeouts = function(enabled) { + this.suite.enableTimeouts(arguments.length && enabled !== undefined + ? enabled + : true); + return this +}; + +/** + * Makes all tests async (accepting a callback) + * + * @return {Mocha} + * @api public + */ + +Mocha.prototype.asyncOnly = function(){ + this.options.asyncOnly = true; + return this; +}; + +/** + * Run tests and invoke `fn()` when complete. + * + * @param {Function} fn + * @return {Runner} + * @api public + */ + +Mocha.prototype.run = function(fn){ + if (this.files.length) this.loadFiles(); + var suite = this.suite; + var options = this.options; + options.files = this.files; + var runner = new exports.Runner(suite); + var reporter = new this._reporter(runner, options); + runner.ignoreLeaks = false !== options.ignoreLeaks; + runner.asyncOnly = options.asyncOnly; + if (options.grep) runner.grep(options.grep, options.invert); + if (options.globals) runner.globals(options.globals); + if (options.growl) this._growl(runner, reporter); + exports.reporters.Base.useColors = options.useColors; + exports.reporters.Base.inlineDiffs = options.useInlineDiffs; + return runner.run(fn); +}; + +}); // module: mocha.js + +require.register("ms.js", function(module, exports, require){ +/** + * Helpers. + */ + +var s = 1000; +var m = s * 60; +var h = m * 60; +var d = h * 24; +var y = d * 365.25; + +/** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} options + * @return {String|Number} + * @api public + */ + +module.exports = function(val, options){ + options = options || {}; + if ('string' == typeof val) return parse(val); + return options.long ? longFormat(val) : shortFormat(val); +}; + +/** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + +function parse(str) { + var match = /^((?:\d+)?\.?\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str); + if (!match) return; + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'y': + return n * y; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 's': + return n * s; + case 'ms': + return n; + } +} + +/** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function shortFormat(ms) { + if (ms >= d) return Math.round(ms / d) + 'd'; + if (ms >= h) return Math.round(ms / h) + 'h'; + if (ms >= m) return Math.round(ms / m) + 'm'; + if (ms >= s) return Math.round(ms / s) + 's'; + return ms + 'ms'; +} + +/** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + +function longFormat(ms) { + return plural(ms, d, 'day') + || plural(ms, h, 'hour') + || plural(ms, m, 'minute') + || plural(ms, s, 'second') + || ms + ' ms'; +} + +/** + * Pluralization helper. + */ + +function plural(ms, n, name) { + if (ms < n) return; + if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name; + return Math.ceil(ms / n) + ' ' + name + 's'; +} + +}); // module: ms.js + +require.register("reporters/base.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var tty = require('browser/tty') + , diff = require('browser/diff') + , ms = require('../ms') + , utils = require('../utils'); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Check if both stdio streams are associated with a tty. + */ + +var isatty = tty.isatty(1) && tty.isatty(2); + +/** + * Expose `Base`. + */ + +exports = module.exports = Base; + +/** + * Enable coloring by default. + */ + +exports.useColors = isatty || (process.env.MOCHA_COLORS !== undefined); + +/** + * Inline diffs instead of +/- + */ + +exports.inlineDiffs = false; + +/** + * Default color map. + */ + +exports.colors = { + 'pass': 90 + , 'fail': 31 + , 'bright pass': 92 + , 'bright fail': 91 + , 'bright yellow': 93 + , 'pending': 36 + , 'suite': 0 + , 'error title': 0 + , 'error message': 31 + , 'error stack': 90 + , 'checkmark': 32 + , 'fast': 90 + , 'medium': 33 + , 'slow': 31 + , 'green': 32 + , 'light': 90 + , 'diff gutter': 90 + , 'diff added': 42 + , 'diff removed': 41 +}; + +/** + * Default symbol map. + */ + +exports.symbols = { + ok: '✓', + err: '✖', + dot: '․' +}; + +// With node.js on Windows: use symbols available in terminal default fonts +if ('win32' == process.platform) { + exports.symbols.ok = '\u221A'; + exports.symbols.err = '\u00D7'; + exports.symbols.dot = '.'; +} + +/** + * Color `str` with the given `type`, + * allowing colors to be disabled, + * as well as user-defined color + * schemes. + * + * @param {String} type + * @param {String} str + * @return {String} + * @api private + */ + +var color = exports.color = function(type, str) { + if (!exports.useColors) return str; + return '\u001b[' + exports.colors[type] + 'm' + str + '\u001b[0m'; +}; + +/** + * Expose term window size, with some + * defaults for when stderr is not a tty. + */ + +exports.window = { + width: isatty + ? process.stdout.getWindowSize + ? process.stdout.getWindowSize(1)[0] + : tty.getWindowSize()[1] + : 75 +}; + +/** + * Expose some basic cursor interactions + * that are common among reporters. + */ + +exports.cursor = { + hide: function(){ + isatty && process.stdout.write('\u001b[?25l'); + }, + + show: function(){ + isatty && process.stdout.write('\u001b[?25h'); + }, + + deleteLine: function(){ + isatty && process.stdout.write('\u001b[2K'); + }, + + beginningOfLine: function(){ + isatty && process.stdout.write('\u001b[0G'); + }, + + CR: function(){ + if (isatty) { + exports.cursor.deleteLine(); + exports.cursor.beginningOfLine(); + } else { + process.stdout.write('\r'); + } + } +}; + +/** + * Outut the given `failures` as a list. + * + * @param {Array} failures + * @api public + */ + +exports.list = function(failures){ + console.error(); + failures.forEach(function(test, i){ + // format + var fmt = color('error title', ' %s) %s:\n') + + color('error message', ' %s') + + color('error stack', '\n%s\n'); + + // msg + var err = test.err + , message = err.message || '' + , stack = err.stack || message + , index = stack.indexOf(message) + message.length + , msg = stack.slice(0, index) + , actual = err.actual + , expected = err.expected + , escape = true; + + // uncaught + if (err.uncaught) { + msg = 'Uncaught ' + msg; + } + + // explicitly show diff + if (err.showDiff && sameType(actual, expected)) { + escape = false; + err.actual = actual = utils.stringify(actual); + err.expected = expected = utils.stringify(expected); + } + + // actual / expected diff + if ('string' == typeof actual && 'string' == typeof expected) { + fmt = color('error title', ' %s) %s:\n%s') + color('error stack', '\n%s\n'); + var match = message.match(/^([^:]+): expected/); + msg = '\n ' + color('error message', match ? match[1] : msg); + + if (exports.inlineDiffs) { + msg += inlineDiff(err, escape); + } else { + msg += unifiedDiff(err, escape); + } + } + + // indent stack trace without msg + stack = stack.slice(index ? index + 1 : index) + .replace(/^/gm, ' '); + + console.error(fmt, (i + 1), test.fullTitle(), msg, stack); + }); +}; + +/** + * Initialize a new `Base` reporter. + * + * All other reporters generally + * inherit from this reporter, providing + * stats such as test duration, number + * of tests passed / failed etc. + * + * @param {Runner} runner + * @api public + */ + +function Base(runner) { + var self = this + , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 } + , failures = this.failures = []; + + if (!runner) return; + this.runner = runner; + + runner.stats = stats; + + runner.on('start', function(){ + stats.start = new Date; + }); + + runner.on('suite', function(suite){ + stats.suites = stats.suites || 0; + suite.root || stats.suites++; + }); + + runner.on('test end', function(test){ + stats.tests = stats.tests || 0; + stats.tests++; + }); + + runner.on('pass', function(test){ + stats.passes = stats.passes || 0; + + var medium = test.slow() / 2; + test.speed = test.duration > test.slow() + ? 'slow' + : test.duration > medium + ? 'medium' + : 'fast'; + + stats.passes++; + }); + + runner.on('fail', function(test, err){ + stats.failures = stats.failures || 0; + stats.failures++; + test.err = err; + failures.push(test); + }); + + runner.on('end', function(){ + stats.end = new Date; + stats.duration = new Date - stats.start; + }); + + runner.on('pending', function(){ + stats.pending++; + }); +} + +/** + * Output common epilogue used by many of + * the bundled reporters. + * + * @api public + */ + +Base.prototype.epilogue = function(){ + var stats = this.stats; + var tests; + var fmt; + + console.log(); + + // passes + fmt = color('bright pass', ' ') + + color('green', ' %d passing') + + color('light', ' (%s)'); + + console.log(fmt, + stats.passes || 0, + ms(stats.duration)); + + // pending + if (stats.pending) { + fmt = color('pending', ' ') + + color('pending', ' %d pending'); + + console.log(fmt, stats.pending); + } + + // failures + if (stats.failures) { + fmt = color('fail', ' %d failing'); + + console.error(fmt, + stats.failures); + + Base.list(this.failures); + console.error(); + } + + console.log(); +}; + +/** + * Pad the given `str` to `len`. + * + * @param {String} str + * @param {String} len + * @return {String} + * @api private + */ + +function pad(str, len) { + str = String(str); + return Array(len - str.length + 1).join(' ') + str; +} + + +/** + * Returns an inline diff between 2 strings with coloured ANSI output + * + * @param {Error} Error with actual/expected + * @return {String} Diff + * @api private + */ + +function inlineDiff(err, escape) { + var msg = errorDiff(err, 'WordsWithSpace', escape); + + // linenos + var lines = msg.split('\n'); + if (lines.length > 4) { + var width = String(lines.length).length; + msg = lines.map(function(str, i){ + return pad(++i, width) + ' |' + ' ' + str; + }).join('\n'); + } + + // legend + msg = '\n' + + color('diff removed', 'actual') + + ' ' + + color('diff added', 'expected') + + '\n\n' + + msg + + '\n'; + + // indent + msg = msg.replace(/^/gm, ' '); + return msg; +} + +/** + * Returns a unified diff between 2 strings + * + * @param {Error} Error with actual/expected + * @return {String} Diff + * @api private + */ + +function unifiedDiff(err, escape) { + var indent = ' '; + function cleanUp(line) { + if (escape) { + line = escapeInvisibles(line); + } + if (line[0] === '+') return indent + colorLines('diff added', line); + if (line[0] === '-') return indent + colorLines('diff removed', line); + if (line.match(/\@\@/)) return null; + if (line.match(/\\ No newline/)) return null; + else return indent + line; + } + function notBlank(line) { + return line != null; + } + msg = diff.createPatch('string', err.actual, err.expected); + var lines = msg.split('\n').splice(4); + return '\n ' + + colorLines('diff added', '+ expected') + ' ' + + colorLines('diff removed', '- actual') + + '\n\n' + + lines.map(cleanUp).filter(notBlank).join('\n'); +} + +/** + * Return a character diff for `err`. + * + * @param {Error} err + * @return {String} + * @api private + */ + +function errorDiff(err, type, escape) { + var actual = escape ? escapeInvisibles(err.actual) : err.actual; + var expected = escape ? escapeInvisibles(err.expected) : err.expected; + return diff['diff' + type](actual, expected).map(function(str){ + if (str.added) return colorLines('diff added', str.value); + if (str.removed) return colorLines('diff removed', str.value); + return str.value; + }).join(''); +} + +/** + * Returns a string with all invisible characters in plain text + * + * @param {String} line + * @return {String} + * @api private + */ +function escapeInvisibles(line) { + return line.replace(/\t/g, '') + .replace(/\r/g, '') + .replace(/\n/g, '\n'); +} + +/** + * Color lines for `str`, using the color `name`. + * + * @param {String} name + * @param {String} str + * @return {String} + * @api private + */ + +function colorLines(name, str) { + return str.split('\n').map(function(str){ + return color(name, str); + }).join('\n'); +} + +/** + * Check that a / b have the same type. + * + * @param {Object} a + * @param {Object} b + * @return {Boolean} + * @api private + */ + +function sameType(a, b) { + a = Object.prototype.toString.call(a); + b = Object.prototype.toString.call(b); + return a == b; +} + +}); // module: reporters/base.js + +require.register("reporters/doc.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils'); + +/** + * Expose `Doc`. + */ + +exports = module.exports = Doc; + +/** + * Initialize a new `Doc` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Doc(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total + , indents = 2; + + function indent() { + return Array(indents).join(' '); + } + + runner.on('suite', function(suite){ + if (suite.root) return; + ++indents; + console.log('%s
', indent()); + ++indents; + console.log('%s

%s

', indent(), utils.escape(suite.title)); + console.log('%s
', indent()); + }); + + runner.on('suite end', function(suite){ + if (suite.root) return; + console.log('%s
', indent()); + --indents; + console.log('%s
', indent()); + --indents; + }); + + runner.on('pass', function(test){ + console.log('%s
%s
', indent(), utils.escape(test.title)); + var code = utils.escape(utils.clean(test.fn.toString())); + console.log('%s 
%s
', indent(), code); + }); + + runner.on('fail', function(test, err){ + console.log('%s
%s
', indent(), utils.escape(test.title)); + var code = utils.escape(utils.clean(test.fn.toString())); + console.log('%s 
%s
', indent(), code); + console.log('%s
%s
', indent(), utils.escape(err)); + }); +} + +}); // module: reporters/doc.js + +require.register("reporters/dot.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `Dot`. + */ + +exports = module.exports = Dot; + +/** + * Initialize a new `Dot` matrix test reporter. + * + * @param {Runner} runner + * @api public + */ + +function Dot(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , n = -1; + + runner.on('start', function(){ + process.stdout.write('\n '); + }); + + runner.on('pending', function(test){ + if (++n % width == 0) process.stdout.write('\n '); + process.stdout.write(color('pending', Base.symbols.dot)); + }); + + runner.on('pass', function(test){ + if (++n % width == 0) process.stdout.write('\n '); + if ('slow' == test.speed) { + process.stdout.write(color('bright yellow', Base.symbols.dot)); + } else { + process.stdout.write(color(test.speed, Base.symbols.dot)); + } + }); + + runner.on('fail', function(test, err){ + if (++n % width == 0) process.stdout.write('\n '); + process.stdout.write(color('fail', Base.symbols.dot)); + }); + + runner.on('end', function(){ + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Dot.prototype = new F; +Dot.prototype.constructor = Dot; + + +}); // module: reporters/dot.js + +require.register("reporters/html-cov.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var JSONCov = require('./json-cov') + , fs = require('browser/fs'); + +/** + * Expose `HTMLCov`. + */ + +exports = module.exports = HTMLCov; + +/** + * Initialize a new `JsCoverage` reporter. + * + * @param {Runner} runner + * @api public + */ + +function HTMLCov(runner) { + var jade = require('jade') + , file = __dirname + '/templates/coverage.jade' + , str = fs.readFileSync(file, 'utf8') + , fn = jade.compile(str, { filename: file }) + , self = this; + + JSONCov.call(this, runner, false); + + runner.on('end', function(){ + process.stdout.write(fn({ + cov: self.cov + , coverageClass: coverageClass + })); + }); +} + +/** + * Return coverage class for `n`. + * + * @return {String} + * @api private + */ + +function coverageClass(n) { + if (n >= 75) return 'high'; + if (n >= 50) return 'medium'; + if (n >= 25) return 'low'; + return 'terrible'; +} +}); // module: reporters/html-cov.js + +require.register("reporters/html.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils') + , Progress = require('../browser/progress') + , escape = utils.escape; + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Expose `HTML`. + */ + +exports = module.exports = HTML; + +/** + * Stats template. + */ + +var statsTemplate = ''; + +/** + * Initialize a new `HTML` reporter. + * + * @param {Runner} runner + * @api public + */ + +function HTML(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total + , stat = fragment(statsTemplate) + , items = stat.getElementsByTagName('li') + , passes = items[1].getElementsByTagName('em')[0] + , passesLink = items[1].getElementsByTagName('a')[0] + , failures = items[2].getElementsByTagName('em')[0] + , failuresLink = items[2].getElementsByTagName('a')[0] + , duration = items[3].getElementsByTagName('em')[0] + , canvas = stat.getElementsByTagName('canvas')[0] + , report = fragment('
    ') + , stack = [report] + , progress + , ctx + , root = document.getElementById('mocha'); + + if (canvas.getContext) { + var ratio = window.devicePixelRatio || 1; + canvas.style.width = canvas.width; + canvas.style.height = canvas.height; + canvas.width *= ratio; + canvas.height *= ratio; + ctx = canvas.getContext('2d'); + ctx.scale(ratio, ratio); + progress = new Progress; + } + + if (!root) return error('#mocha div missing, add it to your document'); + + // pass toggle + on(passesLink, 'click', function(){ + unhide(); + var name = /pass/.test(report.className) ? '' : ' pass'; + report.className = report.className.replace(/fail|pass/g, '') + name; + if (report.className.trim()) hideSuitesWithout('test pass'); + }); + + // failure toggle + on(failuresLink, 'click', function(){ + unhide(); + var name = /fail/.test(report.className) ? '' : ' fail'; + report.className = report.className.replace(/fail|pass/g, '') + name; + if (report.className.trim()) hideSuitesWithout('test fail'); + }); + + root.appendChild(stat); + root.appendChild(report); + + if (progress) progress.size(40); + + runner.on('suite', function(suite){ + if (suite.root) return; + + // suite + var url = self.suiteURL(suite); + var el = fragment('

  • %s

    • ', url, escape(suite.title)); + + // container + stack[0].appendChild(el); + stack.unshift(document.createElement('ul')); + el.appendChild(stack[0]); + }); + + runner.on('suite end', function(suite){ + if (suite.root) return; + stack.shift(); + }); + + runner.on('fail', function(test, err){ + if ('hook' == test.type) runner.emit('test end', test); + }); + + runner.on('test end', function(test){ + // TODO: add to stats + var percent = stats.tests / this.total * 100 | 0; + if (progress) progress.update(percent).draw(ctx); + + // update stats + var ms = new Date - stats.start; + text(passes, stats.passes); + text(failures, stats.failures); + text(duration, (ms / 1000).toFixed(2)); + + // test + if ('passed' == test.state) { + var url = self.testURL(test); + var el = fragment('

  • %e%ems ‣

    • ', test.speed, test.title, test.duration, url); + } else if (test.pending) { + var el = fragment('

  • %e

    • ', test.title); + } else { + var el = fragment('

  • %e ‣

    • ', test.title, encodeURIComponent(test.fullTitle())); + var str = test.err.stack || test.err.toString(); + + // FF / Opera do not add the message + if (!~str.indexOf(test.err.message)) { + str = test.err.message + '\n' + str; + } + + // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we + // check for the result of the stringifying. + if ('[object Error]' == str) str = test.err.message; + + // Safari doesn't give you a stack. Let's at least provide a source line. + if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) { + str += "\n(" + test.err.sourceURL + ":" + test.err.line + ")"; + } + + el.appendChild(fragment('
    %e
    ', str)); + } + + // toggle code + // TODO: defer + if (!test.pending) { + var h2 = el.getElementsByTagName('h2')[0]; + + on(h2, 'click', function(){ + pre.style.display = 'none' == pre.style.display + ? 'block' + : 'none'; + }); + + var pre = fragment('
    %e
    ', utils.clean(test.fn.toString())); + el.appendChild(pre); + pre.style.display = 'none'; + } + + // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack. + if (stack[0]) stack[0].appendChild(el); + }); +} + +/** + * Provide suite URL + * + * @param {Object} [suite] + */ + +HTML.prototype.suiteURL = function(suite){ + return '?grep=' + encodeURIComponent(suite.fullTitle()); +}; + +/** + * Provide test URL + * + * @param {Object} [test] + */ + +HTML.prototype.testURL = function(test){ + return '?grep=' + encodeURIComponent(test.fullTitle()); +}; + +/** + * Display error `msg`. + */ + +function error(msg) { + document.body.appendChild(fragment('
    %s
    ', msg)); +} + +/** + * Return a DOM fragment from `html`. + */ + +function fragment(html) { + var args = arguments + , div = document.createElement('div') + , i = 1; + + div.innerHTML = html.replace(/%([se])/g, function(_, type){ + switch (type) { + case 's': return String(args[i++]); + case 'e': return escape(args[i++]); + } + }); + + return div.firstChild; +} + +/** + * Check for suites that do not have elements + * with `classname`, and hide them. + */ + +function hideSuitesWithout(classname) { + var suites = document.getElementsByClassName('suite'); + for (var i = 0; i < suites.length; i++) { + var els = suites[i].getElementsByClassName(classname); + if (0 == els.length) suites[i].className += ' hidden'; + } +} + +/** + * Unhide .hidden suites. + */ + +function unhide() { + var els = document.getElementsByClassName('suite hidden'); + for (var i = 0; i < els.length; ++i) { + els[i].className = els[i].className.replace('suite hidden', 'suite'); + } +} + +/** + * Set `el` text to `str`. + */ + +function text(el, str) { + if (el.textContent) { + el.textContent = str; + } else { + el.innerText = str; + } +} + +/** + * Listen on `event` with callback `fn`. + */ + +function on(el, event, fn) { + if (el.addEventListener) { + el.addEventListener(event, fn, false); + } else { + el.attachEvent('on' + event, fn); + } +} + +}); // module: reporters/html.js + +require.register("reporters/index.js", function(module, exports, require){ + +exports.Base = require('./base'); +exports.Dot = require('./dot'); +exports.Doc = require('./doc'); +exports.TAP = require('./tap'); +exports.JSON = require('./json'); +exports.HTML = require('./html'); +exports.List = require('./list'); +exports.Min = require('./min'); +exports.Spec = require('./spec'); +exports.Nyan = require('./nyan'); +exports.XUnit = require('./xunit'); +exports.Markdown = require('./markdown'); +exports.Progress = require('./progress'); +exports.Landing = require('./landing'); +exports.JSONCov = require('./json-cov'); +exports.HTMLCov = require('./html-cov'); +exports.JSONStream = require('./json-stream'); + +}); // module: reporters/index.js + +require.register("reporters/json-cov.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base'); + +/** + * Expose `JSONCov`. + */ + +exports = module.exports = JSONCov; + +/** + * Initialize a new `JsCoverage` reporter. + * + * @param {Runner} runner + * @param {Boolean} output + * @api public + */ + +function JSONCov(runner, output) { + var self = this + , output = 1 == arguments.length ? true : output; + + Base.call(this, runner); + + var tests = [] + , failures = [] + , passes = []; + + runner.on('test end', function(test){ + tests.push(test); + }); + + runner.on('pass', function(test){ + passes.push(test); + }); + + runner.on('fail', function(test){ + failures.push(test); + }); + + runner.on('end', function(){ + var cov = global._$jscoverage || {}; + var result = self.cov = map(cov); + result.stats = self.stats; + result.tests = tests.map(clean); + result.failures = failures.map(clean); + result.passes = passes.map(clean); + if (!output) return; + process.stdout.write(JSON.stringify(result, null, 2 )); + }); +} + +/** + * Map jscoverage data to a JSON structure + * suitable for reporting. + * + * @param {Object} cov + * @return {Object} + * @api private + */ + +function map(cov) { + var ret = { + instrumentation: 'node-jscoverage' + , sloc: 0 + , hits: 0 + , misses: 0 + , coverage: 0 + , files: [] + }; + + for (var filename in cov) { + var data = coverage(filename, cov[filename]); + ret.files.push(data); + ret.hits += data.hits; + ret.misses += data.misses; + ret.sloc += data.sloc; + } + + ret.files.sort(function(a, b) { + return a.filename.localeCompare(b.filename); + }); + + if (ret.sloc > 0) { + ret.coverage = (ret.hits / ret.sloc) * 100; + } + + return ret; +}; + +/** + * Map jscoverage data for a single source file + * to a JSON structure suitable for reporting. + * + * @param {String} filename name of the source file + * @param {Object} data jscoverage coverage data + * @return {Object} + * @api private + */ + +function coverage(filename, data) { + var ret = { + filename: filename, + coverage: 0, + hits: 0, + misses: 0, + sloc: 0, + source: {} + }; + + data.source.forEach(function(line, num){ + num++; + + if (data[num] === 0) { + ret.misses++; + ret.sloc++; + } else if (data[num] !== undefined) { + ret.hits++; + ret.sloc++; + } + + ret.source[num] = { + source: line + , coverage: data[num] === undefined + ? '' + : data[num] + }; + }); + + ret.coverage = ret.hits / ret.sloc * 100; + + return ret; +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title + , fullTitle: test.fullTitle() + , duration: test.duration + } +} + +}); // module: reporters/json-cov.js + +require.register("reporters/json-stream.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `List`. + */ + +exports = module.exports = List; + +/** + * Initialize a new `List` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function List(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , total = runner.total; + + runner.on('start', function(){ + console.log(JSON.stringify(['start', { total: total }])); + }); + + runner.on('pass', function(test){ + console.log(JSON.stringify(['pass', clean(test)])); + }); + + runner.on('fail', function(test, err){ + console.log(JSON.stringify(['fail', clean(test)])); + }); + + runner.on('end', function(){ + process.stdout.write(JSON.stringify(['end', self.stats])); + }); +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title + , fullTitle: test.fullTitle() + , duration: test.duration + } +} +}); // module: reporters/json-stream.js + +require.register("reporters/json.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `JSON`. + */ + +exports = module.exports = JSONReporter; + +/** + * Initialize a new `JSON` reporter. + * + * @param {Runner} runner + * @api public + */ + +function JSONReporter(runner) { + var self = this; + Base.call(this, runner); + + var tests = [] + , failures = [] + , passes = []; + + runner.on('test end', function(test){ + tests.push(test); + }); + + runner.on('pass', function(test){ + passes.push(test); + }); + + runner.on('fail', function(test, err){ + failures.push(test); + if (err === Object(err)) { + test.errMsg = err.message; + test.errStack = err.stack; + } + }); + + runner.on('end', function(){ + var obj = { + stats: self.stats, + tests: tests.map(clean), + failures: failures.map(clean), + passes: passes.map(clean) + }; + runner.testResults = obj; + + process.stdout.write(JSON.stringify(obj, null, 2)); + }); +} + +/** + * Return a plain-object representation of `test` + * free of cyclic properties etc. + * + * @param {Object} test + * @return {Object} + * @api private + */ + +function clean(test) { + return { + title: test.title, + fullTitle: test.fullTitle(), + duration: test.duration, + err: test.err, + errStack: test.err.stack, + errMessage: test.err.message + } +} + +}); // module: reporters/json.js + +require.register("reporters/landing.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Landing`. + */ + +exports = module.exports = Landing; + +/** + * Airplane color. + */ + +Base.colors.plane = 0; + +/** + * Airplane crash color. + */ + +Base.colors['plane crash'] = 31; + +/** + * Runway color. + */ + +Base.colors.runway = 90; + +/** + * Initialize a new `Landing` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Landing(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , total = runner.total + , stream = process.stdout + , plane = color('plane', '✈') + , crashed = -1 + , n = 0; + + function runway() { + var buf = Array(width).join('-'); + return ' ' + color('runway', buf); + } + + runner.on('start', function(){ + stream.write('\n '); + cursor.hide(); + }); + + runner.on('test end', function(test){ + // check if the plane crashed + var col = -1 == crashed + ? width * ++n / total | 0 + : crashed; + + // show the crash + if ('failed' == test.state) { + plane = color('plane crash', '✈'); + crashed = col; + } + + // render landing strip + stream.write('\u001b[4F\n\n'); + stream.write(runway()); + stream.write('\n '); + stream.write(color('runway', Array(col).join('⋅'))); + stream.write(plane) + stream.write(color('runway', Array(width - col).join('⋅') + '\n')); + stream.write(runway()); + stream.write('\u001b[0m'); + }); + + runner.on('end', function(){ + cursor.show(); + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Landing.prototype = new F; +Landing.prototype.constructor = Landing; + +}); // module: reporters/landing.js + +require.register("reporters/list.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `List`. + */ + +exports = module.exports = List; + +/** + * Initialize a new `List` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function List(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , n = 0; + + runner.on('start', function(){ + console.log(); + }); + + runner.on('test', function(test){ + process.stdout.write(color('pass', ' ' + test.fullTitle() + ': ')); + }); + + runner.on('pending', function(test){ + var fmt = color('checkmark', ' -') + + color('pending', ' %s'); + console.log(fmt, test.fullTitle()); + }); + + runner.on('pass', function(test){ + var fmt = color('checkmark', ' '+Base.symbols.dot) + + color('pass', ' %s: ') + + color(test.speed, '%dms'); + cursor.CR(); + console.log(fmt, test.fullTitle(), test.duration); + }); + + runner.on('fail', function(test, err){ + cursor.CR(); + console.log(color('fail', ' %d) %s'), ++n, test.fullTitle()); + }); + + runner.on('end', self.epilogue.bind(self)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +List.prototype = new F; +List.prototype.constructor = List; + + +}); // module: reporters/list.js + +require.register("reporters/markdown.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils'); + +/** + * Expose `Markdown`. + */ + +exports = module.exports = Markdown; + +/** + * Initialize a new `Markdown` reporter. + * + * @param {Runner} runner + * @api public + */ + +function Markdown(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , level = 0 + , buf = ''; + + function title(str) { + return Array(level).join('#') + ' ' + str; + } + + function indent() { + return Array(level).join(' '); + } + + function mapTOC(suite, obj) { + var ret = obj; + obj = obj[suite.title] = obj[suite.title] || { suite: suite }; + suite.suites.forEach(function(suite){ + mapTOC(suite, obj); + }); + return ret; + } + + function stringifyTOC(obj, level) { + ++level; + var buf = ''; + var link; + for (var key in obj) { + if ('suite' == key) continue; + if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\n'; + if (key) buf += Array(level).join(' ') + link; + buf += stringifyTOC(obj[key], level); + } + --level; + return buf; + } + + function generateTOC(suite) { + var obj = mapTOC(suite, {}); + return stringifyTOC(obj, 0); + } + + generateTOC(runner.suite); + + runner.on('suite', function(suite){ + ++level; + var slug = utils.slug(suite.fullTitle()); + buf += '' + '\n'; + buf += title(suite.title) + '\n'; + }); + + runner.on('suite end', function(suite){ + --level; + }); + + runner.on('pass', function(test){ + var code = utils.clean(test.fn.toString()); + buf += test.title + '.\n'; + buf += '\n```js\n'; + buf += code + '\n'; + buf += '```\n\n'; + }); + + runner.on('end', function(){ + process.stdout.write('# TOC\n'); + process.stdout.write(generateTOC(runner.suite)); + process.stdout.write(buf); + }); +} +}); // module: reporters/markdown.js + +require.register("reporters/min.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base'); + +/** + * Expose `Min`. + */ + +exports = module.exports = Min; + +/** + * Initialize a new `Min` minimal test reporter (best used with --watch). + * + * @param {Runner} runner + * @api public + */ + +function Min(runner) { + Base.call(this, runner); + + runner.on('start', function(){ + // clear screen + process.stdout.write('\u001b[2J'); + // set cursor position + process.stdout.write('\u001b[1;3H'); + }); + + runner.on('end', this.epilogue.bind(this)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Min.prototype = new F; +Min.prototype.constructor = Min; + + +}); // module: reporters/min.js + +require.register("reporters/nyan.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var Base = require('./base') + , color = Base.color; + +/** + * Expose `Dot`. + */ + +exports = module.exports = NyanCat; + +/** + * Initialize a new `Dot` matrix test reporter. + * + * @param {Runner} runner + * @api public + */ + +function NyanCat(runner) { + Base.call(this, runner); + var self = this + , stats = this.stats + , width = Base.window.width * .75 | 0 + , rainbowColors = this.rainbowColors = self.generateColors() + , colorIndex = this.colorIndex = 0 + , numerOfLines = this.numberOfLines = 4 + , trajectories = this.trajectories = [[], [], [], []] + , nyanCatWidth = this.nyanCatWidth = 11 + , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth) + , scoreboardWidth = this.scoreboardWidth = 5 + , tick = this.tick = 0 + , n = 0; + + runner.on('start', function(){ + Base.cursor.hide(); + self.draw(); + }); + + runner.on('pending', function(test){ + self.draw(); + }); + + runner.on('pass', function(test){ + self.draw(); + }); + + runner.on('fail', function(test, err){ + self.draw(); + }); + + runner.on('end', function(){ + Base.cursor.show(); + for (var i = 0; i < self.numberOfLines; i++) write('\n'); + self.epilogue(); + }); +} + +/** + * Draw the nyan cat + * + * @api private + */ + +NyanCat.prototype.draw = function(){ + this.appendRainbow(); + this.drawScoreboard(); + this.drawRainbow(); + this.drawNyanCat(); + this.tick = !this.tick; +}; + +/** + * Draw the "scoreboard" showing the number + * of passes, failures and pending tests. + * + * @api private + */ + +NyanCat.prototype.drawScoreboard = function(){ + var stats = this.stats; + var colors = Base.colors; + + function draw(color, n) { + write(' '); + write('\u001b[' + color + 'm' + n + '\u001b[0m'); + write('\n'); + } + + draw(colors.green, stats.passes); + draw(colors.fail, stats.failures); + draw(colors.pending, stats.pending); + write('\n'); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Append the rainbow. + * + * @api private + */ + +NyanCat.prototype.appendRainbow = function(){ + var segment = this.tick ? '_' : '-'; + var rainbowified = this.rainbowify(segment); + + for (var index = 0; index < this.numberOfLines; index++) { + var trajectory = this.trajectories[index]; + if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift(); + trajectory.push(rainbowified); + } +}; + +/** + * Draw the rainbow. + * + * @api private + */ + +NyanCat.prototype.drawRainbow = function(){ + var self = this; + + this.trajectories.forEach(function(line, index) { + write('\u001b[' + self.scoreboardWidth + 'C'); + write(line.join('')); + write('\n'); + }); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Draw the nyan cat + * + * @api private + */ + +NyanCat.prototype.drawNyanCat = function() { + var self = this; + var startWidth = this.scoreboardWidth + this.trajectories[0].length; + var color = '\u001b[' + startWidth + 'C'; + var padding = ''; + + write(color); + write('_,------,'); + write('\n'); + + write(color); + padding = self.tick ? ' ' : ' '; + write('_|' + padding + '/\\_/\\ '); + write('\n'); + + write(color); + padding = self.tick ? '_' : '__'; + var tail = self.tick ? '~' : '^'; + var face; + write(tail + '|' + padding + this.face() + ' '); + write('\n'); + + write(color); + padding = self.tick ? ' ' : ' '; + write(padding + '"" "" '); + write('\n'); + + this.cursorUp(this.numberOfLines); +}; + +/** + * Draw nyan cat face. + * + * @return {String} + * @api private + */ + +NyanCat.prototype.face = function() { + var stats = this.stats; + if (stats.failures) { + return '( x .x)'; + } else if (stats.pending) { + return '( o .o)'; + } else if(stats.passes) { + return '( ^ .^)'; + } else { + return '( - .-)'; + } +} + +/** + * Move cursor up `n`. + * + * @param {Number} n + * @api private + */ + +NyanCat.prototype.cursorUp = function(n) { + write('\u001b[' + n + 'A'); +}; + +/** + * Move cursor down `n`. + * + * @param {Number} n + * @api private + */ + +NyanCat.prototype.cursorDown = function(n) { + write('\u001b[' + n + 'B'); +}; + +/** + * Generate rainbow colors. + * + * @return {Array} + * @api private + */ + +NyanCat.prototype.generateColors = function(){ + var colors = []; + + for (var i = 0; i < (6 * 7); i++) { + var pi3 = Math.floor(Math.PI / 3); + var n = (i * (1.0 / 6)); + var r = Math.floor(3 * Math.sin(n) + 3); + var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3); + var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3); + colors.push(36 * r + 6 * g + b + 16); + } + + return colors; +}; + +/** + * Apply rainbow to the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +NyanCat.prototype.rainbowify = function(str){ + var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length]; + this.colorIndex += 1; + return '\u001b[38;5;' + color + 'm' + str + '\u001b[0m'; +}; + +/** + * Stdout helper. + */ + +function write(string) { + process.stdout.write(string); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +NyanCat.prototype = new F; +NyanCat.prototype.constructor = NyanCat; + + +}); // module: reporters/nyan.js + +require.register("reporters/progress.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Progress`. + */ + +exports = module.exports = Progress; + +/** + * General progress bar color. + */ + +Base.colors.progress = 90; + +/** + * Initialize a new `Progress` bar test reporter. + * + * @param {Runner} runner + * @param {Object} options + * @api public + */ + +function Progress(runner, options) { + Base.call(this, runner); + + var self = this + , options = options || {} + , stats = this.stats + , width = Base.window.width * .50 | 0 + , total = runner.total + , complete = 0 + , max = Math.max + , lastN = -1; + + // default chars + options.open = options.open || '['; + options.complete = options.complete || '▬'; + options.incomplete = options.incomplete || Base.symbols.dot; + options.close = options.close || ']'; + options.verbose = false; + + // tests started + runner.on('start', function(){ + console.log(); + cursor.hide(); + }); + + // tests complete + runner.on('test end', function(){ + complete++; + var incomplete = total - complete + , percent = complete / total + , n = width * percent | 0 + , i = width - n; + + if (lastN === n && !options.verbose) { + // Don't re-render the line if it hasn't changed + return; + } + lastN = n; + + cursor.CR(); + process.stdout.write('\u001b[J'); + process.stdout.write(color('progress', ' ' + options.open)); + process.stdout.write(Array(n).join(options.complete)); + process.stdout.write(Array(i).join(options.incomplete)); + process.stdout.write(color('progress', options.close)); + if (options.verbose) { + process.stdout.write(color('progress', ' ' + complete + ' of ' + total)); + } + }); + + // tests are complete, output some stats + // and the failures if any + runner.on('end', function(){ + cursor.show(); + console.log(); + self.epilogue(); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Progress.prototype = new F; +Progress.prototype.constructor = Progress; + + +}); // module: reporters/progress.js + +require.register("reporters/spec.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `Spec`. + */ + +exports = module.exports = Spec; + +/** + * Initialize a new `Spec` test reporter. + * + * @param {Runner} runner + * @api public + */ + +function Spec(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , indents = 0 + , n = 0; + + function indent() { + return Array(indents).join(' ') + } + + runner.on('start', function(){ + console.log(); + }); + + runner.on('suite', function(suite){ + ++indents; + console.log(color('suite', '%s%s'), indent(), suite.title); + }); + + runner.on('suite end', function(suite){ + --indents; + if (1 == indents) console.log(); + }); + + runner.on('pending', function(test){ + var fmt = indent() + color('pending', ' - %s'); + console.log(fmt, test.title); + }); + + runner.on('pass', function(test){ + if ('fast' == test.speed) { + var fmt = indent() + + color('checkmark', ' ' + Base.symbols.ok) + + color('pass', ' %s '); + cursor.CR(); + console.log(fmt, test.title); + } else { + var fmt = indent() + + color('checkmark', ' ' + Base.symbols.ok) + + color('pass', ' %s ') + + color(test.speed, '(%dms)'); + cursor.CR(); + console.log(fmt, test.title, test.duration); + } + }); + + runner.on('fail', function(test, err){ + cursor.CR(); + console.log(indent() + color('fail', ' %d) %s'), ++n, test.title); + }); + + runner.on('end', self.epilogue.bind(self)); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +Spec.prototype = new F; +Spec.prototype.constructor = Spec; + + +}); // module: reporters/spec.js + +require.register("reporters/tap.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , cursor = Base.cursor + , color = Base.color; + +/** + * Expose `TAP`. + */ + +exports = module.exports = TAP; + +/** + * Initialize a new `TAP` reporter. + * + * @param {Runner} runner + * @api public + */ + +function TAP(runner) { + Base.call(this, runner); + + var self = this + , stats = this.stats + , n = 1 + , passes = 0 + , failures = 0; + + runner.on('start', function(){ + var total = runner.grepTotal(runner.suite); + console.log('%d..%d', 1, total); + }); + + runner.on('test end', function(){ + ++n; + }); + + runner.on('pending', function(test){ + console.log('ok %d %s # SKIP -', n, title(test)); + }); + + runner.on('pass', function(test){ + passes++; + console.log('ok %d %s', n, title(test)); + }); + + runner.on('fail', function(test, err){ + failures++; + console.log('not ok %d %s', n, title(test)); + if (err.stack) console.log(err.stack.replace(/^/gm, ' ')); + }); + + runner.on('end', function(){ + console.log('# tests ' + (passes + failures)); + console.log('# pass ' + passes); + console.log('# fail ' + failures); + }); +} + +/** + * Return a TAP-safe title of `test` + * + * @param {Object} test + * @return {String} + * @api private + */ + +function title(test) { + return test.fullTitle().replace(/#/g, ''); +} + +}); // module: reporters/tap.js + +require.register("reporters/xunit.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Base = require('./base') + , utils = require('../utils') + , escape = utils.escape; + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Expose `XUnit`. + */ + +exports = module.exports = XUnit; + +/** + * Initialize a new `XUnit` reporter. + * + * @param {Runner} runner + * @api public + */ + +function XUnit(runner) { + Base.call(this, runner); + var stats = this.stats + , tests = [] + , self = this; + + runner.on('pending', function(test){ + tests.push(test); + }); + + runner.on('pass', function(test){ + tests.push(test); + }); + + runner.on('fail', function(test){ + tests.push(test); + }); + + runner.on('end', function(){ + console.log(tag('testsuite', { + name: 'Mocha Tests' + , tests: stats.tests + , failures: stats.failures + , errors: stats.failures + , skipped: stats.tests - stats.failures - stats.passes + , timestamp: (new Date).toUTCString() + , time: (stats.duration / 1000) || 0 + }, false)); + + tests.forEach(test); + console.log(''); + }); +} + +/** + * Inherit from `Base.prototype`. + */ + +function F(){}; +F.prototype = Base.prototype; +XUnit.prototype = new F; +XUnit.prototype.constructor = XUnit; + + +/** + * Output tag for the given `test.` + */ + +function test(test) { + var attrs = { + classname: test.parent.fullTitle() + , name: test.title + , time: (test.duration / 1000) || 0 + }; + + if ('failed' == test.state) { + var err = test.err; + console.log(tag('testcase', attrs, false, tag('failure', {}, false, cdata(escape(err.message) + "\n" + err.stack)))); + } else if (test.pending) { + console.log(tag('testcase', attrs, false, tag('skipped', {}, true))); + } else { + console.log(tag('testcase', attrs, true) ); + } +} + +/** + * HTML tag helper. + */ + +function tag(name, attrs, close, content) { + var end = close ? '/>' : '>' + , pairs = [] + , tag; + + for (var key in attrs) { + pairs.push(key + '="' + escape(attrs[key]) + '"'); + } + + tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end; + if (content) tag += content + ''; +} + +}); // module: reporters/xunit.js + +require.register("runnable.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:runnable') + , milliseconds = require('./ms'); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date + , setTimeout = global.setTimeout + , setInterval = global.setInterval + , clearTimeout = global.clearTimeout + , clearInterval = global.clearInterval; + +/** + * Object#toString(). + */ + +var toString = Object.prototype.toString; + +/** + * Expose `Runnable`. + */ + +module.exports = Runnable; + +/** + * Initialize a new `Runnable` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Runnable(title, fn) { + this.title = title; + this.fn = fn; + this.async = fn && fn.length; + this.sync = ! this.async; + this._timeout = 2000; + this._slow = 75; + this._enableTimeouts = true; + this.timedOut = false; +} + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Runnable.prototype = new F; +Runnable.prototype.constructor = Runnable; + + +/** + * Set & get timeout `ms`. + * + * @param {Number|String} ms + * @return {Runnable|Number} ms or self + * @api private + */ + +Runnable.prototype.timeout = function(ms){ + if (0 == arguments.length) return this._timeout; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._timeout = ms; + if (this.timer) this.resetTimeout(); + return this; +}; + +/** + * Set & get slow `ms`. + * + * @param {Number|String} ms + * @return {Runnable|Number} ms or self + * @api private + */ + +Runnable.prototype.slow = function(ms){ + if (0 === arguments.length) return this._slow; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._slow = ms; + return this; +}; + +/** + * Set and & get timeout `enabled`. + * + * @param {Boolean} enabled + * @return {Runnable|Boolean} enabled or self + * @api private + */ + +Runnable.prototype.enableTimeouts = function(enabled){ + if (arguments.length === 0) return this._enableTimeouts; + debug('enableTimeouts %s', enabled); + this._enableTimeouts = enabled; + return this; +}; + +/** + * Return the full title generated by recursively + * concatenating the parent's full title. + * + * @return {String} + * @api public + */ + +Runnable.prototype.fullTitle = function(){ + return this.parent.fullTitle() + ' ' + this.title; +}; + +/** + * Clear the timeout. + * + * @api private + */ + +Runnable.prototype.clearTimeout = function(){ + clearTimeout(this.timer); +}; + +/** + * Inspect the runnable void of private properties. + * + * @return {String} + * @api private + */ + +Runnable.prototype.inspect = function(){ + return JSON.stringify(this, function(key, val){ + if ('_' == key[0]) return; + if ('parent' == key) return '#'; + if ('ctx' == key) return '#'; + return val; + }, 2); +}; + +/** + * Reset the timeout. + * + * @api private + */ + +Runnable.prototype.resetTimeout = function(){ + var self = this; + var ms = this.timeout() || 1e9; + + if (!this._enableTimeouts) return; + this.clearTimeout(); + this.timer = setTimeout(function(){ + self.callback(new Error('timeout of ' + ms + 'ms exceeded')); + self.timedOut = true; + }, ms); +}; + +/** + * Whitelist these globals for this test run + * + * @api private + */ +Runnable.prototype.globals = function(arr){ + var self = this; + this._allowedGlobals = arr; +}; + +/** + * Run the test and invoke `fn(err)`. + * + * @param {Function} fn + * @api private + */ + +Runnable.prototype.run = function(fn){ + var self = this + , start = new Date + , ctx = this.ctx + , finished + , emitted; + + // Some times the ctx exists but it is not runnable + if (ctx && ctx.runnable) ctx.runnable(this); + + // called multiple times + function multiple(err) { + if (emitted) return; + emitted = true; + self.emit('error', err || new Error('done() called multiple times')); + } + + // finished + function done(err) { + var ms = self.timeout(); + if (self.timedOut) return; + if (finished) return multiple(err); + self.clearTimeout(); + self.duration = new Date - start; + finished = true; + if (!err && self.duration > ms && self._enableTimeouts) err = new Error('timeout of ' + ms + 'ms exceeded'); + fn(err); + } + + // for .resetTimeout() + this.callback = done; + + // explicit async with `done` argument + if (this.async) { + this.resetTimeout(); + + try { + this.fn.call(ctx, function(err){ + if (err instanceof Error || toString.call(err) === "[object Error]") return done(err); + if (null != err) { + if (Object.prototype.toString.call(err) === '[object Object]') { + return done(new Error('done() invoked with non-Error: ' + JSON.stringify(err))); + } else { + return done(new Error('done() invoked with non-Error: ' + err)); + } + } + done(); + }); + } catch (err) { + done(err); + } + return; + } + + if (this.asyncOnly) { + return done(new Error('--async-only option in use without declaring `done()`')); + } + + // sync or promise-returning + try { + if (this.pending) { + done(); + } else { + callFn(this.fn); + } + } catch (err) { + done(err); + } + + function callFn(fn) { + var result = fn.call(ctx); + if (result && typeof result.then === 'function') { + self.resetTimeout(); + result + .then(function() { + done() + }, + function(reason) { + done(reason || new Error('Promise rejected with no or falsy reason')) + }); + } else { + done(); + } + } +}; + +}); // module: runnable.js + +require.register("runner.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:runner') + , Test = require('./test') + , utils = require('./utils') + , filter = utils.filter + , keys = utils.keys; + +/** + * Non-enumerable globals. + */ + +var globals = [ + 'setTimeout', + 'clearTimeout', + 'setInterval', + 'clearInterval', + 'XMLHttpRequest', + 'Date' +]; + +/** + * Expose `Runner`. + */ + +module.exports = Runner; + +/** + * Initialize a `Runner` for the given `suite`. + * + * Events: + * + * - `start` execution started + * - `end` execution complete + * - `suite` (suite) test suite execution started + * - `suite end` (suite) all tests (and sub-suites) have finished + * - `test` (test) test execution started + * - `test end` (test) test completed + * - `hook` (hook) hook execution started + * - `hook end` (hook) hook complete + * - `pass` (test) test passed + * - `fail` (test, err) test failed + * - `pending` (test) test pending + * + * @api public + */ + +function Runner(suite) { + var self = this; + this._globals = []; + this._abort = false; + this.suite = suite; + this.total = suite.total(); + this.failures = 0; + this.on('test end', function(test){ self.checkGlobals(test); }); + this.on('hook end', function(hook){ self.checkGlobals(hook); }); + this.grep(/.*/); + this.globals(this.globalProps().concat(extraGlobals())); +} + +/** + * Wrapper for setImmediate, process.nextTick, or browser polyfill. + * + * @param {Function} fn + * @api private + */ + +Runner.immediately = global.setImmediate || process.nextTick; + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Runner.prototype = new F; +Runner.prototype.constructor = Runner; + + +/** + * Run tests with full titles matching `re`. Updates runner.total + * with number of tests matched. + * + * @param {RegExp} re + * @param {Boolean} invert + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.grep = function(re, invert){ + debug('grep %s', re); + this._grep = re; + this._invert = invert; + this.total = this.grepTotal(this.suite); + return this; +}; + +/** + * Returns the number of tests matching the grep search for the + * given suite. + * + * @param {Suite} suite + * @return {Number} + * @api public + */ + +Runner.prototype.grepTotal = function(suite) { + var self = this; + var total = 0; + + suite.eachTest(function(test){ + var match = self._grep.test(test.fullTitle()); + if (self._invert) match = !match; + if (match) total++; + }); + + return total; +}; + +/** + * Return a list of global properties. + * + * @return {Array} + * @api private + */ + +Runner.prototype.globalProps = function() { + var props = utils.keys(global); + + // non-enumerables + for (var i = 0; i < globals.length; ++i) { + if (~utils.indexOf(props, globals[i])) continue; + props.push(globals[i]); + } + + return props; +}; + +/** + * Allow the given `arr` of globals. + * + * @param {Array} arr + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.globals = function(arr){ + if (0 == arguments.length) return this._globals; + debug('globals %j', arr); + this._globals = this._globals.concat(arr); + return this; +}; + +/** + * Check for global variable leaks. + * + * @api private + */ + +Runner.prototype.checkGlobals = function(test){ + if (this.ignoreLeaks) return; + var ok = this._globals; + + var globals = this.globalProps(); + var leaks; + + if (test) { + ok = ok.concat(test._allowedGlobals || []); + } + + if(this.prevGlobalsLength == globals.length) return; + this.prevGlobalsLength = globals.length; + + leaks = filterLeaks(ok, globals); + this._globals = this._globals.concat(leaks); + + if (leaks.length > 1) { + this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + '')); + } else if (leaks.length) { + this.fail(test, new Error('global leak detected: ' + leaks[0])); + } +}; + +/** + * Fail the given `test`. + * + * @param {Test} test + * @param {Error} err + * @api private + */ + +Runner.prototype.fail = function(test, err){ + ++this.failures; + test.state = 'failed'; + + if ('string' == typeof err) { + err = new Error('the string "' + err + '" was thrown, throw an Error :)'); + } + + this.emit('fail', test, err); +}; + +/** + * Fail the given `hook` with `err`. + * + * Hook failures work in the following pattern: + * - If bail, then exit + * - Failed `before` hook skips all tests in a suite and subsuites, + * but jumps to corresponding `after` hook + * - Failed `before each` hook skips remaining tests in a + * suite and jumps to corresponding `after each` hook, + * which is run only once + * - Failed `after` hook does not alter + * execution order + * - Failed `after each` hook skips remaining tests in a + * suite and subsuites, but executes other `after each` + * hooks + * + * @param {Hook} hook + * @param {Error} err + * @api private + */ + +Runner.prototype.failHook = function(hook, err){ + this.fail(hook, err); + if (this.suite.bail()) { + this.emit('end'); + } +}; + +/** + * Run hook `name` callbacks and then invoke `fn()`. + * + * @param {String} name + * @param {Function} function + * @api private + */ + +Runner.prototype.hook = function(name, fn){ + var suite = this.suite + , hooks = suite['_' + name] + , self = this + , timer; + + function next(i) { + var hook = hooks[i]; + if (!hook) return fn(); + if (self.failures && suite.bail()) return fn(); + self.currentRunnable = hook; + + hook.ctx.currentTest = self.test; + + self.emit('hook', hook); + + hook.on('error', function(err){ + self.failHook(hook, err); + }); + + hook.run(function(err){ + hook.removeAllListeners('error'); + var testError = hook.error(); + if (testError) self.fail(self.test, testError); + if (err) { + self.failHook(hook, err); + + // stop executing hooks, notify callee of hook err + return fn(err); + } + self.emit('hook end', hook); + delete hook.ctx.currentTest; + next(++i); + }); + } + + Runner.immediately(function(){ + next(0); + }); +}; + +/** + * Run hook `name` for the given array of `suites` + * in order, and callback `fn(err, errSuite)`. + * + * @param {String} name + * @param {Array} suites + * @param {Function} fn + * @api private + */ + +Runner.prototype.hooks = function(name, suites, fn){ + var self = this + , orig = this.suite; + + function next(suite) { + self.suite = suite; + + if (!suite) { + self.suite = orig; + return fn(); + } + + self.hook(name, function(err){ + if (err) { + var errSuite = self.suite; + self.suite = orig; + return fn(err, errSuite); + } + + next(suites.pop()); + }); + } + + next(suites.pop()); +}; + +/** + * Run hooks from the top level down. + * + * @param {String} name + * @param {Function} fn + * @api private + */ + +Runner.prototype.hookUp = function(name, fn){ + var suites = [this.suite].concat(this.parents()).reverse(); + this.hooks(name, suites, fn); +}; + +/** + * Run hooks from the bottom up. + * + * @param {String} name + * @param {Function} fn + * @api private + */ + +Runner.prototype.hookDown = function(name, fn){ + var suites = [this.suite].concat(this.parents()); + this.hooks(name, suites, fn); +}; + +/** + * Return an array of parent Suites from + * closest to furthest. + * + * @return {Array} + * @api private + */ + +Runner.prototype.parents = function(){ + var suite = this.suite + , suites = []; + while (suite = suite.parent) suites.push(suite); + return suites; +}; + +/** + * Run the current test and callback `fn(err)`. + * + * @param {Function} fn + * @api private + */ + +Runner.prototype.runTest = function(fn){ + var test = this.test + , self = this; + + if (this.asyncOnly) test.asyncOnly = true; + + try { + test.on('error', function(err){ + self.fail(test, err); + }); + test.run(fn); + } catch (err) { + fn(err); + } +}; + +/** + * Run tests in the given `suite` and invoke + * the callback `fn()` when complete. + * + * @param {Suite} suite + * @param {Function} fn + * @api private + */ + +Runner.prototype.runTests = function(suite, fn){ + var self = this + , tests = suite.tests.slice() + , test; + + + function hookErr(err, errSuite, after) { + // before/after Each hook for errSuite failed: + var orig = self.suite; + + // for failed 'after each' hook start from errSuite parent, + // otherwise start from errSuite itself + self.suite = after ? errSuite.parent : errSuite; + + if (self.suite) { + // call hookUp afterEach + self.hookUp('afterEach', function(err2, errSuite2) { + self.suite = orig; + // some hooks may fail even now + if (err2) return hookErr(err2, errSuite2, true); + // report error suite + fn(errSuite); + }); + } else { + // there is no need calling other 'after each' hooks + self.suite = orig; + fn(errSuite); + } + } + + function next(err, errSuite) { + // if we bail after first err + if (self.failures && suite._bail) return fn(); + + if (self._abort) return fn(); + + if (err) return hookErr(err, errSuite, true); + + // next test + test = tests.shift(); + + // all done + if (!test) return fn(); + + // grep + var match = self._grep.test(test.fullTitle()); + if (self._invert) match = !match; + if (!match) return next(); + + // pending + if (test.pending) { + self.emit('pending', test); + self.emit('test end', test); + return next(); + } + + // execute test and hook(s) + self.emit('test', self.test = test); + self.hookDown('beforeEach', function(err, errSuite){ + + if (err) return hookErr(err, errSuite, false); + + self.currentRunnable = self.test; + self.runTest(function(err){ + test = self.test; + + if (err) { + self.fail(test, err); + self.emit('test end', test); + return self.hookUp('afterEach', next); + } + + test.state = 'passed'; + self.emit('pass', test); + self.emit('test end', test); + self.hookUp('afterEach', next); + }); + }); + } + + this.next = next; + next(); +}; + +/** + * Run the given `suite` and invoke the + * callback `fn()` when complete. + * + * @param {Suite} suite + * @param {Function} fn + * @api private + */ + +Runner.prototype.runSuite = function(suite, fn){ + var total = this.grepTotal(suite) + , self = this + , i = 0; + + debug('run suite %s', suite.fullTitle()); + + if (!total) return fn(); + + this.emit('suite', this.suite = suite); + + function next(errSuite) { + if (errSuite) { + // current suite failed on a hook from errSuite + if (errSuite == suite) { + // if errSuite is current suite + // continue to the next sibling suite + return done(); + } else { + // errSuite is among the parents of current suite + // stop execution of errSuite and all sub-suites + return done(errSuite); + } + } + + if (self._abort) return done(); + + var curr = suite.suites[i++]; + if (!curr) return done(); + self.runSuite(curr, next); + } + + function done(errSuite) { + self.suite = suite; + self.hook('afterAll', function(){ + self.emit('suite end', suite); + fn(errSuite); + }); + } + + this.hook('beforeAll', function(err){ + if (err) return done(); + self.runTests(suite, next); + }); +}; + +/** + * Handle uncaught exceptions. + * + * @param {Error} err + * @api private + */ + +Runner.prototype.uncaught = function(err){ + if (err) { + debug('uncaught exception %s', err.message); + } else { + debug('uncaught undefined exception'); + err = new Error('Catched undefined error, did you throw without specifying what?'); + } + + var runnable = this.currentRunnable; + if (!runnable || 'failed' == runnable.state) return; + runnable.clearTimeout(); + err.uncaught = true; + this.fail(runnable, err); + + // recover from test + if ('test' == runnable.type) { + this.emit('test end', runnable); + this.hookUp('afterEach', this.next); + return; + } + + // bail on hooks + this.emit('end'); +}; + +/** + * Run the root suite and invoke `fn(failures)` + * on completion. + * + * @param {Function} fn + * @return {Runner} for chaining + * @api public + */ + +Runner.prototype.run = function(fn){ + var self = this + , fn = fn || function(){}; + + function uncaught(err){ + self.uncaught(err); + } + + debug('start'); + + // callback + this.on('end', function(){ + debug('end'); + process.removeListener('uncaughtException', uncaught); + fn(self.failures); + }); + + // run suites + this.emit('start'); + this.runSuite(this.suite, function(){ + debug('finished running'); + self.emit('end'); + }); + + // uncaught exception + process.on('uncaughtException', uncaught); + + return this; +}; + +/** + * Cleanly abort execution + * + * @return {Runner} for chaining + * @api public + */ +Runner.prototype.abort = function(){ + debug('aborting'); + this._abort = true; +} + +/** + * Filter leaks with the given globals flagged as `ok`. + * + * @param {Array} ok + * @param {Array} globals + * @return {Array} + * @api private + */ + +function filterLeaks(ok, globals) { + return filter(globals, function(key){ + // Firefox and Chrome exposes iframes as index inside the window object + if (/^d+/.test(key)) return false; + + // in firefox + // if runner runs in an iframe, this iframe's window.getInterface method not init at first + // it is assigned in some seconds + if (global.navigator && /^getInterface/.test(key)) return false; + + // an iframe could be approached by window[iframeIndex] + // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak + if (global.navigator && /^\d+/.test(key)) return false; + + // Opera and IE expose global variables for HTML element IDs (issue #243) + if (/^mocha-/.test(key)) return false; + + var matched = filter(ok, function(ok){ + if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]); + return key == ok; + }); + return matched.length == 0 && (!global.navigator || 'onerror' !== key); + }); +} + +/** + * Array of globals dependent on the environment. + * + * @return {Array} + * @api private + */ + + function extraGlobals() { + if (typeof(process) === 'object' && + typeof(process.version) === 'string') { + + var nodeVersion = process.version.split('.').reduce(function(a, v) { + return a << 8 | v; + }); + + // 'errno' was renamed to process._errno in v0.9.11. + + if (nodeVersion < 0x00090B) { + return ['errno']; + } + } + + return []; + } + +}); // module: runner.js + +require.register("suite.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var EventEmitter = require('browser/events').EventEmitter + , debug = require('browser/debug')('mocha:suite') + , milliseconds = require('./ms') + , utils = require('./utils') + , Hook = require('./hook'); + +/** + * Expose `Suite`. + */ + +exports = module.exports = Suite; + +/** + * Create a new `Suite` with the given `title` + * and parent `Suite`. When a suite with the + * same title is already present, that suite + * is returned to provide nicer reporter + * and more flexible meta-testing. + * + * @param {Suite} parent + * @param {String} title + * @return {Suite} + * @api public + */ + +exports.create = function(parent, title){ + var suite = new Suite(title, parent.ctx); + suite.parent = parent; + if (parent.pending) suite.pending = true; + title = suite.fullTitle(); + parent.addSuite(suite); + return suite; +}; + +/** + * Initialize a new `Suite` with the given + * `title` and `ctx`. + * + * @param {String} title + * @param {Context} ctx + * @api private + */ + +function Suite(title, parentContext) { + this.title = title; + var context = function() {}; + context.prototype = parentContext; + this.ctx = new context(); + this.suites = []; + this.tests = []; + this.pending = false; + this._beforeEach = []; + this._beforeAll = []; + this._afterEach = []; + this._afterAll = []; + this.root = !title; + this._timeout = 2000; + this._enableTimeouts = true; + this._slow = 75; + this._bail = false; +} + +/** + * Inherit from `EventEmitter.prototype`. + */ + +function F(){}; +F.prototype = EventEmitter.prototype; +Suite.prototype = new F; +Suite.prototype.constructor = Suite; + + +/** + * Return a clone of this `Suite`. + * + * @return {Suite} + * @api private + */ + +Suite.prototype.clone = function(){ + var suite = new Suite(this.title); + debug('clone'); + suite.ctx = this.ctx; + suite.timeout(this.timeout()); + suite.enableTimeouts(this.enableTimeouts()); + suite.slow(this.slow()); + suite.bail(this.bail()); + return suite; +}; + +/** + * Set timeout `ms` or short-hand such as "2s". + * + * @param {Number|String} ms + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.timeout = function(ms){ + if (0 == arguments.length) return this._timeout; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('timeout %d', ms); + this._timeout = parseInt(ms, 10); + return this; +}; + +/** + * Set timeout `enabled`. + * + * @param {Boolean} enabled + * @return {Suite|Boolean} self or enabled + * @api private + */ + +Suite.prototype.enableTimeouts = function(enabled){ + if (arguments.length === 0) return this._enableTimeouts; + debug('enableTimeouts %s', enabled); + this._enableTimeouts = enabled; + return this; +} + +/** + * Set slow `ms` or short-hand such as "2s". + * + * @param {Number|String} ms + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.slow = function(ms){ + if (0 === arguments.length) return this._slow; + if ('string' == typeof ms) ms = milliseconds(ms); + debug('slow %d', ms); + this._slow = ms; + return this; +}; + +/** + * Sets whether to bail after first error. + * + * @parma {Boolean} bail + * @return {Suite|Number} for chaining + * @api private + */ + +Suite.prototype.bail = function(bail){ + if (0 == arguments.length) return this._bail; + debug('bail %s', bail); + this._bail = bail; + return this; +}; + +/** + * Run `fn(test[, done])` before running tests. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.beforeAll = function(title, fn){ + if (this.pending) return this; + if ('function' === typeof title) { + fn = title; + title = fn.name; + } + title = '"before all" hook' + (title ? ': ' + title : ''); + + var hook = new Hook(title, fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.enableTimeouts(this.enableTimeouts()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._beforeAll.push(hook); + this.emit('beforeAll', hook); + return this; +}; + +/** + * Run `fn(test[, done])` after running tests. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.afterAll = function(title, fn){ + if (this.pending) return this; + if ('function' === typeof title) { + fn = title; + title = fn.name; + } + title = '"after all" hook' + (title ? ': ' + title : ''); + + var hook = new Hook(title, fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.enableTimeouts(this.enableTimeouts()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._afterAll.push(hook); + this.emit('afterAll', hook); + return this; +}; + +/** + * Run `fn(test[, done])` before each test case. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.beforeEach = function(title, fn){ + if (this.pending) return this; + if ('function' === typeof title) { + fn = title; + title = fn.name; + } + title = '"before each" hook' + (title ? ': ' + title : ''); + + var hook = new Hook(title, fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.enableTimeouts(this.enableTimeouts()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._beforeEach.push(hook); + this.emit('beforeEach', hook); + return this; +}; + +/** + * Run `fn(test[, done])` after each test case. + * + * @param {Function} fn + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.afterEach = function(title, fn){ + if (this.pending) return this; + if ('function' === typeof title) { + fn = title; + title = fn.name; + } + title = '"after each" hook' + (title ? ': ' + title : ''); + + var hook = new Hook(title, fn); + hook.parent = this; + hook.timeout(this.timeout()); + hook.enableTimeouts(this.enableTimeouts()); + hook.slow(this.slow()); + hook.ctx = this.ctx; + this._afterEach.push(hook); + this.emit('afterEach', hook); + return this; +}; + +/** + * Add a test `suite`. + * + * @param {Suite} suite + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.addSuite = function(suite){ + suite.parent = this; + suite.timeout(this.timeout()); + suite.enableTimeouts(this.enableTimeouts()); + suite.slow(this.slow()); + suite.bail(this.bail()); + this.suites.push(suite); + this.emit('suite', suite); + return this; +}; + +/** + * Add a `test` to this suite. + * + * @param {Test} test + * @return {Suite} for chaining + * @api private + */ + +Suite.prototype.addTest = function(test){ + test.parent = this; + test.timeout(this.timeout()); + test.enableTimeouts(this.enableTimeouts()); + test.slow(this.slow()); + test.ctx = this.ctx; + this.tests.push(test); + this.emit('test', test); + return this; +}; + +/** + * Return the full title generated by recursively + * concatenating the parent's full title. + * + * @return {String} + * @api public + */ + +Suite.prototype.fullTitle = function(){ + if (this.parent) { + var full = this.parent.fullTitle(); + if (full) return full + ' ' + this.title; + } + return this.title; +}; + +/** + * Return the total number of tests. + * + * @return {Number} + * @api public + */ + +Suite.prototype.total = function(){ + return utils.reduce(this.suites, function(sum, suite){ + return sum + suite.total(); + }, 0) + this.tests.length; +}; + +/** + * Iterates through each suite recursively to find + * all tests. Applies a function in the format + * `fn(test)`. + * + * @param {Function} fn + * @return {Suite} + * @api private + */ + +Suite.prototype.eachTest = function(fn){ + utils.forEach(this.tests, fn); + utils.forEach(this.suites, function(suite){ + suite.eachTest(fn); + }); + return this; +}; + +}); // module: suite.js + +require.register("test.js", function(module, exports, require){ + +/** + * Module dependencies. + */ + +var Runnable = require('./runnable'); + +/** + * Expose `Test`. + */ + +module.exports = Test; + +/** + * Initialize a new `Test` with the given `title` and callback `fn`. + * + * @param {String} title + * @param {Function} fn + * @api private + */ + +function Test(title, fn) { + Runnable.call(this, title, fn); + this.pending = !fn; + this.type = 'test'; +} + +/** + * Inherit from `Runnable.prototype`. + */ + +function F(){}; +F.prototype = Runnable.prototype; +Test.prototype = new F; +Test.prototype.constructor = Test; + + +}); // module: test.js + +require.register("utils.js", function(module, exports, require){ +/** + * Module dependencies. + */ + +var fs = require('browser/fs') + , path = require('browser/path') + , join = path.join + , debug = require('browser/debug')('mocha:watch'); + +/** + * Ignored directories. + */ + +var ignore = ['node_modules', '.git']; + +/** + * Escape special characters in the given string of html. + * + * @param {String} html + * @return {String} + * @api private + */ + +exports.escape = function(html){ + return String(html) + .replace(/&/g, '&') + .replace(/"/g, '"') + .replace(//g, '>'); +}; + +/** + * Array#forEach (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @param {Object} scope + * @api private + */ + +exports.forEach = function(arr, fn, scope){ + for (var i = 0, l = arr.length; i < l; i++) + fn.call(scope, arr[i], i); +}; + +/** + * Array#map (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @param {Object} scope + * @api private + */ + +exports.map = function(arr, fn, scope){ + var result = []; + for (var i = 0, l = arr.length; i < l; i++) + result.push(fn.call(scope, arr[i], i)); + return result; +}; + +/** + * Array#indexOf (<=IE8) + * + * @parma {Array} arr + * @param {Object} obj to find index of + * @param {Number} start + * @api private + */ + +exports.indexOf = function(arr, obj, start){ + for (var i = start || 0, l = arr.length; i < l; i++) { + if (arr[i] === obj) + return i; + } + return -1; +}; + +/** + * Array#reduce (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @param {Object} initial value + * @api private + */ + +exports.reduce = function(arr, fn, val){ + var rval = val; + + for (var i = 0, l = arr.length; i < l; i++) { + rval = fn(rval, arr[i], i, arr); + } + + return rval; +}; + +/** + * Array#filter (<=IE8) + * + * @param {Array} array + * @param {Function} fn + * @api private + */ + +exports.filter = function(arr, fn){ + var ret = []; + + for (var i = 0, l = arr.length; i < l; i++) { + var val = arr[i]; + if (fn(val, i, arr)) ret.push(val); + } + + return ret; +}; + +/** + * Object.keys (<=IE8) + * + * @param {Object} obj + * @return {Array} keys + * @api private + */ + +exports.keys = Object.keys || function(obj) { + var keys = [] + , has = Object.prototype.hasOwnProperty // for `window` on <=IE8 + + for (var key in obj) { + if (has.call(obj, key)) { + keys.push(key); + } + } + + return keys; +}; + +/** + * Watch the given `files` for changes + * and invoke `fn(file)` on modification. + * + * @param {Array} files + * @param {Function} fn + * @api private + */ + +exports.watch = function(files, fn){ + var options = { interval: 100 }; + files.forEach(function(file){ + debug('file %s', file); + fs.watchFile(file, options, function(curr, prev){ + if (prev.mtime < curr.mtime) fn(file); + }); + }); +}; + +/** + * Ignored files. + */ + +function ignored(path){ + return !~ignore.indexOf(path); +} + +/** + * Lookup files in the given `dir`. + * + * @return {Array} + * @api private + */ + +exports.files = function(dir, ext, ret){ + ret = ret || []; + ext = ext || ['js']; + + var re = new RegExp('\\.(' + ext.join('|') + ')$'); + + fs.readdirSync(dir) + .filter(ignored) + .forEach(function(path){ + path = join(dir, path); + if (fs.statSync(path).isDirectory()) { + exports.files(path, ext, ret); + } else if (path.match(re)) { + ret.push(path); + } + }); + + return ret; +}; + +/** + * Compute a slug from the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.slug = function(str){ + return str + .toLowerCase() + .replace(/ +/g, '-') + .replace(/[^-\w]/g, ''); +}; + +/** + * Strip the function definition from `str`, + * and re-indent for pre whitespace. + */ + +exports.clean = function(str) { + str = str + .replace(/\r\n?|[\n\u2028\u2029]/g, "\n").replace(/^\uFEFF/, '') + .replace(/^function *\(.*\) *{|\(.*\) *=> *{?/, '') + .replace(/\s+\}$/, ''); + + var spaces = str.match(/^\n?( *)/)[1].length + , tabs = str.match(/^\n?(\t*)/)[1].length + , re = new RegExp('^\n?' + (tabs ? '\t' : ' ') + '{' + (tabs ? tabs : spaces) + '}', 'gm'); + + str = str.replace(re, ''); + + return exports.trim(str); +}; + +/** + * Escape regular expression characters in `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.escapeRegexp = function(str){ + return str.replace(/[-\\^$*+?.()|[\]{}]/g, "\\$&"); +}; + +/** + * Trim the given `str`. + * + * @param {String} str + * @return {String} + * @api private + */ + +exports.trim = function(str){ + return str.replace(/^\s+|\s+$/g, ''); +}; + +/** + * Parse the given `qs`. + * + * @param {String} qs + * @return {Object} + * @api private + */ + +exports.parseQuery = function(qs){ + return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){ + var i = pair.indexOf('=') + , key = pair.slice(0, i) + , val = pair.slice(++i); + + obj[key] = decodeURIComponent(val); + return obj; + }, {}); +}; + +/** + * Highlight the given string of `js`. + * + * @param {String} js + * @return {String} + * @api private + */ + +function highlight(js) { + return js + .replace(//g, '>') + .replace(/\/\/(.*)/gm, '//$1') + .replace(/('.*?')/gm, '$1') + .replace(/(\d+\.\d+)/gm, '$1') + .replace(/(\d+)/gm, '$1') + .replace(/\bnew[ \t]+(\w+)/gm, 'new $1') + .replace(/\b(function|new|throw|return|var|if|else)\b/gm, '$1') +} + +/** + * Highlight the contents of tag `name`. + * + * @param {String} name + * @api private + */ + +exports.highlightTags = function(name) { + var code = document.getElementsByTagName(name); + for (var i = 0, len = code.length; i < len; ++i) { + code[i].innerHTML = highlight(code[i].innerHTML); + } +}; + + +/** + * Stringify `obj`. + * + * @param {Object} obj + * @return {String} + * @api private + */ + +exports.stringify = function(obj) { + if (obj instanceof RegExp) return obj.toString(); + return JSON.stringify(exports.canonicalize(obj), null, 2).replace(/,(\n|$)/g, '$1'); +} + +/** + * Return a new object that has the keys in sorted order. + * @param {Object} obj + * @return {Object} + * @api private + */ + +exports.canonicalize = function(obj, stack) { + stack = stack || []; + + if (exports.indexOf(stack, obj) !== -1) return '[Circular]'; + + var canonicalizedObj; + + if ({}.toString.call(obj) === '[object Array]') { + stack.push(obj); + canonicalizedObj = exports.map(obj, function(item) { + return exports.canonicalize(item, stack); + }); + stack.pop(); + } else if (typeof obj === 'object' && obj !== null) { + stack.push(obj); + canonicalizedObj = {}; + exports.forEach(exports.keys(obj).sort(), function(key) { + canonicalizedObj[key] = exports.canonicalize(obj[key], stack); + }); + stack.pop(); + } else { + canonicalizedObj = obj; + } + + return canonicalizedObj; + } + +}); // module: utils.js +// The global object is "self" in Web Workers. +var global = (function() { return this; })(); + +/** + * Save timer references to avoid Sinon interfering (see GH-237). + */ + +var Date = global.Date; +var setTimeout = global.setTimeout; +var setInterval = global.setInterval; +var clearTimeout = global.clearTimeout; +var clearInterval = global.clearInterval; + +/** + * Node shims. + * + * These are meant only to allow + * mocha.js to run untouched, not + * to allow running node code in + * the browser. + */ + +var process = {}; +process.exit = function(status){}; +process.stdout = {}; + +var uncaughtExceptionHandlers = []; + +var originalOnerrorHandler = global.onerror; + +/** + * Remove uncaughtException listener. + * Revert to original onerror handler if previously defined. + */ + +process.removeListener = function(e, fn){ + if ('uncaughtException' == e) { + if (originalOnerrorHandler) { + global.onerror = originalOnerrorHandler; + } else { + global.onerror = function() {}; + } + var i = Mocha.utils.indexOf(uncaughtExceptionHandlers, fn); + if (i != -1) { uncaughtExceptionHandlers.splice(i, 1); } + } +}; + +/** + * Implements uncaughtException listener. + */ + +process.on = function(e, fn){ + if ('uncaughtException' == e) { + global.onerror = function(err, url, line){ + fn(new Error(err + ' (' + url + ':' + line + ')')); + return true; + }; + uncaughtExceptionHandlers.push(fn); + } +}; + +/** + * Expose mocha. + */ + +var Mocha = global.Mocha = require('mocha'), + mocha = global.mocha = new Mocha({ reporter: 'html' }); + +// The BDD UI is registered by default, but no UI will be functional in the +// browser without an explicit call to the overridden `mocha.ui` (see below). +// Ensure that this default UI does not expose its methods to the global scope. +mocha.suite.removeAllListeners('pre-require'); + +var immediateQueue = [] + , immediateTimeout; + +function timeslice() { + var immediateStart = new Date().getTime(); + while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) { + immediateQueue.shift()(); + } + if (immediateQueue.length) { + immediateTimeout = setTimeout(timeslice, 0); + } else { + immediateTimeout = null; + } +} + +/** + * High-performance override of Runner.immediately. + */ + +Mocha.Runner.immediately = function(callback) { + immediateQueue.push(callback); + if (!immediateTimeout) { + immediateTimeout = setTimeout(timeslice, 0); + } +}; + +/** + * Function to allow assertion libraries to throw errors directly into mocha. + * This is useful when running tests in a browser because window.onerror will + * only receive the 'message' attribute of the Error. + */ +mocha.throwError = function(err) { + Mocha.utils.forEach(uncaughtExceptionHandlers, function (fn) { + fn(err); + }); + throw err; +}; + +/** + * Override ui to ensure that the ui functions are initialized. + * Normally this would happen in Mocha.prototype.loadFiles. + */ + +mocha.ui = function(ui){ + Mocha.prototype.ui.call(this, ui); + this.suite.emit('pre-require', global, null, this); + return this; +}; + +/** + * Setup mocha with the given setting options. + */ + +mocha.setup = function(opts){ + if ('string' == typeof opts) opts = { ui: opts }; + for (var opt in opts) this[opt](opts[opt]); + return this; +}; + +/** + * Run mocha, returning the Runner. + */ + +mocha.run = function(fn){ + var options = mocha.options; + mocha.globals('location'); + + var query = Mocha.utils.parseQuery(global.location.search || ''); + if (query.grep) mocha.grep(query.grep); + if (query.invert) mocha.invert(); + + return Mocha.prototype.run.call(mocha, function(err){ + // The DOM Document is not available in Web Workers. + if (global.document) { + Mocha.utils.highlightTags('code'); + } + if (fn) fn(err); + }); +}; + +/** + * Expose the process shim. + */ + +Mocha.process = process; +})(); +(function() { +var style = document.createElement('style'); +style.textContent = '@charset "utf-8";\n\nbody {\n margin:0;\n}\n\n#mocha {\n font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;\n margin: 60px 50px;\n}\n\n#mocha ul,\n#mocha li {\n margin: 0;\n padding: 0;\n}\n\n#mocha ul {\n list-style: none;\n}\n\n#mocha h1,\n#mocha h2 {\n margin: 0;\n}\n\n#mocha h1 {\n margin-top: 15px;\n font-size: 1em;\n font-weight: 200;\n}\n\n#mocha h1 a {\n text-decoration: none;\n color: inherit;\n}\n\n#mocha h1 a:hover {\n text-decoration: underline;\n}\n\n#mocha .suite .suite h1 {\n margin-top: 0;\n font-size: .8em;\n}\n\n#mocha .hidden {\n display: none;\n}\n\n#mocha h2 {\n font-size: 12px;\n font-weight: normal;\n cursor: pointer;\n}\n\n#mocha .suite {\n margin-left: 15px;\n}\n\n#mocha .test {\n margin-left: 15px;\n overflow: hidden;\n}\n\n#mocha .test.pending:hover h2::after {\n content: \'(pending)\';\n font-family: arial, sans-serif;\n}\n\n#mocha .test.pass.medium .duration {\n background: #c09853;\n}\n\n#mocha .test.pass.slow .duration {\n background: #b94a48;\n}\n\n#mocha .test.pass::before {\n content: \'✓\';\n font-size: 12px;\n display: block;\n float: left;\n margin-right: 5px;\n color: #00d6b2;\n}\n\n#mocha .test.pass .duration {\n font-size: 9px;\n margin-left: 5px;\n padding: 2px 5px;\n color: #fff;\n -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n -webkit-border-radius: 5px;\n -moz-border-radius: 5px;\n -ms-border-radius: 5px;\n -o-border-radius: 5px;\n border-radius: 5px;\n}\n\n#mocha .test.pass.fast .duration {\n display: none;\n}\n\n#mocha .test.pending {\n color: #0b97c4;\n}\n\n#mocha .test.pending::before {\n content: \'◦\';\n color: #0b97c4;\n}\n\n#mocha .test.fail {\n color: #c00;\n}\n\n#mocha .test.fail pre {\n color: black;\n}\n\n#mocha .test.fail::before {\n content: \'✖\';\n font-size: 12px;\n display: block;\n float: left;\n margin-right: 5px;\n color: #c00;\n}\n\n#mocha .test pre.error {\n color: #c00;\n max-height: 300px;\n overflow: auto;\n}\n\n/**\n * (1): approximate for browsers not supporting calc\n * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)\n * ^^ seriously\n */\n#mocha .test pre {\n display: block;\n float: left;\n clear: left;\n font: 12px/1.5 monaco, monospace;\n margin: 5px;\n padding: 15px;\n border: 1px solid #eee;\n max-width: 85%; /*(1)*/\n max-width: calc(100% - 42px); /*(2)*/\n word-wrap: break-word;\n border-bottom-color: #ddd;\n -webkit-border-radius: 3px;\n -webkit-box-shadow: 0 1px 3px #eee;\n -moz-border-radius: 3px;\n -moz-box-shadow: 0 1px 3px #eee;\n border-radius: 3px;\n}\n\n#mocha .test h2 {\n position: relative;\n}\n\n#mocha .test a.replay {\n position: absolute;\n top: 3px;\n right: 0;\n text-decoration: none;\n vertical-align: middle;\n display: block;\n width: 15px;\n height: 15px;\n line-height: 15px;\n text-align: center;\n background: #eee;\n font-size: 15px;\n -moz-border-radius: 15px;\n border-radius: 15px;\n -webkit-transition: opacity 200ms;\n -moz-transition: opacity 200ms;\n transition: opacity 200ms;\n opacity: 0.3;\n color: #888;\n}\n\n#mocha .test:hover a.replay {\n opacity: 1;\n}\n\n#mocha-report.pass .test.fail {\n display: none;\n}\n\n#mocha-report.fail .test.pass {\n display: none;\n}\n\n#mocha-report.pending .test.pass,\n#mocha-report.pending .test.fail {\n display: none;\n}\n#mocha-report.pending .test.pass.pending {\n display: block;\n}\n\n#mocha-error {\n color: #c00;\n font-size: 1.5em;\n font-weight: 100;\n letter-spacing: 1px;\n}\n\n#mocha-stats {\n position: fixed;\n top: 15px;\n right: 10px;\n font-size: 12px;\n margin: 0;\n color: #888;\n z-index: 1;\n}\n\n#mocha-stats .progress {\n float: right;\n padding-top: 0;\n}\n\n#mocha-stats em {\n color: black;\n}\n\n#mocha-stats a {\n text-decoration: none;\n color: inherit;\n}\n\n#mocha-stats a:hover {\n border-bottom: 1px solid #eee;\n}\n\n#mocha-stats li {\n display: inline-block;\n margin: 0 5px;\n list-style: none;\n padding-top: 11px;\n}\n\n#mocha-stats canvas {\n width: 40px;\n height: 40px;\n}\n\n#mocha code .comment { color: #ddd; }\n#mocha code .init { color: #2f6fad; }\n#mocha code .string { color: #5890ad; }\n#mocha code .keyword { color: #8a6343; }\n#mocha code .number { color: #2f6fad; }\n\n@media screen and (max-device-width: 480px) {\n #mocha {\n margin: 60px 0px;\n }\n\n #mocha #stats {\n position: absolute;\n }\n}\n'; +document.head.appendChild(style); +})(); +// Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +// +// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt +// The complete set of authors may be found at polymer.github.io/AUTHORS.txt +// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt +// Code distributed by Google as part of the polymer project is also subject to +// an additional IP rights grant found at polymer.github.io/PATENTS.txt +(function(scope) { +'use strict'; + +function parse(stack) { + var rawLines = stack.split('\n'); + + var stackyLines = compact(rawLines.map(parseStackyLine)); + if (stackyLines.length === rawLines.length) return stackyLines; + + var v8Lines = compact(rawLines.map(parseV8Line)); + if (v8Lines.length > 0) return v8Lines; + + var geckoLines = compact(rawLines.map(parseGeckoLine)); + if (geckoLines.length > 0) return geckoLines; + + throw new Error('Unknown stack format: ' + stack); +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack +var GECKO_LINE = /^(?:([^@]*)@)?(.*?):(\d+)(?::(\d+))?$/; + +function parseGeckoLine(line) { + var match = line.match(GECKO_LINE); + if (!match) return null; + return { + method: match[1] || '', + location: match[2] || '', + line: parseInt(match[3]) || 0, + column: parseInt(match[4]) || 0, + }; +} + +// https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi +var V8_OUTER1 = /^\s*(eval )?at (.*) \((.*)\)$/; +var V8_OUTER2 = /^\s*at()() (\S+)$/; +var V8_INNER = /^\(?([^\(]+):(\d+):(\d+)\)?$/; + +function parseV8Line(line) { + var outer = line.match(V8_OUTER1) || line.match(V8_OUTER2); + if (!outer) return null; + var inner = outer[3].match(V8_INNER); + if (!inner) return null; + + var method = outer[2] || ''; + if (outer[1]) method = 'eval at ' + method; + return { + method: method, + location: inner[1] || '', + line: parseInt(inner[2]) || 0, + column: parseInt(inner[3]) || 0, + }; +} + +// Stacky.formatting.pretty + +var STACKY_LINE = /^\s*(.+) at (.+):(\d+):(\d+)$/; + +function parseStackyLine(line) { + var match = line.match(STACKY_LINE); + if (!match) return null; + return { + method: match[1] || '', + location: match[2] || '', + line: parseInt(match[3]) || 0, + column: parseInt(match[4]) || 0, + }; +} + +// Helpers + +function compact(array) { + var result = []; + array.forEach(function(value) { + if (value) { + result.push(value); + } + }); + return result; +} + +scope.parse = parse; +scope.parseGeckoLine = parseGeckoLine; +scope.parseV8Line = parseV8Line; +scope.parseStackyLine = parseStackyLine; +})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {})); + +// Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +// +// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt +// The complete set of authors may be found at polymer.github.io/AUTHORS.txt +// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt +// Code distributed by Google as part of the polymer project is also subject to +// an additional IP rights grant found at polymer.github.io/PATENTS.txt +(function(scope) { +'use strict'; + +var parse = scope.parse || require('./parsing').parse; + +scope.defaults = { + // Methods are aligned up to this much padding. + maxMethodPadding: 40, + // A string to prefix each line with. + indent: '', + // A string to show for stack lines that are missing a method. + methodPlaceholder: '', + // A list of Strings/RegExps that will be stripped from `location` values on + // each line (via `String#replace`). + locationStrip: [], + // A list of Strings/RegExps that indicate that a line is *not* important, and + // should be styled as such. + unimportantLocation: [], + // A filter function to completely remove lines + filter: function() { return false; }, + // styles are functions that take a string and return that string when styled. + styles: { + method: passthrough, + location: passthrough, + line: passthrough, + column: passthrough, + unimportant: passthrough, + }, +}; + +// For Stacky-in-Node, we default to colored stacks. +if (typeof require === 'function') { + var chalk = require('chalk'); + + scope.defaults.styles = { + method: chalk.magenta, + location: chalk.blue, + line: chalk.cyan, + column: chalk.cyan, + unimportant: chalk.dim, + }; +} + +function pretty(stackOrParsed, options) { + options = mergeDefaults(options || {}, scope.defaults); + var lines = Array.isArray(stackOrParsed) ? stackOrParsed : parse(stackOrParsed); + lines = clean(lines, options); + + var padSize = methodPadding(lines, options); + var parts = lines.map(function(line) { + var method = line.method || options.methodPlaceholder; + var pad = options.indent + padding(padSize - method.length); + var location = [ + options.styles.location(line.location), + options.styles.line(line.line), + options.styles.column(line.column), + ].join(':'); + + var text = pad + options.styles.method(method) + ' at ' + location; + if (!line.important) { + text = options.styles.unimportant(text); + } + return text; + }); + + return parts.join('\n'); +} + +function clean(lines, options) { + var result = []; + for (var i = 0, line; line = lines[i]; i++) { + if (options.filter(line)) continue; + line.location = cleanLocation(line.location, options); + line.important = isImportant(line, options); + result.push(line); + } + + return result; +} + +// Utility + +function passthrough(string) { + return string; +} + +function mergeDefaults(options, defaults) { + var result = Object.create(defaults); + Object.keys(options).forEach(function(key) { + var value = options[key]; + if (typeof value === 'object' && !Array.isArray(value)) { + value = mergeDefaults(value, defaults[key]); + } + result[key] = value; + }); + return result; +} + +function methodPadding(lines, options) { + var size = options.methodPlaceholder.length; + for (var i = 0, line; line = lines[i]; i++) { + size = Math.min(options.maxMethodPadding, Math.max(size, line.method.length)); + } + return size; +} + +function padding(length) { + var result = ''; + for (var i = 0; i < length; i++) { + result = result + ' '; + } + return result; +} + +function cleanLocation(location, options) { + if (options.locationStrip) { + for (var i = 0, matcher; matcher = options.locationStrip[i]; i++) { + location = location.replace(matcher, ''); + } + } + + return location; +} + +function isImportant(line, options) { + if (options.unimportantLocation) { + for (var i = 0, matcher; matcher = options.unimportantLocation[i]; i++) { + if (line.location.match(matcher)) return false; + } + } + + return true; +} + +scope.clean = clean; +scope.pretty = pretty; +})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {})); + + +// Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +// +// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt +// The complete set of authors may be found at polymer.github.io/AUTHORS.txt +// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt +// Code distributed by Google as part of the polymer project is also subject to +// an additional IP rights grant found at polymer.github.io/PATENTS.txt +(function(scope) { +'use strict'; + +var parse = scope.parse || require('./parsing').parse; +var pretty = scope.pretty || require('./formatting').pretty; + +function normalize(error, prettyOptions) { + if (error.parsedStack) return error; + var message = error.message || error.description || error || ''; + var parsedStack = []; + try { + parsedStack = parse(error.stack || error.toString()); + } catch (error) { + // Ah well. + } + + if (parsedStack.length === 0 && error.fileName) { + parsedStack.push({ + method: '', + location: error.fileName, + line: error.lineNumber, + column: error.columnNumber, + }); + } + + var prettyStack = message; + if (parsedStack.length > 0) { + prettyStack = prettyStack + '\n' + pretty(parsedStack, prettyOptions); + } + + return { + message: message, + stack: prettyStack, + parsedStack: parsedStack, + }; +} + +scope.normalize = normalize; +})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {})); + + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +/** + * @fileoverview + * + * Your entry point into `web-component-tester`'s environment and configuration. + */ +(function() { + +var WCT = window.WCT = { + reporters: {}, +}; + +// Configuration + +/** By default, we wait for any web component frameworks to load. */ +WCT.waitForFrameworks = true; + +/** How many `.html` suites that can be concurrently loaded & run. */ +WCT.numConcurrentSuites = 1; + +// Helpers + +// Evaluated in mocha/run.js. +WCT._suitesToLoad = []; +WCT._dependencies = []; + +// Used to share data between subSuites on client and reporters on server +WCT.share = {}; + +/** + * Loads suites of tests, supporting `.js` as well as `.html` files. + * + * @param {!Array.} files The files to load. + */ +WCT.loadSuites = function loadSuites(files) { + files.forEach(function(file) { + if (file.slice(-3) === '.js') { + WCT._dependencies.push(file); + } else if (file.slice(-5) === '.html') { + WCT._suitesToLoad.push(file); + } else { + throw new Error('Unknown resource type: ' + file); + } + }); +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.util = {}; + +/** + * @param {function()} callback A function to call when the active web component + * frameworks have loaded. + */ +WCT.util.whenFrameworksReady = function(callback) { + WCT.util.debug(window.location.pathname, 'WCT.util.whenFrameworksReady'); + var done = function() { + WCT.util.debug(window.location.pathname, 'WCT.util.whenFrameworksReady done'); + callback(); + }; + + function importsReady() { + window.removeEventListener('HTMLImportsLoaded', importsReady); + WCT.util.debug(window.location.pathname, 'HTMLImportsLoaded'); + + if (window.Polymer && Polymer.whenReady) { + Polymer.whenReady(function() { + WCT.util.debug(window.location.pathname, 'polymer-ready'); + done(); + }); + } else { + done(); + } + } + + // All our supported framework configurations depend on imports. + if (!window.HTMLImports) { + done(); + } else if (HTMLImports.ready) { + importsReady(); + } else { + window.addEventListener('HTMLImportsLoaded', importsReady); + } +}; + +/** + * @param {number} count + * @param {string} kind + * @return {string} ' tests' or ' test'. + */ +WCT.util.pluralizedStat = function pluralizedStat(count, kind) { + if (count === 1) { + return count + ' ' + kind + ' test'; + } else { + return count + ' ' + kind + ' tests'; + } +}; + +/** + * @param {string} path The URI of the script to load. + * @param {function} done + */ +WCT.util.loadScript = function loadScript(path, done) { + var script = document.createElement('script'); + script.src = path + '?' + Math.random(); + script.onload = done.bind(null, null); + script.onerror = done.bind(null, 'Failed to load script ' + script.src); + document.head.appendChild(script); +}; + +/** + * @param {...*} var_args Logs values to the console when `WCT.debug` is true. + */ +WCT.util.debug = function debug(var_args) { + if (!WCT.debug) return; + console.debug.apply(console, arguments); +}; + +// URL Processing + +/** + * @param {string} opt_query A query string to parse. + * @return {!Object.>} All params on the URL's query. + */ +WCT.util.getParams = function getParams(opt_query) { + var query = opt_query || window.location.search; + if (query.substring(0, 1) === '?') { + query = query.substring(1); + } + // python's SimpleHTTPServer tacks a `/` on the end of query strings :( + if (query.slice(-1) === '/') { + query = query.substring(0, query.length - 1); + } + if (query === '') return {}; + + var result = {}; + query.split('&').forEach(function(part) { + var pair = part.split('='); + if (pair.length !== 2) { + console.warn('Invalid URL query part:', part); + return; + } + var key = decodeURIComponent(pair[0]); + var value = decodeURIComponent(pair[1]); + + if (!result[key]) { + result[key] = []; + } + result[key].push(value); + }); + + return result; +}; + +/** + * @param {string} param The param to return a value for. + * @return {?string} The first value for `param`, if found. + */ +WCT.util.getParam = function getParam(param) { + var params = WCT.util.getParams(); + return params[param] ? params[param][0] : null; +}; + +/** + * @param {!Object.>} params + * @return {string} `params` encoded as a URI query. + */ +WCT.util.paramsToQuery = function paramsToQuery(params) { + var pairs = []; + Object.keys(params).forEach(function(key) { + params[key].forEach(function(value) { + pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(value)); + }); + }); + return '?' + pairs.join('&'); +}; + +/** @return {string} `location` relative to the current window. */ +WCT.util.relativeLocation = function relativeLocation(location) { + var path = location.pathname; + var basePath = window.location.pathname.match(/^.*\//)[0]; + if (path.indexOf(basePath) === 0) { + path = path.substring(basePath.length); + } + return path; +}; + +/** + * Like `async.parallelLimit`, but our own so that we don't force a dependency + * on downstream code. + * + * @param {!Array.} runners Runners that call their given + * Node-style callback when done. + * @param {number|function(*)} limit Maximum number of concurrent runners. + * (optional). + * @param {?function(*)} done Callback that should be triggered once all runners + * have completed, or encountered an error. + */ +WCT.util.parallel = function parallel(runners, limit, done) { + if (typeof limit !== 'number') { + done = limit; + limit = 0; + } + if (!runners.length) return done(); + + var called = false; + var total = runners.length; + var numActive = 0; + var numDone = 0; + + function runnerDone(error) { + if (called) return; + numDone = numDone + 1; + numActive = numActive - 1; + + if (error || numDone >= total) { + called = true; + done(error); + } else { + runOne(); + } + } + + function runOne() { + if (limit && numActive >= limit) return; + if (!runners.length) return; + numActive = numActive + 1; + runners.shift()(runnerDone); + } + runners.forEach(runOne); +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.CLISocket = CLISocket; + +var SOCKETIO_ENDPOINT = window.location.protocol + '//' + window.location.host; +var SOCKETIO_LIBRARY = SOCKETIO_ENDPOINT + '/socket.io/socket.io.js'; + +/** + * A socket for communication between the CLI and browser runners. + * + * @param {string} browserId An ID generated by the CLI runner. + * @param {!io.Socket} socket The socket.io `Socket` to communicate over. + */ +function CLISocket(browserId, socket) { + this.browserId = browserId; + this.socket = socket; +} + +/** + * @param {!Mocha.Runner} runner The Mocha `Runner` to observe, reporting + * interesting events back to the CLI runner. + */ +CLISocket.prototype.observe = function observe(runner) { + this.emitEvent('browser-start', { + url: window.location.toString(), + }); + + // We only emit a subset of events that we care about, and follow a more + // general event format that is hopefully applicable to test runners beyond + // mocha. + // + // For all possible mocha events, see: + // https://github.com/visionmedia/mocha/blob/master/lib/runner.js#L36 + runner.on('test', function(test) { + this.emitEvent('test-start', {test: getTitles(test)}); + }.bind(this)); + + runner.on('test end', function(test) { + this.emitEvent('test-end', { + state: getState(test), + test: getTitles(test), + duration: test.duration, + error: test.err, + }); + }.bind(this)); + + runner.on('subSuite start', function(subSuite) { + this.emitEvent('sub-suite-start', subSuite.share); + }.bind(this)); + + runner.on('subSuite end', function(subSuite) { + this.emitEvent('sub-suite-end', subSuite.share); + }.bind(this)); + + runner.on('end', function() { + this.emitEvent('browser-end'); + }.bind(this)); +}; + +/** + * @param {string} event The name of the event to fire. + * @param {*} data Additional data to pass with the event. + */ +CLISocket.prototype.emitEvent = function emitEvent(event, data) { + this.socket.emit('client-event', { + browserId: this.browserId, + event: event, + data: data, + }); +}; + +/** + * Builds a `CLISocket` if we are within a CLI-run environment; short-circuits + * otherwise. + * + * @param {function(*, CLISocket)} done Node-style callback. + */ +CLISocket.init = function init(done) { + var browserId = WCT.util.getParam('cli_browser_id'); + if (!browserId) return done(); + + WCT.util.loadScript(SOCKETIO_LIBRARY, function(error) { + if (error) return done(error); + + var socket = io(SOCKETIO_ENDPOINT); + socket.on('error', function(error) { + socket.off(); + done(error); + }); + + socket.on('connect', function() { + socket.off(); + done(null, new CLISocket(browserId, socket)); + }); + }); +}; + +// Misc Utility + +/** + * @param {!Mocha.Runnable} runnable The test or suite to extract titles from. + * @return {!Array.} The titles of the runnable and its parents. + */ +function getTitles(runnable) { + var titles = []; + while (runnable && !runnable.root && runnable.title) { + titles.unshift(runnable.title); + runnable = runnable.parent; + } + return titles; +} + +/** + * @param {!Mocha.Runnable} runnable + * @return {string} + */ +function getState(runnable) { + if (runnable.state === 'passed') { + return 'passing'; + } else if (runnable.state == 'failed') { + return 'failing'; + } else if (runnable.pending) { + return 'pending'; + } else { + return 'unknown'; + } +} + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +// TODO(thedeeno): Consider renaming subsuite. IIRC, subSuite is entirely +// distinct from mocha suite, which tripped me up badly when trying to add +// plugin support. Perhaps something like 'batch', or 'bundle'. Something that +// has no mocha correlate. This may also eliminate the need for root/non-root +// suite distinctions. + +/** + * A Mocha suite (or suites) run within a child iframe, but reported as if they + * are part of the current context. + */ +function SubSuite(url, parentScope) { + var params = WCT.util.getParams(parentScope.location.search); + delete params.cli_browser_id; + params.bust = [Math.random()]; + + this.url = url + WCT.util.paramsToQuery(params); + this.parentScope = parentScope; + + this.state = 'initializing'; +} +WCT.SubSuite = SubSuite; + +// SubSuites get a pretty generous load timeout by default. +SubSuite.loadTimeout = 30000; + +// We can't maintain properties on iframe elements in Firefox/Safari/???, so we +// track subSuites by URL. +SubSuite._byUrl = {}; + +/** + * @return {SubSuite} The `SubSuite` that was registered for this window. + */ +SubSuite.current = function() { + return SubSuite.get(window); +}; + +/** + * @param {!Window} target A window to find the SubSuite of. + * @param {boolean} traversal Whether this is a traversal from a child window. + * @return {SubSuite} The `SubSuite` that was registered for `target`. + */ +SubSuite.get = function(target, traversal) { + var subSuite = SubSuite._byUrl[target.location.href]; + if (subSuite) return subSuite; + if (window.parent === window) { + if (traversal) { + // I really hope there's no legit case for this. Infinite reloads are no good. + console.warn('Subsuite loaded but was never registered. This most likely is due to wonky history behavior. Reloading...'); + window.location.reload(); + } else { + return null; + } + } + // Otherwise, traverse. + return window.parent.WCT.SubSuite.get(target, true); +}; + +/** + * Hangs a reference to the SubSuite's iframe-local wct object + * + * TODO(thedeeno): This method is odd to document so the achitecture might need + * a little rework here. Maybe another named concept? Seeing WCT everywhere is + * pretty confusing. Also, I don't think we need the parentScope.WCT; to limit + * confusion I didn't include it. + * + * @param {object} wct The SubSuite's iframe-local wct object + */ +SubSuite.prototype.prepare = function(wct) { + this.share = wct.share; +}; + +/** + * Loads and runs the subsuite. + * + * @param {function} done Node-style callback. + */ +SubSuite.prototype.run = function(done) { + WCT.util.debug('SubSuite#run', this.url); + this.state = 'loading'; + this.onRunComplete = done; + + this.iframe = document.createElement('iframe'); + this.iframe.src = this.url; + this.iframe.classList.add('subsuite'); + + var container = document.getElementById('subsuites'); + if (!container) { + container = document.createElement('div'); + container.id = 'subsuites'; + document.body.appendChild(container); + } + container.appendChild(this.iframe); + + // let the iframe expand the URL for us. + this.url = this.iframe.src; + SubSuite._byUrl[this.url] = this; + + this.timeoutId = setTimeout( + this.loaded.bind(this, new Error('Timed out loading ' + this.url)), SubSuite.loadTimeout); + + this.iframe.addEventListener('error', + this.loaded.bind(this, new Error('Failed to load document ' + this.url))); + + this.iframe.contentWindow.addEventListener('DOMContentLoaded', this.loaded.bind(this, null)); +}; + +/** + * Called when the sub suite's iframe has loaded (or errored during load). + * + * @param {*} error The error that occured, if any. + */ +SubSuite.prototype.loaded = function(error) { + WCT.util.debug('SubSuite#loaded', this.url, error); + if (this.timeoutId) { + clearTimeout(this.timeoutId); + } + if (error) { + this.signalRunComplete(error); + this.done(); + } +}; + +/** Called when the sub suite's tests are complete, so that it can clean up. */ +SubSuite.prototype.done = function done() { + WCT.util.debug('SubSuite#done', this.url, arguments); + + this.signalRunComplete(); + + if (!this.iframe) return; + this.iframe.parentNode.removeChild(this.iframe); +}; + +SubSuite.prototype.signalRunComplete = function signalRunComplete(error) { + if (!this.onRunComplete) return; + this.state = 'complete'; + this.onRunComplete(error); + this.onRunComplete = null; +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +// polymer-test-tools (and Polymer/tools) support HTML tests where each file is +// expected to call `done()`, which posts a message to the parent window. +window.addEventListener('message', function(event) { + if (!event.data || (event.data !== 'ok' && !event.data.error)) return; + var subSuite = WCT.SubSuite.get(event.source); + if (!subSuite) return; + + // The name of the suite as exposed to the user. + var path = WCT.util.relativeLocation(event.source.location); + var parentRunner = subSuite.parentScope.WCT._multiRunner; + parentRunner.emitOutOfBandTest('page-wide tests via global done()', event.data.error, path, true); + + subSuite.done(); +}); + +// Attempt to ensure that we complete a test suite if it is interrupted by a +// document unload. +window.addEventListener('unload', function(event) { + // Mocha's hook queue is asynchronous; but we want synchronous behavior if + // we've gotten to the point of unloading the document. + Mocha.Runner.immediately = function(callback) { callback(); }; +}); + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +/** + * Runs `stepFn`, catching any error and passing it to `callback` (Node-style). + * Otherwise, calls `callback` with no arguments on success. + * + * @param {function()} callback + * @param {function()} stepFn + */ +window.safeStep = function safeStep(callback, stepFn) { + var err; + try { + stepFn(); + } catch (error) { + err = error; + } + callback(err); +}; + +/** + * Runs your test at declaration time (before Mocha has begun tests). Handy for + * when you need to test document initialization. + * + * Be aware that any errors thrown asynchronously cannot be tied to your test. + * You may want to catch them and pass them to the done event, instead. See + * `safeStep`. + * + * @param {string} name The name of the test. + * @param {function(?function())} testFn The test function. If an argument is + * accepted, the test will be treated as async, just like Mocha tests. + */ +window.testImmediate = function testImmediate(name, testFn) { + if (testFn.length > 0) { + return testImmediateAsync(name, testFn); + } + + var err; + try { + testFn(); + } catch (error) { + err = error; + } + + test(name, function(done) { + done(err); + }); +}; + +/** + * An async-only variant of `testImmediate`. + * + * @param {string} name + * @param {function(?function())} testFn + */ +window.testImmediateAsync = function testImmediateAsync(name, testFn) { + var testComplete = false; + var err; + + test(name, function(done) { + var intervalId = setInterval(function() { + if (!testComplete) return; + clearInterval(intervalId); + done(err); + }, 10); + }); + + try { + testFn(function(error) { + if (error) err = error; + testComplete = true; + }); + } catch (error) { + err = error; + } +}; + +/** + * Triggers a flush of any pending events, observations, etc and calls you back + * after they have been processed. + * + * @param {function()} callback + */ +window.flush = function flush(callback) { + // Ideally, this function would be a call to Polymer.flush, but that doesn't + // support a callback yet (https://github.com/Polymer/polymer-dev/issues/115), + // ...and there's cross-browser flakiness to deal with. + + // Make sure that we're invoking the callback with no arguments so that the + // caller can pass Mocha callbacks, etc. + var done = function done() { callback(); }; + + // Because endOfMicrotask is flaky for IE, we perform microtask checkpoints + // ourselves (https://github.com/Polymer/polymer-dev/issues/114): + var isIE = navigator.appName == 'Microsoft Internet Explorer'; + if (isIE && window.Platform && window.Platform.performMicrotaskCheckpoint) { + var reallyDone = done; + done = function doneIE() { + Platform.performMicrotaskCheckpoint(); + setTimeout(reallyDone, 0); + }; + } + + // Everyone else gets a regular flush. + var scope = window.Polymer || window.WebComponents; + if (scope && scope.flush) { + scope.flush(); + } + + // Ensure that we are creating a new _task_ to allow all active microtasks to + // finish (the code you're testing may be using endOfMicrotask, too). + setTimeout(done, 0); +}; + +/** + * Advances a single animation frame. + * + * Calls `flush`, `requestAnimationFrame`, `flush`, and `callback` sequentially + * @param {function()} callback + */ +window.animationFrameFlush = function animationFrameFlush(callback) { + flush(function() { + requestAnimationFrame(function() { + flush(callback); + }); + }); +}; + +/** + * DEPRECATED: Use `flush`. + * @param {function} callback + */ +window.asyncPlatformFlush = function asyncPlatformFlush(callback) { + console.warn('asyncPlatformFlush is deprecated in favor of the more terse flush()'); + return window.flush(callback); +}; + +/** + * + */ +window.waitFor = function waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime) { + timeoutTime = timeoutTime || Date.now() + (timeout || 1000); + intervalOrMutationEl = intervalOrMutationEl || 32; + try { + fn(); + } catch (e) { + if (Date.now() > timeoutTime) { + throw e; + } else { + if (isNaN(intervalOrMutationEl)) { + intervalOrMutationEl.onMutation(intervalOrMutationEl, function() { + waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime); + }); + } else { + setTimeout(function() { + waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime); + }, intervalOrMutationEl); + } + return; + } + } + next(); +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.MultiRunner = MultiRunner; + +var STACKY_CONFIG = { + indent: ' ', + locationStrip: [ + /^https?:\/\/[^\/]+/, + /\?[\d\.]+$/, + ], + filter: function(line) { + return line.location.match(/web-component-tester\/browser.js/); + }, +}; + +// https://github.com/visionmedia/mocha/blob/master/lib/runner.js#L36-46 +var MOCHA_EVENTS = [ + 'start', + 'end', + 'suite', + 'suite end', + 'test', + 'test end', + 'hook', + 'hook end', + 'pass', + 'fail', + 'pending', +]; + +// Until a suite has loaded, we assume this many tests in it. +var ESTIMATED_TESTS_PER_SUITE = 3; + +/** + * A Mocha-like runner that combines the output of multiple Mocha suites. + * + * @param {number} numSuites The number of suites that will be run, in order to + * estimate the total number of tests that will be performed. + * @param {!Array.} reporters The set of reporters that + * should receive the unified event stream. + */ +function MultiRunner(numSuites, reporters) { + this.reporters = reporters.map(function(reporter) { + return new reporter(this); + }.bind(this)); + + this.total = numSuites * ESTIMATED_TESTS_PER_SUITE; + // Mocha reporters assume a stream of events, so we have to be careful to only + // report on one runner at a time... + this.currentRunner = null; + // ...while we buffer events for any other active runners. + this.pendingEvents = []; + + this.emit('start'); +} +// Mocha doesn't expose its `EventEmitter` shim directly, so: +MultiRunner.prototype = Object.create(Object.getPrototypeOf(Mocha.Runner.prototype)); + +/** + * @return {!Mocha.reporters.Base} A reporter-like "class" for each child suite + * that should be passed to `mocha.run`. + */ +MultiRunner.prototype.childReporter = function childReporter(name) { + // The reporter is used as a constructor, so we can't depend on `this` being + // properly bound. + var self = this; + function reporter(runner) { + runner.name = name; + self.bindChildRunner(runner); + } + reporter.title = name; + return reporter; +}; + +/** Must be called once all runners have finished. */ +MultiRunner.prototype.done = function done() { + this.complete = true; + this.emit('end'); + this.flushPendingEvents(); +}; + +/** + * Emit a top level test that is not part of any suite managed by this runner. + * + * Helpful for reporting on global errors, loading issues, etc. + * + * @param {string} title The title of the test. + * @param {*} opt_error An error associated with this test. If falsy, test is + * considered to be passing. + * @param {string} opt_suiteTitle Title for the suite that's wrapping the test. + * @param {?boolean} opt_estimated If this test was included in the original + * estimate of `numSuites`. + */ +MultiRunner.prototype.emitOutOfBandTest = function emitOutOfBandTest(title, opt_error, opt_suiteTitle, opt_estimated) { + WCT.util.debug('MultiRunner#emitOutOfBandTest(', arguments, ')'); + var root = new Mocha.Suite(); + root.title = opt_suiteTitle; + var test = new Mocha.Test(title, function() { + }); + test.parent = root; + test.state = opt_error ? 'failed' : 'passed'; + test.err = opt_error; + + if (!opt_estimated) { + this.total = this.total + ESTIMATED_TESTS_PER_SUITE; + } + + var runner = {total: 1}; + this.proxyEvent('start', runner); + this.proxyEvent('suite', runner, root); + this.proxyEvent('test', runner, test); + if (opt_error) { + this.proxyEvent('fail', runner, test, opt_error); + } else { + this.proxyEvent('pass', runner, test); + } + this.proxyEvent('test end', runner, test); + this.proxyEvent('suite end', runner, root); + this.proxyEvent('end', runner); +}; + +// Internal Interface + +/** @param {!Mocha.runners.Base} runner The runner to listen to events for. */ +MultiRunner.prototype.bindChildRunner = function bindChildRunner(runner) { + MOCHA_EVENTS.forEach(function(eventName) { + runner.on(eventName, this.proxyEvent.bind(this, eventName, runner)); + }.bind(this)); +}; + +/** + * Evaluates an event fired by `runner`, proxying it forward or buffering it. + * + * @param {string} eventName + * @param {!Mocha.runners.Base} runner The runner that emitted this event. + * @param {...*} var_args Any additional data passed as part of the event. + */ +MultiRunner.prototype.proxyEvent = function proxyEvent(eventName, runner, var_args) { + var extraArgs = Array.prototype.slice.call(arguments, 2); + if (this.complete) { + console.warn('out of order Mocha event for ' + runner.name + ':', eventName, extraArgs); + return; + } + + if (this.currentRunner && runner !== this.currentRunner) { + this.pendingEvents.push(arguments); + return; + } + WCT.util.debug('MultiRunner#proxyEvent(', arguments, ')'); + + // This appears to be a Mocha bug: Tests failed by passing an error to their + // done function don't set `err` properly. + // + // TODO(nevir): Track down. + if (eventName === 'fail' && !extraArgs[0].err) { + extraArgs[0].err = extraArgs[1]; + } + + if (eventName === 'start') { + this.onRunnerStart(runner); + } else if (eventName === 'end') { + this.onRunnerEnd(runner); + } else { + this.cleanEvent(eventName, runner, extraArgs); + this.emit.apply(this, [eventName].concat(extraArgs)); + } +}; + +/** + * Cleans or modifies an event if needed. + * + * @param {string} eventName + * @param {!Mocha.runners.Base} runner The runner that emitted this event. + * @param {!Array.<*>} extraArgs + */ +MultiRunner.prototype.cleanEvent = function cleanEvent(eventName, runner, extraArgs) { + // Suite hierarchy + if (extraArgs[0]) { + extraArgs[0] = this.showRootSuite(extraArgs[0]); + } + + // Normalize errors + if (eventName === 'fail') { + extraArgs[1] = Stacky.normalize(extraArgs[1], STACKY_CONFIG); + } + if (extraArgs[0] && extraArgs[0].err) { + extraArgs[0].err = Stacky.normalize(extraArgs[0].err, STACKY_CONFIG); + } +}; + +/** + * We like to show the root suite's title, which requires a little bit of + * trickery in the suite hierarchy. + * + * @param {!Mocha.Runnable} node + */ +MultiRunner.prototype.showRootSuite = function showRootSuite(node) { + var leaf = node = Object.create(node); + while (node && !node.root) { + var wrappedParent = Object.create(node.parent); + node.parent = wrappedParent; + node = wrappedParent; + } + node.root = false; + + return leaf; +}; + +/** @param {!Mocha.runners.Base} runner */ +MultiRunner.prototype.onRunnerStart = function onRunnerStart(runner) { + WCT.util.debug('MultiRunner#onRunnerStart:', runner.name); + this.total = this.total - ESTIMATED_TESTS_PER_SUITE + runner.total; + this.currentRunner = runner; +}; + +/** @param {!Mocha.runners.Base} runner */ +MultiRunner.prototype.onRunnerEnd = function onRunnerEnd(runner) { + WCT.util.debug('MultiRunner#onRunnerEnd:', runner.name); + this.currentRunner = null; + this.flushPendingEvents(); +}; + +/** + * Flushes any buffered events and runs them through `proxyEvent`. This will + * loop until all buffered runners are complete, or we have run out of buffered + * events. + */ +MultiRunner.prototype.flushPendingEvents = function flushPendingEvents() { + var events = this.pendingEvents; + this.pendingEvents = []; + events.forEach(function(eventArgs) { + this.proxyEvent.apply(this, eventArgs); + }.bind(this)); +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +/** + * @fileoverview + * + * Runs all tests described by this document, after giving the document a chance + * to load. + * + * If `WCT.waitForFrameworks` is true (the default), we will also wait for any + * present web component frameworks to have fully initialized as well. + */ +(function() { + +// We do a bit of our own grep processing to speed things up. +var grep = WCT.util.getParam('grep'); + +// environment.js is optional; we need to take a look at our script's URL in +// order to determine how (or not) to load it. +var prefix = window.WCTPrefix; +var loadEnv = !window.WCTSkipEnvironment; + +var scripts = document.querySelectorAll('script[src*="browser.js"]'); +if (scripts.length !== 1 && !prefix) { + throw new Error('Unable to detect root URL for WCT. Please set WCTPrefix before including browser.js'); +} +if (scripts[0]) { + var thisScript = scripts[0].src; + prefix = thisScript.substring(0, thisScript.indexOf('browser.js')); + // You can tack ?skipEnv onto the browser URL to skip the default environment. + loadEnv = thisScript.indexOf('skipEnv') === -1; +} +if (loadEnv) { + // Synchronous load so that we can guarantee it is set up for early tests. + document.write(''); // jshint ignore:line +} + +// Give any scripts on the page a chance to twiddle the environment. +document.addEventListener('DOMContentLoaded', function() { + WCT.util.debug('run stage: DOMContentLoaded'); + var subSuite = WCT.SubSuite.current(); + if (subSuite) { + WCT.util.debug('run stage: subsuite'); + // Give the subsuite time to complete its load (see `SubSuite.load`). + setTimeout(runSubSuite.bind(null, subSuite), 0); + return; + } + + // Before anything else, we need to ensure our communication channel with the + // CLI runner is established (if we're running in that context). Less + // buffering to deal with. + WCT.CLISocket.init(function(error, socket) { + WCT.util.debug('run stage: WCT.CLISocket.init done', error); + if (error) throw error; + var subsuites = WCT._suitesToLoad; + if (grep) { + var cleanSubsuites = []; + for (var i = 0, subsuite; subsuite = subsuites[i]; i++) { + if (subsuite.indexOf(grep) === 0) { + cleanSubsuites.push(subsuite); + } + } + subsuites = cleanSubsuites; + } + + var runner = newMultiSuiteRunner(subsuites, determineReporters(socket)); + + loadDependencies(runner, function(error) { + WCT.util.debug('run stage: loadDependencies done', error); + if (error) throw error; + + runMultiSuite(runner, subsuites); + }); + }); +}); + +/** + * Loads any dependencies of the _current_ suite (e.g. `.js` sources). + * + * @param {!WCT.MultiRunner} runner The runner where errors should be reported. + * @param {function} done A node style callback. + */ +function loadDependencies(runner, done) { + WCT.util.debug('loadDependencies:', WCT._dependencies); + + function onError(event) { + runner.emitOutOfBandTest('Test Suite Initialization', event.error); + } + window.addEventListener('error', onError); + + var loaders = WCT._dependencies.map(function(file) { + // We only support `.js` dependencies for now. + return WCT.util.loadScript.bind(WCT.util, file); + }); + + WCT.util.parallel(loaders, function(error) { + window.removeEventListener('error', onError); + done(error); + }); +} + +/** + * @param {!WCT.SubSuite} subSuite The `SubSuite` for this frame, that `mocha` + * should be run for. + */ +function runSubSuite(subSuite) { + WCT.util.debug('runSubSuite', window.location.pathname); + // Not very pretty. + var parentWCT = subSuite.parentScope.WCT; + subSuite.prepare(WCT); + + var suiteName = parentWCT.util.relativeLocation(window.location); + var reporter = parentWCT._multiRunner.childReporter(suiteName); + runMocha(reporter, subSuite.done.bind(subSuite)); +} + +/** + * @param {!Array.} subsuites The subsuites that will be run. + * @param {!Array.} reporters The reporters that should + * consume the output of this `MultiRunner`. + * @return {!WCT.MultiRunner} The runner for our root suite. + */ +function newMultiSuiteRunner(subsuites, reporters) { + WCT.util.debug('newMultiSuiteRunner', window.location.pathname); + WCT._multiRunner = new WCT.MultiRunner(subsuites.length + 1, reporters); + return WCT._multiRunner; +} + +/** + * @param {!WCT.MultiRunner} The runner built via `newMultiSuiteRunner`. + * @param {!Array.} subsuites The subsuites to run. + */ +function runMultiSuite(runner, subsuites) { + WCT.util.debug('runMultiSuite', window.location.pathname); + var rootName = WCT.util.relativeLocation(window.location); + + var suiteRunners = [ + // Run the local tests (if any) first, not stopping on error; + runMocha.bind(null, runner.childReporter(rootName)), + ]; + + // As well as any sub suites. Again, don't stop on error. + subsuites.forEach(function(file) { + suiteRunners.push(function(next) { + var subSuite = new WCT.SubSuite(file, window); + runner.emit('subSuite start', subSuite); + subSuite.run(function(error) { + runner.emit('subSuite end', subSuite); + + if (error) runner.emitOutOfBandTest(file, error); + next(); + }); + }); + }); + + WCT.util.parallel(suiteRunners, WCT.numConcurrentSuites, function(error) { + WCT.util.debug('runMultiSuite done', error); + runner.done(); + }); +} + +/** + * Kicks off a mocha run, waiting for frameworks to load if necessary. + * + * @param {!Mocha.reporters.Base} reporter The reporter to pass to `mocha.run`. + * @param {function} done A callback fired, _no error is passed_. + */ +function runMocha(reporter, done, waited) { + if (WCT.waitForFrameworks && !waited) { + WCT.util.whenFrameworksReady(runMocha.bind(null, reporter, done, true)); + return; + } + WCT.util.debug('runMocha', window.location.pathname); + + mocha.reporter(reporter); + mocha.suite.title = reporter.title; + mocha.grep(grep); + + // We can't use `mocha.run` because it bashes over grep, invert, and friends. + // See https://github.com/visionmedia/mocha/blob/master/support/tail.js#L137 + var runner = Mocha.prototype.run.call(mocha, function(error) { + Mocha.utils.highlightTags('code'); + done(); // We ignore the Mocha failure count. + }); + + // Mocha's default `onerror` handling strips the stack (to support really old + // browsers). We upgrade this to get better stacks for async errors. + // + // TODO(nevir): Can we expand support to other browsers? + if (navigator.userAgent.match(/chrome/i)) { + window.onerror = null; + window.addEventListener('error', function(event) { + if (!event.error) return; + if (event.error.ignore) return; + runner.uncaught(event.error); + }); + } +} + +/** + * Figure out which reporters should be used for the current `window`. + * + * @param {WCT.CLISocket} socket The CLI socket, if present. + */ +function determineReporters(socket) { + var reporters = [ + WCT.reporters.Title, + WCT.reporters.Console, + ]; + + if (socket) { + reporters.push(function(runner) { + socket.observe(runner); + }); + } + + if (WCT._suitesToLoad.length > 0 || WCT._dependencies.length > 0) { + reporters.push(WCT.reporters.HTML); + } + + return reporters; +} + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +/** + * @fileoverview + * + * Provides automatic configuration of Mocha by stubbing out potential Mocha + * methods, and configuring Mocha appropriately once you call them. + * + * Just call `suite`, `describe`, etc normally, and everything should Just Work. + */ +(function() { + +// Mocha global helpers, broken out by testing method. +var MOCHA_EXPORTS = { + // https://github.com/visionmedia/mocha/blob/master/lib/interfaces/tdd.js + tdd: [ + 'setup', + 'teardown', + 'suiteSetup', + 'suiteTeardown', + 'suite', + 'test', + ], + // https://github.com/visionmedia/mocha/blob/master/lib/interfaces/tdd.js + bdd: [ + 'before', + 'after', + 'beforeEach', + 'afterEach', + 'describe', + 'xdescribe', + 'xcontext', + 'it', + 'xit', + 'xspecify', + ], +}; + +// We expose all Mocha methods up front, configuring and running mocha +// automatically when you call them. +// +// The assumption is that it is a one-off (sub-)suite of tests being run. +Object.keys(MOCHA_EXPORTS).forEach(function(ui) { + MOCHA_EXPORTS[ui].forEach(function(key) { + window[key] = function wrappedMochaFunction() { + WCT.setupMocha(ui); + if (!window[key] || window[key] === wrappedMochaFunction) { + throw new Error('Expected mocha.setup to define ' + key); + } + window[key].apply(window, arguments); + }; + }); +}); + +/** + * @param {string} ui Sets up mocha to run `ui`-style tests. + */ +WCT.setupMocha = function setupMocha(ui) { + if (WCT._mochaUI && WCT._mochaUI === ui) return; + if (WCT._mochaUI && WCT._mochaUI !== ui) { + throw new Error('Mixing ' + WCT._mochaUI + ' and ' + ui + ' Mocha styles is not supported.'); + } + mocha.setup({ui: ui, timeout: 60 * 1000}); // Note that the reporter is configured in run.js. + WCT.mochaIsSetup = true; +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.reporters.Console = Console; + +// We capture console events when running tests; so make sure we have a +// reference to the original one. +var console = window.console; + +var FONT = ';font: normal 13px "Roboto", "Helvetica Neue", "Helvetica", sans-serif;'; +var STYLES = { + plain: FONT, + suite: 'color: #5c6bc0' + FONT, + test: FONT, + passing: 'color: #259b24' + FONT, + pending: 'color: #e65100' + FONT, + failing: 'color: #c41411' + FONT, + stack: 'color: #c41411', + results: FONT + 'font-size: 16px', +}; + +// I don't think we can feature detect this one... +var userAgent = navigator.userAgent.toLowerCase(); +var CAN_STYLE_LOG = userAgent.match('firefox') || userAgent.match('webkit'); +var CAN_STYLE_GROUP = userAgent.match('webkit'); +// Track the indent for faked `console.group` +var logIndent = ''; + +function log(text, style) { + text = text.split('\n').map(function(l) { return logIndent + l; }).join('\n'); + if (CAN_STYLE_LOG) { + console.log('%c' + text, STYLES[style] || STYLES.plain); + } else { + console.log(text); + } +} + +function logGroup(text, style) { + if (CAN_STYLE_GROUP) { + console.group('%c' + text, STYLES[style] || STYLES.plain); + } else if (console.group) { + console.group(text); + } else { + logIndent = logIndent + ' '; + log(text, style); + } +} + +function logGroupEnd() { + if (console.groupEnd) { + console.groupEnd(); + } else { + logIndent = logIndent.substr(0, logIndent.length - 2); + } +} + +function logException(error) { + log(error.stack || error.message || error, 'stack'); +} + +/** + * A Mocha reporter that logs results out to the web `console`. + * + * @param {!Mocha.Runner} runner The runner that is being reported on. + */ +function Console(runner) { + Mocha.reporters.Base.call(this, runner); + + runner.on('suite', function(suite) { + if (suite.root) return; + logGroup(suite.title, 'suite'); + }.bind(this)); + + runner.on('suite end', function(suite) { + if (suite.root) return; + logGroupEnd(); + }.bind(this)); + + runner.on('test', function(test) { + logGroup(test.title, 'test'); + }.bind(this)); + + runner.on('pending', function(test) { + logGroup(test.title, 'pending'); + }.bind(this)); + + runner.on('fail', function(test, error) { + logException(error); + }.bind(this)); + + runner.on('test end', function(test) { + logGroupEnd(); + }.bind(this)); + + runner.on('end', this.logSummary.bind(this)); +} +Console.prototype = Object.create(Mocha.reporters.Base.prototype); + +/** Prints out a final summary of test results. */ +Console.prototype.logSummary = function logSummary() { + logGroup('Test Results', 'results'); + + if (this.stats.failures > 0) { + log(WCT.util.pluralizedStat(this.stats.failures, 'failing'), 'failing'); + } + if (this.stats.pending > 0) { + log(WCT.util.pluralizedStat(this.stats.pending, 'pending'), 'pending'); + } + log(WCT.util.pluralizedStat(this.stats.passes, 'passing')); + + if (!this.stats.failures) { + log('test suite passed', 'passing'); + } + log('Evaluated ' + this.stats.tests + ' tests in ' + this.stats.duration + 'ms.'); + logGroupEnd(); +}; + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.reporters.HTML = HTML; + +/** + * WCT-specific behavior on top of Mocha's default HTML reporter. + * + * @param {!Mocha.Runner} runner The runner that is being reported on. + */ +function HTML(runner) { + var output = document.createElement('div'); + output.id = 'mocha'; + document.body.appendChild(output); + + runner.on('suite', function(test) { + this.total = runner.total; + }.bind(this)); + + Mocha.reporters.HTML.call(this, runner); +} +HTML.prototype = Object.create(Mocha.reporters.HTML.prototype); + +})(); + +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +(function() { + +WCT.reporters.Title = Title; + +var ARC_OFFSET = 0; // start at the right. +var ARC_WIDTH = 6; + +/** + * A Mocha reporter that updates the document's title and favicon with + * at-a-glance stats. + * + * @param {!Mocha.Runner} runner The runner that is being reported on. + */ +function Title(runner) { + Mocha.reporters.Base.call(this, runner); + + runner.on('test end', this.report.bind(this)); +} + +/** Reports current stats via the page title and favicon. */ +Title.prototype.report = function report() { + this.updateTitle(); + this.updateFavicon(); +}; + +/** Updates the document title with a summary of current stats. */ +Title.prototype.updateTitle = function updateTitle() { + if (this.stats.failures > 0) { + document.title = WCT.util.pluralizedStat(this.stats.failures, 'failing'); + } else { + document.title = WCT.util.pluralizedStat(this.stats.passes, 'passing'); + } +}; + +/** + * Draws an arc for the favicon status, relative to the total number of tests. + * + * @param {!CanvasRenderingContext2D} context + * @param {number} total + * @param {number} start + * @param {number} length + * @param {string} color + */ +function drawFaviconArc(context, total, start, length, color) { + var arcStart = ARC_OFFSET + Math.PI * 2 * (start / total); + var arcEnd = ARC_OFFSET + Math.PI * 2 * ((start + length) / total); + + context.beginPath(); + context.strokeStyle = color; + context.lineWidth = ARC_WIDTH; + context.arc(16, 16, 16 - ARC_WIDTH / 2, arcStart, arcEnd); + context.stroke(); +} + +/** Updates the document's favicon w/ a summary of current stats. */ +Title.prototype.updateFavicon = function updateFavicon() { + var canvas = document.createElement('canvas'); + canvas.height = canvas.width = 32; + var context = canvas.getContext('2d'); + + var passing = this.stats.passes; + var pending = this.stats.pending; + var failing = this.stats.failures; + var total = Math.max(this.runner.total, passing + pending + failing); + drawFaviconArc(context, total, 0, passing, '#0e9c57'); + drawFaviconArc(context, total, passing, pending, '#f3b300'); + drawFaviconArc(context, total, pending + passing, failing, '#ff5621'); + + this.setFavicon(canvas.toDataURL()); +}; + +/** Sets the current favicon by URL. */ +Title.prototype.setFavicon = function setFavicon(url) { + var current = document.head.querySelector('link[rel="icon"]'); + if (current) { + document.head.removeChild(current); + } + + var link = document.createElement('link'); + link.rel = 'icon'; + link.type = 'image/x-icon'; + link.href = url; + link.setAttribute('sizes', '32x32'); + document.head.appendChild(link); +}; + +})(); + +(function() { +var style = document.createElement('style'); +style.textContent = '/**\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nhtml, body {\n height: 100%;\n width: 100%;\n}\n\n#mocha, #subsuites {\n height: 100%;\n position: absolute;\n top: 0;\n width: 50%;\n}\n\n#mocha {\n box-sizing: border-box;\n margin: 0 !important;\n overflow-y: auto;\n padding: 60px 50px;\n right: 0;\n}\n\n#subsuites {\n -ms-flex-direction: column;\n -webkit-flex-direction: column;\n display: -ms-flexbox;\n display: -webkit-flex;\n display: flex;\n flex-direction: column;\n left: 0;\n}\n\n#subsuites .subsuite {\n border: 0;\n width: 100%;\n height: 100%;\n}\n\n#mocha .test.pass .duration {\n color: #555;\n}\n'; +document.head.appendChild(style); +})(); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["mocha.js","mocha.css","parsing.js","formatting.js","normalization.js","index.js","util.js","clisocket.js","subsuite.js","environment/compatability.js","environment/helpers.js","mocha/multirunner.js","mocha/run.js","mocha/setup.js","reporters/console.js","reporters/html.js","reporters/title.js","reporters/html.css"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC91LA;AACA;AACA;AACA;AACA;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC5FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACjJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC/CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACpMA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACvJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC7KA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACrPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ACtOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC1EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AC9HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AChGA;AACA;AACA;AACA;AACA","file":"browser.js","sourcesContent":[";(function(){\n\n// CommonJS require()\n\nfunction require(p){\n    var path = require.resolve(p)\n      , mod = require.modules[path];\n    if (!mod) throw new Error('failed to require \"' + p + '\"');\n    if (!mod.exports) {\n      mod.exports = {};\n      mod.call(mod.exports, mod, mod.exports, require.relative(path));\n    }\n    return mod.exports;\n  }\n\nrequire.modules = {};\n\nrequire.resolve = function (path){\n    var orig = path\n      , reg = path + '.js'\n      , index = path + '/index.js';\n    return require.modules[reg] && reg\n      || require.modules[index] && index\n      || orig;\n  };\n\nrequire.register = function (path, fn){\n    require.modules[path] = fn;\n  };\n\nrequire.relative = function (parent) {\n    return function(p){\n      if ('.' != p.charAt(0)) return require(p);\n\n      var path = parent.split('/')\n        , segs = p.split('/');\n      path.pop();\n\n      for (var i = 0; i < segs.length; i++) {\n        var seg = segs[i];\n        if ('..' == seg) path.pop();\n        else if ('.' != seg) path.push(seg);\n      }\n\n      return require(path.join('/'));\n    };\n  };\n\n\nrequire.register(\"browser/debug.js\", function(module, exports, require){\n\nmodule.exports = function(type){\n  return function(){\n  }\n};\n\n}); // module: browser/debug.js\n\nrequire.register(\"browser/diff.js\", function(module, exports, require){\n/* See LICENSE file for terms of use */\n\n/*\n * Text diff implementation.\n *\n * This library supports the following APIS:\n * JsDiff.diffChars: Character by character diff\n * JsDiff.diffWords: Word (as defined by \\b regex) diff which ignores whitespace\n * JsDiff.diffLines: Line based diff\n *\n * JsDiff.diffCss: Diff targeted at CSS content\n *\n * These methods are based on the implementation proposed in\n * \"An O(ND) Difference Algorithm and its Variations\" (Myers, 1986).\n * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927\n */\nvar JsDiff = (function() {\n  /*jshint maxparams: 5*/\n  function clonePath(path) {\n    return { newPos: path.newPos, components: path.components.slice(0) };\n  }\n  function removeEmpty(array) {\n    var ret = [];\n    for (var i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  }\n  function escapeHTML(s) {\n    var n = s;\n    n = n.replace(/&/g, '&amp;');\n    n = n.replace(/</g, '&lt;');\n    n = n.replace(/>/g, '&gt;');\n    n = n.replace(/\"/g, '&quot;');\n\n    return n;\n  }\n\n  var Diff = function(ignoreWhitespace) {\n    this.ignoreWhitespace = ignoreWhitespace;\n  };\n  Diff.prototype = {\n      diff: function(oldString, newString) {\n        // Handle the identity case (this is due to unrolling editLength == 0\n        if (newString === oldString) {\n          return [{ value: newString }];\n        }\n        if (!newString) {\n          return [{ value: oldString, removed: true }];\n        }\n        if (!oldString) {\n          return [{ value: newString, added: true }];\n        }\n\n        newString = this.tokenize(newString);\n        oldString = this.tokenize(oldString);\n\n        var newLen = newString.length, oldLen = oldString.length;\n        var maxEditLength = newLen + oldLen;\n        var bestPath = [{ newPos: -1, components: [] }];\n\n        // Seed editLength = 0\n        var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n        if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {\n          return bestPath[0].components;\n        }\n\n        for (var editLength = 1; editLength <= maxEditLength; editLength++) {\n          for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {\n            var basePath;\n            var addPath = bestPath[diagonalPath-1],\n                removePath = bestPath[diagonalPath+1];\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n            if (addPath) {\n              // No one else is going to attempt to use this value, clear it\n              bestPath[diagonalPath-1] = undefined;\n            }\n\n            var canAdd = addPath && addPath.newPos+1 < newLen;\n            var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n            if (!canAdd && !canRemove) {\n              bestPath[diagonalPath] = undefined;\n              continue;\n            }\n\n            // Select the diagonal that we want to branch from. We select the prior\n            // path whose position in the new string is the farthest from the origin\n            // and does not pass the bounds of the diff graph\n            if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n              basePath = clonePath(removePath);\n              this.pushComponent(basePath.components, oldString[oldPos], undefined, true);\n            } else {\n              basePath = clonePath(addPath);\n              basePath.newPos++;\n              this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);\n            }\n\n            var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);\n\n            if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {\n              return basePath.components;\n            } else {\n              bestPath[diagonalPath] = basePath;\n            }\n          }\n        }\n      },\n\n      pushComponent: function(components, value, added, removed) {\n        var last = components[components.length-1];\n        if (last && last.added === added && last.removed === removed) {\n          // We need to clone here as the component clone operation is just\n          // as shallow array clone\n          components[components.length-1] =\n            {value: this.join(last.value, value), added: added, removed: removed };\n        } else {\n          components.push({value: value, added: added, removed: removed });\n        }\n      },\n      extractCommon: function(basePath, newString, oldString, diagonalPath) {\n        var newLen = newString.length,\n            oldLen = oldString.length,\n            newPos = basePath.newPos,\n            oldPos = newPos - diagonalPath;\n        while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {\n          newPos++;\n          oldPos++;\n\n          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);\n        }\n        basePath.newPos = newPos;\n        return oldPos;\n      },\n\n      equals: function(left, right) {\n        var reWhitespace = /\\S/;\n        if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {\n          return true;\n        } else {\n          return left === right;\n        }\n      },\n      join: function(left, right) {\n        return left + right;\n      },\n      tokenize: function(value) {\n        return value;\n      }\n  };\n\n  var CharDiff = new Diff();\n\n  var WordDiff = new Diff(true);\n  var WordWithSpaceDiff = new Diff();\n  WordDiff.tokenize = WordWithSpaceDiff.tokenize = function(value) {\n    return removeEmpty(value.split(/(\\s+|\\b)/));\n  };\n\n  var CssDiff = new Diff(true);\n  CssDiff.tokenize = function(value) {\n    return removeEmpty(value.split(/([{}:;,]|\\s+)/));\n  };\n\n  var LineDiff = new Diff();\n  LineDiff.tokenize = function(value) {\n    return value.split(/^/m);\n  };\n\n  return {\n    Diff: Diff,\n\n    diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },\n    diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },\n    diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); },\n    diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },\n\n    diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },\n\n    createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {\n      var ret = [];\n\n      ret.push('Index: ' + fileName);\n      ret.push('===================================================================');\n      ret.push('--- ' + fileName + (typeof oldHeader === 'undefined' ? '' : '\\t' + oldHeader));\n      ret.push('+++ ' + fileName + (typeof newHeader === 'undefined' ? '' : '\\t' + newHeader));\n\n      var diff = LineDiff.diff(oldStr, newStr);\n      if (!diff[diff.length-1].value) {\n        diff.pop();   // Remove trailing newline add\n      }\n      diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier\n\n      function contextLines(lines) {\n        return lines.map(function(entry) { return ' ' + entry; });\n      }\n      function eofNL(curRange, i, current) {\n        var last = diff[diff.length-2],\n            isLast = i === diff.length-2,\n            isLastOfType = i === diff.length-3 && (current.added !== last.added || current.removed !== last.removed);\n\n        // Figure out if this is the last line for the given file and missing NL\n        if (!/\\n$/.test(current.value) && (isLast || isLastOfType)) {\n          curRange.push('\\\\ No newline at end of file');\n        }\n      }\n\n      var oldRangeStart = 0, newRangeStart = 0, curRange = [],\n          oldLine = 1, newLine = 1;\n      for (var i = 0; i < diff.length; i++) {\n        var current = diff[i],\n            lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n        current.lines = lines;\n\n        if (current.added || current.removed) {\n          if (!oldRangeStart) {\n            var prev = diff[i-1];\n            oldRangeStart = oldLine;\n            newRangeStart = newLine;\n\n            if (prev) {\n              curRange = contextLines(prev.lines.slice(-4));\n              oldRangeStart -= curRange.length;\n              newRangeStart -= curRange.length;\n            }\n          }\n          curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?'+':'-') + entry; }));\n          eofNL(curRange, i, current);\n\n          if (current.added) {\n            newLine += lines.length;\n          } else {\n            oldLine += lines.length;\n          }\n        } else {\n          if (oldRangeStart) {\n            // Close out any changes that have been output (or join overlapping)\n            if (lines.length <= 8 && i < diff.length-2) {\n              // Overlapping\n              curRange.push.apply(curRange, contextLines(lines));\n            } else {\n              // end the range and output\n              var contextSize = Math.min(lines.length, 4);\n              ret.push(\n                  '@@ -' + oldRangeStart + ',' + (oldLine-oldRangeStart+contextSize)\n                  + ' +' + newRangeStart + ',' + (newLine-newRangeStart+contextSize)\n                  + ' @@');\n              ret.push.apply(ret, curRange);\n              ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));\n              if (lines.length <= 4) {\n                eofNL(ret, i, current);\n              }\n\n              oldRangeStart = 0;  newRangeStart = 0; curRange = [];\n            }\n          }\n          oldLine += lines.length;\n          newLine += lines.length;\n        }\n      }\n\n      return ret.join('\\n') + '\\n';\n    },\n\n    applyPatch: function(oldStr, uniDiff) {\n      var diffstr = uniDiff.split('\\n');\n      var diff = [];\n      var remEOFNL = false,\n          addEOFNL = false;\n\n      for (var i = (diffstr[0][0]==='I'?4:0); i < diffstr.length; i++) {\n        if(diffstr[i][0] === '@') {\n          var meh = diffstr[i].split(/@@ -(\\d+),(\\d+) \\+(\\d+),(\\d+) @@/);\n          diff.unshift({\n            start:meh[3],\n            oldlength:meh[2],\n            oldlines:[],\n            newlength:meh[4],\n            newlines:[]\n          });\n        } else if(diffstr[i][0] === '+') {\n          diff[0].newlines.push(diffstr[i].substr(1));\n        } else if(diffstr[i][0] === '-') {\n          diff[0].oldlines.push(diffstr[i].substr(1));\n        } else if(diffstr[i][0] === ' ') {\n          diff[0].newlines.push(diffstr[i].substr(1));\n          diff[0].oldlines.push(diffstr[i].substr(1));\n        } else if(diffstr[i][0] === '\\\\') {\n          if (diffstr[i-1][0] === '+') {\n            remEOFNL = true;\n          } else if(diffstr[i-1][0] === '-') {\n            addEOFNL = true;\n          }\n        }\n      }\n\n      var str = oldStr.split('\\n');\n      for (var i = diff.length - 1; i >= 0; i--) {\n        var d = diff[i];\n        for (var j = 0; j < d.oldlength; j++) {\n          if(str[d.start-1+j] !== d.oldlines[j]) {\n            return false;\n          }\n        }\n        Array.prototype.splice.apply(str,[d.start-1,+d.oldlength].concat(d.newlines));\n      }\n\n      if (remEOFNL) {\n        while (!str[str.length-1]) {\n          str.pop();\n        }\n      } else if (addEOFNL) {\n        str.push('');\n      }\n      return str.join('\\n');\n    },\n\n    convertChangesToXML: function(changes){\n      var ret = [];\n      for ( var i = 0; i < changes.length; i++) {\n        var change = changes[i];\n        if (change.added) {\n          ret.push('<ins>');\n        } else if (change.removed) {\n          ret.push('<del>');\n        }\n\n        ret.push(escapeHTML(change.value));\n\n        if (change.added) {\n          ret.push('</ins>');\n        } else if (change.removed) {\n          ret.push('</del>');\n        }\n      }\n      return ret.join('');\n    },\n\n    // See: http://code.google.com/p/google-diff-match-patch/wiki/API\n    convertChangesToDMP: function(changes){\n      var ret = [], change;\n      for ( var i = 0; i < changes.length; i++) {\n        change = changes[i];\n        ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);\n      }\n      return ret;\n    }\n  };\n})();\n\nif (typeof module !== 'undefined') {\n    module.exports = JsDiff;\n}\n\n}); // module: browser/diff.js\n\nrequire.register(\"browser/events.js\", function(module, exports, require){\n\n/**\n * Module exports.\n */\n\nexports.EventEmitter = EventEmitter;\n\n/**\n * Check if `obj` is an array.\n */\n\nfunction isArray(obj) {\n  return '[object Array]' == {}.toString.call(obj);\n}\n\n/**\n * Event emitter constructor.\n *\n * @api public\n */\n\nfunction EventEmitter(){};\n\n/**\n * Adds a listener.\n *\n * @api public\n */\n\nEventEmitter.prototype.on = function (name, fn) {\n  if (!this.$events) {\n    this.$events = {};\n  }\n\n  if (!this.$events[name]) {\n    this.$events[name] = fn;\n  } else if (isArray(this.$events[name])) {\n    this.$events[name].push(fn);\n  } else {\n    this.$events[name] = [this.$events[name], fn];\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n/**\n * Adds a volatile listener.\n *\n * @api public\n */\n\nEventEmitter.prototype.once = function (name, fn) {\n  var self = this;\n\n  function on () {\n    self.removeListener(name, on);\n    fn.apply(this, arguments);\n  };\n\n  on.listener = fn;\n  this.on(name, on);\n\n  return this;\n};\n\n/**\n * Removes a listener.\n *\n * @api public\n */\n\nEventEmitter.prototype.removeListener = function (name, fn) {\n  if (this.$events && this.$events[name]) {\n    var list = this.$events[name];\n\n    if (isArray(list)) {\n      var pos = -1;\n\n      for (var i = 0, l = list.length; i < l; i++) {\n        if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {\n          pos = i;\n          break;\n        }\n      }\n\n      if (pos < 0) {\n        return this;\n      }\n\n      list.splice(pos, 1);\n\n      if (!list.length) {\n        delete this.$events[name];\n      }\n    } else if (list === fn || (list.listener && list.listener === fn)) {\n      delete this.$events[name];\n    }\n  }\n\n  return this;\n};\n\n/**\n * Removes all listeners for an event.\n *\n * @api public\n */\n\nEventEmitter.prototype.removeAllListeners = function (name) {\n  if (name === undefined) {\n    this.$events = {};\n    return this;\n  }\n\n  if (this.$events && this.$events[name]) {\n    this.$events[name] = null;\n  }\n\n  return this;\n};\n\n/**\n * Gets all listeners for a certain event.\n *\n * @api public\n */\n\nEventEmitter.prototype.listeners = function (name) {\n  if (!this.$events) {\n    this.$events = {};\n  }\n\n  if (!this.$events[name]) {\n    this.$events[name] = [];\n  }\n\n  if (!isArray(this.$events[name])) {\n    this.$events[name] = [this.$events[name]];\n  }\n\n  return this.$events[name];\n};\n\n/**\n * Emits an event.\n *\n * @api public\n */\n\nEventEmitter.prototype.emit = function (name) {\n  if (!this.$events) {\n    return false;\n  }\n\n  var handler = this.$events[name];\n\n  if (!handler) {\n    return false;\n  }\n\n  var args = [].slice.call(arguments, 1);\n\n  if ('function' == typeof handler) {\n    handler.apply(this, args);\n  } else if (isArray(handler)) {\n    var listeners = handler.slice();\n\n    for (var i = 0, l = listeners.length; i < l; i++) {\n      listeners[i].apply(this, args);\n    }\n  } else {\n    return false;\n  }\n\n  return true;\n};\n}); // module: browser/events.js\n\nrequire.register(\"browser/fs.js\", function(module, exports, require){\n\n}); // module: browser/fs.js\n\nrequire.register(\"browser/path.js\", function(module, exports, require){\n\n}); // module: browser/path.js\n\nrequire.register(\"browser/progress.js\", function(module, exports, require){\n/**\n * Expose `Progress`.\n */\n\nmodule.exports = Progress;\n\n/**\n * Initialize a new `Progress` indicator.\n */\n\nfunction Progress() {\n  this.percent = 0;\n  this.size(0);\n  this.fontSize(11);\n  this.font('helvetica, arial, sans-serif');\n}\n\n/**\n * Set progress size to `n`.\n *\n * @param {Number} n\n * @return {Progress} for chaining\n * @api public\n */\n\nProgress.prototype.size = function(n){\n  this._size = n;\n  return this;\n};\n\n/**\n * Set text to `str`.\n *\n * @param {String} str\n * @return {Progress} for chaining\n * @api public\n */\n\nProgress.prototype.text = function(str){\n  this._text = str;\n  return this;\n};\n\n/**\n * Set font size to `n`.\n *\n * @param {Number} n\n * @return {Progress} for chaining\n * @api public\n */\n\nProgress.prototype.fontSize = function(n){\n  this._fontSize = n;\n  return this;\n};\n\n/**\n * Set font `family`.\n *\n * @param {String} family\n * @return {Progress} for chaining\n */\n\nProgress.prototype.font = function(family){\n  this._font = family;\n  return this;\n};\n\n/**\n * Update percentage to `n`.\n *\n * @param {Number} n\n * @return {Progress} for chaining\n */\n\nProgress.prototype.update = function(n){\n  this.percent = n;\n  return this;\n};\n\n/**\n * Draw on `ctx`.\n *\n * @param {CanvasRenderingContext2d} ctx\n * @return {Progress} for chaining\n */\n\nProgress.prototype.draw = function(ctx){\n  try {\n    var percent = Math.min(this.percent, 100)\n      , size = this._size\n      , half = size / 2\n      , x = half\n      , y = half\n      , rad = half - 1\n      , fontSize = this._fontSize;\n  \n    ctx.font = fontSize + 'px ' + this._font;\n  \n    var angle = Math.PI * 2 * (percent / 100);\n    ctx.clearRect(0, 0, size, size);\n  \n    // outer circle\n    ctx.strokeStyle = '#9f9f9f';\n    ctx.beginPath();\n    ctx.arc(x, y, rad, 0, angle, false);\n    ctx.stroke();\n  \n    // inner circle\n    ctx.strokeStyle = '#eee';\n    ctx.beginPath();\n    ctx.arc(x, y, rad - 1, 0, angle, true);\n    ctx.stroke();\n  \n    // text\n    var text = this._text || (percent | 0) + '%'\n      , w = ctx.measureText(text).width;\n  \n    ctx.fillText(\n        text\n      , x - w / 2 + 1\n      , y + fontSize / 2 - 1);\n  } catch (ex) {} //don't fail if we can't render progress\n  return this;\n};\n\n}); // module: browser/progress.js\n\nrequire.register(\"browser/tty.js\", function(module, exports, require){\n\nexports.isatty = function(){\n  return true;\n};\n\nexports.getWindowSize = function(){\n  if ('innerHeight' in global) {\n    return [global.innerHeight, global.innerWidth];\n  } else {\n    // In a Web Worker, the DOM Window is not available.\n    return [640, 480];\n  }\n};\n\n}); // module: browser/tty.js\n\nrequire.register(\"context.js\", function(module, exports, require){\n\n/**\n * Expose `Context`.\n */\n\nmodule.exports = Context;\n\n/**\n * Initialize a new `Context`.\n *\n * @api private\n */\n\nfunction Context(){}\n\n/**\n * Set or get the context `Runnable` to `runnable`.\n *\n * @param {Runnable} runnable\n * @return {Context}\n * @api private\n */\n\nContext.prototype.runnable = function(runnable){\n  if (0 == arguments.length) return this._runnable;\n  this.test = this._runnable = runnable;\n  return this;\n};\n\n/**\n * Set test timeout `ms`.\n *\n * @param {Number} ms\n * @return {Context} self\n * @api private\n */\n\nContext.prototype.timeout = function(ms){\n  if (arguments.length === 0) return this.runnable().timeout();\n  this.runnable().timeout(ms);\n  return this;\n};\n\n/**\n * Set test timeout `enabled`.\n *\n * @param {Boolean} enabled\n * @return {Context} self\n * @api private\n */\n\nContext.prototype.enableTimeouts = function (enabled) {\n  this.runnable().enableTimeouts(enabled);\n  return this;\n};\n\n\n/**\n * Set test slowness threshold `ms`.\n *\n * @param {Number} ms\n * @return {Context} self\n * @api private\n */\n\nContext.prototype.slow = function(ms){\n  this.runnable().slow(ms);\n  return this;\n};\n\n/**\n * Inspect the context void of `._runnable`.\n *\n * @return {String}\n * @api private\n */\n\nContext.prototype.inspect = function(){\n  return JSON.stringify(this, function(key, val){\n    if ('_runnable' == key) return;\n    if ('test' == key) return;\n    return val;\n  }, 2);\n};\n\n}); // module: context.js\n\nrequire.register(\"hook.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Runnable = require('./runnable');\n\n/**\n * Expose `Hook`.\n */\n\nmodule.exports = Hook;\n\n/**\n * Initialize a new `Hook` with the given `title` and callback `fn`.\n *\n * @param {String} title\n * @param {Function} fn\n * @api private\n */\n\nfunction Hook(title, fn) {\n  Runnable.call(this, title, fn);\n  this.type = 'hook';\n}\n\n/**\n * Inherit from `Runnable.prototype`.\n */\n\nfunction F(){};\nF.prototype = Runnable.prototype;\nHook.prototype = new F;\nHook.prototype.constructor = Hook;\n\n\n/**\n * Get or set the test `err`.\n *\n * @param {Error} err\n * @return {Error}\n * @api public\n */\n\nHook.prototype.error = function(err){\n  if (0 == arguments.length) {\n    var err = this._error;\n    this._error = null;\n    return err;\n  }\n\n  this._error = err;\n};\n\n}); // module: hook.js\n\nrequire.register(\"interfaces/bdd.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Suite = require('../suite')\n  , Test = require('../test')\n  , utils = require('../utils');\n\n/**\n * BDD-style interface:\n *\n *      describe('Array', function(){\n *        describe('#indexOf()', function(){\n *          it('should return -1 when not present', function(){\n *\n *          });\n *\n *          it('should return the index when present', function(){\n *\n *          });\n *        });\n *      });\n *\n */\n\nmodule.exports = function(suite){\n  var suites = [suite];\n\n  suite.on('pre-require', function(context, file, mocha){\n\n    /**\n     * Execute before running tests.\n     */\n\n    context.before = function(name, fn){\n      suites[0].beforeAll(name, fn);\n    };\n\n    /**\n     * Execute after running tests.\n     */\n\n    context.after = function(name, fn){\n      suites[0].afterAll(name, fn);\n    };\n\n    /**\n     * Execute before each test case.\n     */\n\n    context.beforeEach = function(name, fn){\n      suites[0].beforeEach(name, fn);\n    };\n\n    /**\n     * Execute after each test case.\n     */\n\n    context.afterEach = function(name, fn){\n      suites[0].afterEach(name, fn);\n    };\n\n    /**\n     * Describe a \"suite\" with the given `title`\n     * and callback `fn` containing nested suites\n     * and/or tests.\n     */\n\n    context.describe = context.context = function(title, fn){\n      var suite = Suite.create(suites[0], title);\n      suite.file = file;\n      suites.unshift(suite);\n      fn.call(suite);\n      suites.shift();\n      return suite;\n    };\n\n    /**\n     * Pending describe.\n     */\n\n    context.xdescribe =\n    context.xcontext =\n    context.describe.skip = function(title, fn){\n      var suite = Suite.create(suites[0], title);\n      suite.pending = true;\n      suites.unshift(suite);\n      fn.call(suite);\n      suites.shift();\n    };\n\n    /**\n     * Exclusive suite.\n     */\n\n    context.describe.only = function(title, fn){\n      var suite = context.describe(title, fn);\n      mocha.grep(suite.fullTitle());\n      return suite;\n    };\n\n    /**\n     * Describe a specification or test-case\n     * with the given `title` and callback `fn`\n     * acting as a thunk.\n     */\n\n    context.it = context.specify = function(title, fn){\n      var suite = suites[0];\n      if (suite.pending) var fn = null;\n      var test = new Test(title, fn);\n      test.file = file;\n      suite.addTest(test);\n      return test;\n    };\n\n    /**\n     * Exclusive test-case.\n     */\n\n    context.it.only = function(title, fn){\n      var test = context.it(title, fn);\n      var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$';\n      mocha.grep(new RegExp(reString));\n      return test;\n    };\n\n    /**\n     * Pending test case.\n     */\n\n    context.xit =\n    context.xspecify =\n    context.it.skip = function(title){\n      context.it(title);\n    };\n  });\n};\n\n}); // module: interfaces/bdd.js\n\nrequire.register(\"interfaces/exports.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Suite = require('../suite')\n  , Test = require('../test');\n\n/**\n * TDD-style interface:\n *\n *     exports.Array = {\n *       '#indexOf()': {\n *         'should return -1 when the value is not present': function(){\n *\n *         },\n *\n *         'should return the correct index when the value is present': function(){\n *\n *         }\n *       }\n *     };\n *\n */\n\nmodule.exports = function(suite){\n  var suites = [suite];\n\n  suite.on('require', visit);\n\n  function visit(obj, file) {\n    var suite;\n    for (var key in obj) {\n      if ('function' == typeof obj[key]) {\n        var fn = obj[key];\n        switch (key) {\n          case 'before':\n            suites[0].beforeAll(fn);\n            break;\n          case 'after':\n            suites[0].afterAll(fn);\n            break;\n          case 'beforeEach':\n            suites[0].beforeEach(fn);\n            break;\n          case 'afterEach':\n            suites[0].afterEach(fn);\n            break;\n          default:\n            var test = new Test(key, fn);\n            test.file = file;\n            suites[0].addTest(test);\n        }\n      } else {\n        var suite = Suite.create(suites[0], key);\n        suites.unshift(suite);\n        visit(obj[key]);\n        suites.shift();\n      }\n    }\n  }\n};\n\n}); // module: interfaces/exports.js\n\nrequire.register(\"interfaces/index.js\", function(module, exports, require){\n\nexports.bdd = require('./bdd');\nexports.tdd = require('./tdd');\nexports.qunit = require('./qunit');\nexports.exports = require('./exports');\n\n}); // module: interfaces/index.js\n\nrequire.register(\"interfaces/qunit.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Suite = require('../suite')\n  , Test = require('../test')\n  , utils = require('../utils');\n\n/**\n * QUnit-style interface:\n *\n *     suite('Array');\n *\n *     test('#length', function(){\n *       var arr = [1,2,3];\n *       ok(arr.length == 3);\n *     });\n *\n *     test('#indexOf()', function(){\n *       var arr = [1,2,3];\n *       ok(arr.indexOf(1) == 0);\n *       ok(arr.indexOf(2) == 1);\n *       ok(arr.indexOf(3) == 2);\n *     });\n *\n *     suite('String');\n *\n *     test('#length', function(){\n *       ok('foo'.length == 3);\n *     });\n *\n */\n\nmodule.exports = function(suite){\n  var suites = [suite];\n\n  suite.on('pre-require', function(context, file, mocha){\n\n    /**\n     * Execute before running tests.\n     */\n\n    context.before = function(name, fn){\n      suites[0].beforeAll(name, fn);\n    };\n\n    /**\n     * Execute after running tests.\n     */\n\n    context.after = function(name, fn){\n      suites[0].afterAll(name, fn);\n    };\n\n    /**\n     * Execute before each test case.\n     */\n\n    context.beforeEach = function(name, fn){\n      suites[0].beforeEach(name, fn);\n    };\n\n    /**\n     * Execute after each test case.\n     */\n\n    context.afterEach = function(name, fn){\n      suites[0].afterEach(name, fn);\n    };\n\n    /**\n     * Describe a \"suite\" with the given `title`.\n     */\n\n    context.suite = function(title){\n      if (suites.length > 1) suites.shift();\n      var suite = Suite.create(suites[0], title);\n      suite.file = file;\n      suites.unshift(suite);\n      return suite;\n    };\n\n    /**\n     * Exclusive test-case.\n     */\n\n    context.suite.only = function(title, fn){\n      var suite = context.suite(title, fn);\n      mocha.grep(suite.fullTitle());\n    };\n\n    /**\n     * Describe a specification or test-case\n     * with the given `title` and callback `fn`\n     * acting as a thunk.\n     */\n\n    context.test = function(title, fn){\n      var test = new Test(title, fn);\n      test.file = file;\n      suites[0].addTest(test);\n      return test;\n    };\n\n    /**\n     * Exclusive test-case.\n     */\n\n    context.test.only = function(title, fn){\n      var test = context.test(title, fn);\n      var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$';\n      mocha.grep(new RegExp(reString));\n    };\n\n    /**\n     * Pending test case.\n     */\n\n    context.test.skip = function(title){\n      context.test(title);\n    };\n  });\n};\n\n}); // module: interfaces/qunit.js\n\nrequire.register(\"interfaces/tdd.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Suite = require('../suite')\n  , Test = require('../test')\n  , utils = require('../utils');;\n\n/**\n * TDD-style interface:\n *\n *      suite('Array', function(){\n *        suite('#indexOf()', function(){\n *          suiteSetup(function(){\n *\n *          });\n *\n *          test('should return -1 when not present', function(){\n *\n *          });\n *\n *          test('should return the index when present', function(){\n *\n *          });\n *\n *          suiteTeardown(function(){\n *\n *          });\n *        });\n *      });\n *\n */\n\nmodule.exports = function(suite){\n  var suites = [suite];\n\n  suite.on('pre-require', function(context, file, mocha){\n\n    /**\n     * Execute before each test case.\n     */\n\n    context.setup = function(name, fn){\n      suites[0].beforeEach(name, fn);\n    };\n\n    /**\n     * Execute after each test case.\n     */\n\n    context.teardown = function(name, fn){\n      suites[0].afterEach(name, fn);\n    };\n\n    /**\n     * Execute before the suite.\n     */\n\n    context.suiteSetup = function(name, fn){\n      suites[0].beforeAll(name, fn);\n    };\n\n    /**\n     * Execute after the suite.\n     */\n\n    context.suiteTeardown = function(name, fn){\n      suites[0].afterAll(name, fn);\n    };\n\n    /**\n     * Describe a \"suite\" with the given `title`\n     * and callback `fn` containing nested suites\n     * and/or tests.\n     */\n\n    context.suite = function(title, fn){\n      var suite = Suite.create(suites[0], title);\n      suite.file = file;\n      suites.unshift(suite);\n      fn.call(suite);\n      suites.shift();\n      return suite;\n    };\n\n    /**\n     * Pending suite.\n     */\n    context.suite.skip = function(title, fn) {\n      var suite = Suite.create(suites[0], title);\n      suite.pending = true;\n      suites.unshift(suite);\n      fn.call(suite);\n      suites.shift();\n    };\n\n    /**\n     * Exclusive test-case.\n     */\n\n    context.suite.only = function(title, fn){\n      var suite = context.suite(title, fn);\n      mocha.grep(suite.fullTitle());\n    };\n\n    /**\n     * Describe a specification or test-case\n     * with the given `title` and callback `fn`\n     * acting as a thunk.\n     */\n\n    context.test = function(title, fn){\n      var suite = suites[0];\n      if (suite.pending) var fn = null;\n      var test = new Test(title, fn);\n      test.file = file;\n      suite.addTest(test);\n      return test;\n    };\n\n    /**\n     * Exclusive test-case.\n     */\n\n    context.test.only = function(title, fn){\n      var test = context.test(title, fn);\n      var reString = '^' + utils.escapeRegexp(test.fullTitle()) + '$';\n      mocha.grep(new RegExp(reString));\n    };\n\n    /**\n     * Pending test case.\n     */\n\n    context.test.skip = function(title){\n      context.test(title);\n    };\n  });\n};\n\n}); // module: interfaces/tdd.js\n\nrequire.register(\"mocha.js\", function(module, exports, require){\n/*!\n * mocha\n * Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>\n * MIT Licensed\n */\n\n/**\n * Module dependencies.\n */\n\nvar path = require('browser/path')\n  , utils = require('./utils');\n\n/**\n * Expose `Mocha`.\n */\n\nexports = module.exports = Mocha;\n\n/**\n * To require local UIs and reporters when running in node.\n */\n\nif (typeof process !== 'undefined' && typeof process.cwd === 'function') {\n  var join = path.join\n    , cwd = process.cwd();\n  module.paths.push(cwd, join(cwd, 'node_modules'));\n}\n\n/**\n * Expose internals.\n */\n\nexports.utils = utils;\nexports.interfaces = require('./interfaces');\nexports.reporters = require('./reporters');\nexports.Runnable = require('./runnable');\nexports.Context = require('./context');\nexports.Runner = require('./runner');\nexports.Suite = require('./suite');\nexports.Hook = require('./hook');\nexports.Test = require('./test');\n\n/**\n * Return image `name` path.\n *\n * @param {String} name\n * @return {String}\n * @api private\n */\n\nfunction image(name) {\n  return __dirname + '/../images/' + name + '.png';\n}\n\n/**\n * Setup mocha with `options`.\n *\n * Options:\n *\n *   - `ui` name \"bdd\", \"tdd\", \"exports\" etc\n *   - `reporter` reporter instance, defaults to `mocha.reporters.spec`\n *   - `globals` array of accepted globals\n *   - `timeout` timeout in milliseconds\n *   - `bail` bail on the first test failure\n *   - `slow` milliseconds to wait before considering a test slow\n *   - `ignoreLeaks` ignore global leaks\n *   - `grep` string or regexp to filter tests with\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Mocha(options) {\n  options = options || {};\n  this.files = [];\n  this.options = options;\n  this.grep(options.grep);\n  this.suite = new exports.Suite('', new exports.Context);\n  this.ui(options.ui);\n  this.bail(options.bail);\n  this.reporter(options.reporter);\n  if (null != options.timeout) this.timeout(options.timeout);\n  this.useColors(options.useColors)\n  if (options.enableTimeouts !== null) this.enableTimeouts(options.enableTimeouts);\n  if (options.slow) this.slow(options.slow);\n\n  this.suite.on('pre-require', function (context) {\n    exports.afterEach = context.afterEach || context.teardown;\n    exports.after = context.after || context.suiteTeardown;\n    exports.beforeEach = context.beforeEach || context.setup;\n    exports.before = context.before || context.suiteSetup;\n    exports.describe = context.describe || context.suite;\n    exports.it = context.it || context.test;\n    exports.setup = context.setup || context.beforeEach;\n    exports.suiteSetup = context.suiteSetup || context.before;\n    exports.suiteTeardown = context.suiteTeardown || context.after;\n    exports.suite = context.suite || context.describe;\n    exports.teardown = context.teardown || context.afterEach;\n    exports.test = context.test || context.it;\n  });\n}\n\n/**\n * Enable or disable bailing on the first failure.\n *\n * @param {Boolean} [bail]\n * @api public\n */\n\nMocha.prototype.bail = function(bail){\n  if (0 == arguments.length) bail = true;\n  this.suite.bail(bail);\n  return this;\n};\n\n/**\n * Add test `file`.\n *\n * @param {String} file\n * @api public\n */\n\nMocha.prototype.addFile = function(file){\n  this.files.push(file);\n  return this;\n};\n\n/**\n * Set reporter to `reporter`, defaults to \"spec\".\n *\n * @param {String|Function} reporter name or constructor\n * @api public\n */\n\nMocha.prototype.reporter = function(reporter){\n  if ('function' == typeof reporter) {\n    this._reporter = reporter;\n  } else {\n    reporter = reporter || 'spec';\n    var _reporter;\n    try { _reporter = require('./reporters/' + reporter); } catch (err) {};\n    if (!_reporter) try { _reporter = require(reporter); } catch (err) {};\n    if (!_reporter && reporter === 'teamcity')\n      console.warn('The Teamcity reporter was moved to a package named ' +\n        'mocha-teamcity-reporter ' +\n        '(https://npmjs.org/package/mocha-teamcity-reporter).');\n    if (!_reporter) throw new Error('invalid reporter \"' + reporter + '\"');\n    this._reporter = _reporter;\n  }\n  return this;\n};\n\n/**\n * Set test UI `name`, defaults to \"bdd\".\n *\n * @param {String} bdd\n * @api public\n */\n\nMocha.prototype.ui = function(name){\n  name = name || 'bdd';\n  this._ui = exports.interfaces[name];\n  if (!this._ui) try { this._ui = require(name); } catch (err) {};\n  if (!this._ui) throw new Error('invalid interface \"' + name + '\"');\n  this._ui = this._ui(this.suite);\n  return this;\n};\n\n/**\n * Load registered files.\n *\n * @api private\n */\n\nMocha.prototype.loadFiles = function(fn){\n  var self = this;\n  var suite = this.suite;\n  var pending = this.files.length;\n  this.files.forEach(function(file){\n    file = path.resolve(file);\n    suite.emit('pre-require', global, file, self);\n    suite.emit('require', require(file), file, self);\n    suite.emit('post-require', global, file, self);\n    --pending || (fn && fn());\n  });\n};\n\n/**\n * Enable growl support.\n *\n * @api private\n */\n\nMocha.prototype._growl = function(runner, reporter) {\n  var notify = require('growl');\n\n  runner.on('end', function(){\n    var stats = reporter.stats;\n    if (stats.failures) {\n      var msg = stats.failures + ' of ' + runner.total + ' tests failed';\n      notify(msg, { name: 'mocha', title: 'Failed', image: image('error') });\n    } else {\n      notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {\n          name: 'mocha'\n        , title: 'Passed'\n        , image: image('ok')\n      });\n    }\n  });\n};\n\n/**\n * Add regexp to grep, if `re` is a string it is escaped.\n *\n * @param {RegExp|String} re\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.grep = function(re){\n  this.options.grep = 'string' == typeof re\n    ? new RegExp(utils.escapeRegexp(re))\n    : re;\n  return this;\n};\n\n/**\n * Invert `.grep()` matches.\n *\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.invert = function(){\n  this.options.invert = true;\n  return this;\n};\n\n/**\n * Ignore global leaks.\n *\n * @param {Boolean} ignore\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.ignoreLeaks = function(ignore){\n  this.options.ignoreLeaks = !!ignore;\n  return this;\n};\n\n/**\n * Enable global leak checking.\n *\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.checkLeaks = function(){\n  this.options.ignoreLeaks = false;\n  return this;\n};\n\n/**\n * Enable growl support.\n *\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.growl = function(){\n  this.options.growl = true;\n  return this;\n};\n\n/**\n * Ignore `globals` array or string.\n *\n * @param {Array|String} globals\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.globals = function(globals){\n  this.options.globals = (this.options.globals || []).concat(globals);\n  return this;\n};\n\n/**\n * Emit color output.\n *\n * @param {Boolean} colors\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.useColors = function(colors){\n  this.options.useColors = arguments.length && colors != undefined\n    ? colors\n    : true;\n  return this;\n};\n\n/**\n * Use inline diffs rather than +/-.\n *\n * @param {Boolean} inlineDiffs\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.useInlineDiffs = function(inlineDiffs) {\n  this.options.useInlineDiffs = arguments.length && inlineDiffs != undefined\n  ? inlineDiffs\n  : false;\n  return this;\n};\n\n/**\n * Set the timeout in milliseconds.\n *\n * @param {Number} timeout\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.timeout = function(timeout){\n  this.suite.timeout(timeout);\n  return this;\n};\n\n/**\n * Set slowness threshold in milliseconds.\n *\n * @param {Number} slow\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.slow = function(slow){\n  this.suite.slow(slow);\n  return this;\n};\n\n/**\n * Enable timeouts.\n *\n * @param {Boolean} enabled\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.enableTimeouts = function(enabled) {\n  this.suite.enableTimeouts(arguments.length && enabled !== undefined\n    ? enabled\n    : true);\n  return this\n};\n\n/**\n * Makes all tests async (accepting a callback)\n *\n * @return {Mocha}\n * @api public\n */\n\nMocha.prototype.asyncOnly = function(){\n  this.options.asyncOnly = true;\n  return this;\n};\n\n/**\n * Run tests and invoke `fn()` when complete.\n *\n * @param {Function} fn\n * @return {Runner}\n * @api public\n */\n\nMocha.prototype.run = function(fn){\n  if (this.files.length) this.loadFiles();\n  var suite = this.suite;\n  var options = this.options;\n  options.files = this.files;\n  var runner = new exports.Runner(suite);\n  var reporter = new this._reporter(runner, options);\n  runner.ignoreLeaks = false !== options.ignoreLeaks;\n  runner.asyncOnly = options.asyncOnly;\n  if (options.grep) runner.grep(options.grep, options.invert);\n  if (options.globals) runner.globals(options.globals);\n  if (options.growl) this._growl(runner, reporter);\n  exports.reporters.Base.useColors = options.useColors;\n  exports.reporters.Base.inlineDiffs = options.useInlineDiffs;\n  return runner.run(fn);\n};\n\n}); // module: mocha.js\n\nrequire.register(\"ms.js\", function(module, exports, require){\n/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} options\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options){\n  options = options || {};\n  if ('string' == typeof val) return parse(val);\n  return options.long ? longFormat(val) : shortFormat(val);\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  var match = /^((?:\\d+)?\\.?\\d+) *(ms|seconds?|s|minutes?|m|hours?|h|days?|d|years?|y)?$/i.exec(str);\n  if (!match) return;\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 's':\n      return n * s;\n    case 'ms':\n      return n;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction shortFormat(ms) {\n  if (ms >= d) return Math.round(ms / d) + 'd';\n  if (ms >= h) return Math.round(ms / h) + 'h';\n  if (ms >= m) return Math.round(ms / m) + 'm';\n  if (ms >= s) return Math.round(ms / s) + 's';\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction longFormat(ms) {\n  return plural(ms, d, 'day')\n    || plural(ms, h, 'hour')\n    || plural(ms, m, 'minute')\n    || plural(ms, s, 'second')\n    || ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) return;\n  if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name;\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n\n}); // module: ms.js\n\nrequire.register(\"reporters/base.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar tty = require('browser/tty')\n  , diff = require('browser/diff')\n  , ms = require('../ms')\n  , utils = require('../utils');\n\n/**\n * Save timer references to avoid Sinon interfering (see GH-237).\n */\n\nvar Date = global.Date\n  , setTimeout = global.setTimeout\n  , setInterval = global.setInterval\n  , clearTimeout = global.clearTimeout\n  , clearInterval = global.clearInterval;\n\n/**\n * Check if both stdio streams are associated with a tty.\n */\n\nvar isatty = tty.isatty(1) && tty.isatty(2);\n\n/**\n * Expose `Base`.\n */\n\nexports = module.exports = Base;\n\n/**\n * Enable coloring by default.\n */\n\nexports.useColors = isatty || (process.env.MOCHA_COLORS !== undefined);\n\n/**\n * Inline diffs instead of +/-\n */\n\nexports.inlineDiffs = false;\n\n/**\n * Default color map.\n */\n\nexports.colors = {\n    'pass': 90\n  , 'fail': 31\n  , 'bright pass': 92\n  , 'bright fail': 91\n  , 'bright yellow': 93\n  , 'pending': 36\n  , 'suite': 0\n  , 'error title': 0\n  , 'error message': 31\n  , 'error stack': 90\n  , 'checkmark': 32\n  , 'fast': 90\n  , 'medium': 33\n  , 'slow': 31\n  , 'green': 32\n  , 'light': 90\n  , 'diff gutter': 90\n  , 'diff added': 42\n  , 'diff removed': 41\n};\n\n/**\n * Default symbol map.\n */\n\nexports.symbols = {\n  ok: '✓',\n  err: '✖',\n  dot: '․'\n};\n\n// With node.js on Windows: use symbols available in terminal default fonts\nif ('win32' == process.platform) {\n  exports.symbols.ok = '\\u221A';\n  exports.symbols.err = '\\u00D7';\n  exports.symbols.dot = '.';\n}\n\n/**\n * Color `str` with the given `type`,\n * allowing colors to be disabled,\n * as well as user-defined color\n * schemes.\n *\n * @param {String} type\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nvar color = exports.color = function(type, str) {\n  if (!exports.useColors) return str;\n  return '\\u001b[' + exports.colors[type] + 'm' + str + '\\u001b[0m';\n};\n\n/**\n * Expose term window size, with some\n * defaults for when stderr is not a tty.\n */\n\nexports.window = {\n  width: isatty\n    ? process.stdout.getWindowSize\n      ? process.stdout.getWindowSize(1)[0]\n      : tty.getWindowSize()[1]\n    : 75\n};\n\n/**\n * Expose some basic cursor interactions\n * that are common among reporters.\n */\n\nexports.cursor = {\n  hide: function(){\n    isatty && process.stdout.write('\\u001b[?25l');\n  },\n\n  show: function(){\n    isatty && process.stdout.write('\\u001b[?25h');\n  },\n\n  deleteLine: function(){\n    isatty && process.stdout.write('\\u001b[2K');\n  },\n\n  beginningOfLine: function(){\n    isatty && process.stdout.write('\\u001b[0G');\n  },\n\n  CR: function(){\n    if (isatty) {\n      exports.cursor.deleteLine();\n      exports.cursor.beginningOfLine();\n    } else {\n      process.stdout.write('\\r');\n    }\n  }\n};\n\n/**\n * Outut the given `failures` as a list.\n *\n * @param {Array} failures\n * @api public\n */\n\nexports.list = function(failures){\n  console.error();\n  failures.forEach(function(test, i){\n    // format\n    var fmt = color('error title', '  %s) %s:\\n')\n      + color('error message', '     %s')\n      + color('error stack', '\\n%s\\n');\n\n    // msg\n    var err = test.err\n      , message = err.message || ''\n      , stack = err.stack || message\n      , index = stack.indexOf(message) + message.length\n      , msg = stack.slice(0, index)\n      , actual = err.actual\n      , expected = err.expected\n      , escape = true;\n\n    // uncaught\n    if (err.uncaught) {\n      msg = 'Uncaught ' + msg;\n    }\n\n    // explicitly show diff\n    if (err.showDiff && sameType(actual, expected)) {\n      escape = false;\n      err.actual = actual = utils.stringify(actual);\n      err.expected = expected = utils.stringify(expected);\n    }\n\n    // actual / expected diff\n    if ('string' == typeof actual && 'string' == typeof expected) {\n      fmt = color('error title', '  %s) %s:\\n%s') + color('error stack', '\\n%s\\n');\n      var match = message.match(/^([^:]+): expected/);\n      msg = '\\n      ' + color('error message', match ? match[1] : msg);\n\n      if (exports.inlineDiffs) {\n        msg += inlineDiff(err, escape);\n      } else {\n        msg += unifiedDiff(err, escape);\n      }\n    }\n\n    // indent stack trace without msg\n    stack = stack.slice(index ? index + 1 : index)\n      .replace(/^/gm, '  ');\n\n    console.error(fmt, (i + 1), test.fullTitle(), msg, stack);\n  });\n};\n\n/**\n * Initialize a new `Base` reporter.\n *\n * All other reporters generally\n * inherit from this reporter, providing\n * stats such as test duration, number\n * of tests passed / failed etc.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Base(runner) {\n  var self = this\n    , stats = this.stats = { suites: 0, tests: 0, passes: 0, pending: 0, failures: 0 }\n    , failures = this.failures = [];\n\n  if (!runner) return;\n  this.runner = runner;\n\n  runner.stats = stats;\n\n  runner.on('start', function(){\n    stats.start = new Date;\n  });\n\n  runner.on('suite', function(suite){\n    stats.suites = stats.suites || 0;\n    suite.root || stats.suites++;\n  });\n\n  runner.on('test end', function(test){\n    stats.tests = stats.tests || 0;\n    stats.tests++;\n  });\n\n  runner.on('pass', function(test){\n    stats.passes = stats.passes || 0;\n\n    var medium = test.slow() / 2;\n    test.speed = test.duration > test.slow()\n      ? 'slow'\n      : test.duration > medium\n        ? 'medium'\n        : 'fast';\n\n    stats.passes++;\n  });\n\n  runner.on('fail', function(test, err){\n    stats.failures = stats.failures || 0;\n    stats.failures++;\n    test.err = err;\n    failures.push(test);\n  });\n\n  runner.on('end', function(){\n    stats.end = new Date;\n    stats.duration = new Date - stats.start;\n  });\n\n  runner.on('pending', function(){\n    stats.pending++;\n  });\n}\n\n/**\n * Output common epilogue used by many of\n * the bundled reporters.\n *\n * @api public\n */\n\nBase.prototype.epilogue = function(){\n  var stats = this.stats;\n  var tests;\n  var fmt;\n\n  console.log();\n\n  // passes\n  fmt = color('bright pass', ' ')\n    + color('green', ' %d passing')\n    + color('light', ' (%s)');\n\n  console.log(fmt,\n    stats.passes || 0,\n    ms(stats.duration));\n\n  // pending\n  if (stats.pending) {\n    fmt = color('pending', ' ')\n      + color('pending', ' %d pending');\n\n    console.log(fmt, stats.pending);\n  }\n\n  // failures\n  if (stats.failures) {\n    fmt = color('fail', '  %d failing');\n\n    console.error(fmt,\n      stats.failures);\n\n    Base.list(this.failures);\n    console.error();\n  }\n\n  console.log();\n};\n\n/**\n * Pad the given `str` to `len`.\n *\n * @param {String} str\n * @param {String} len\n * @return {String}\n * @api private\n */\n\nfunction pad(str, len) {\n  str = String(str);\n  return Array(len - str.length + 1).join(' ') + str;\n}\n\n\n/**\n * Returns an inline diff between 2 strings with coloured ANSI output\n *\n * @param {Error} Error with actual/expected\n * @return {String} Diff\n * @api private\n */\n\nfunction inlineDiff(err, escape) {\n  var msg = errorDiff(err, 'WordsWithSpace', escape);\n\n  // linenos\n  var lines = msg.split('\\n');\n  if (lines.length > 4) {\n    var width = String(lines.length).length;\n    msg = lines.map(function(str, i){\n      return pad(++i, width) + ' |' + ' ' + str;\n    }).join('\\n');\n  }\n\n  // legend\n  msg = '\\n'\n    + color('diff removed', 'actual')\n    + ' '\n    + color('diff added', 'expected')\n    + '\\n\\n'\n    + msg\n    + '\\n';\n\n  // indent\n  msg = msg.replace(/^/gm, '      ');\n  return msg;\n}\n\n/**\n * Returns a unified diff between 2 strings\n *\n * @param {Error} Error with actual/expected\n * @return {String} Diff\n * @api private\n */\n\nfunction unifiedDiff(err, escape) {\n  var indent = '      ';\n  function cleanUp(line) {\n    if (escape) {\n      line = escapeInvisibles(line);\n    }\n    if (line[0] === '+') return indent + colorLines('diff added', line);\n    if (line[0] === '-') return indent + colorLines('diff removed', line);\n    if (line.match(/\\@\\@/)) return null;\n    if (line.match(/\\\\ No newline/)) return null;\n    else return indent + line;\n  }\n  function notBlank(line) {\n    return line != null;\n  }\n  msg = diff.createPatch('string', err.actual, err.expected);\n  var lines = msg.split('\\n').splice(4);\n  return '\\n      '\n         + colorLines('diff added',   '+ expected') + ' '\n         + colorLines('diff removed', '- actual')\n         + '\\n\\n'\n         + lines.map(cleanUp).filter(notBlank).join('\\n');\n}\n\n/**\n * Return a character diff for `err`.\n *\n * @param {Error} err\n * @return {String}\n * @api private\n */\n\nfunction errorDiff(err, type, escape) {\n  var actual   = escape ? escapeInvisibles(err.actual)   : err.actual;\n  var expected = escape ? escapeInvisibles(err.expected) : err.expected;\n  return diff['diff' + type](actual, expected).map(function(str){\n    if (str.added) return colorLines('diff added', str.value);\n    if (str.removed) return colorLines('diff removed', str.value);\n    return str.value;\n  }).join('');\n}\n\n/**\n * Returns a string with all invisible characters in plain text\n *\n * @param {String} line\n * @return {String}\n * @api private\n */\nfunction escapeInvisibles(line) {\n    return line.replace(/\\t/g, '<tab>')\n               .replace(/\\r/g, '<CR>')\n               .replace(/\\n/g, '<LF>\\n');\n}\n\n/**\n * Color lines for `str`, using the color `name`.\n *\n * @param {String} name\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nfunction colorLines(name, str) {\n  return str.split('\\n').map(function(str){\n    return color(name, str);\n  }).join('\\n');\n}\n\n/**\n * Check that a / b have the same type.\n *\n * @param {Object} a\n * @param {Object} b\n * @return {Boolean}\n * @api private\n */\n\nfunction sameType(a, b) {\n  a = Object.prototype.toString.call(a);\n  b = Object.prototype.toString.call(b);\n  return a == b;\n}\n\n}); // module: reporters/base.js\n\nrequire.register(\"reporters/doc.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , utils = require('../utils');\n\n/**\n * Expose `Doc`.\n */\n\nexports = module.exports = Doc;\n\n/**\n * Initialize a new `Doc` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Doc(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , total = runner.total\n    , indents = 2;\n\n  function indent() {\n    return Array(indents).join('  ');\n  }\n\n  runner.on('suite', function(suite){\n    if (suite.root) return;\n    ++indents;\n    console.log('%s<section class=\"suite\">', indent());\n    ++indents;\n    console.log('%s<h1>%s</h1>', indent(), utils.escape(suite.title));\n    console.log('%s<dl>', indent());\n  });\n\n  runner.on('suite end', function(suite){\n    if (suite.root) return;\n    console.log('%s</dl>', indent());\n    --indents;\n    console.log('%s</section>', indent());\n    --indents;\n  });\n\n  runner.on('pass', function(test){\n    console.log('%s  <dt>%s</dt>', indent(), utils.escape(test.title));\n    var code = utils.escape(utils.clean(test.fn.toString()));\n    console.log('%s  <dd><pre><code>%s</code></pre></dd>', indent(), code);\n  });\n\n  runner.on('fail', function(test, err){\n    console.log('%s  <dt class=\"error\">%s</dt>', indent(), utils.escape(test.title));\n    var code = utils.escape(utils.clean(test.fn.toString()));\n    console.log('%s  <dd class=\"error\"><pre><code>%s</code></pre></dd>', indent(), code);\n    console.log('%s  <dd class=\"error\">%s</dd>', indent(), utils.escape(err));\n  });\n}\n\n}); // module: reporters/doc.js\n\nrequire.register(\"reporters/dot.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , color = Base.color;\n\n/**\n * Expose `Dot`.\n */\n\nexports = module.exports = Dot;\n\n/**\n * Initialize a new `Dot` matrix test reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Dot(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , width = Base.window.width * .75 | 0\n    , n = -1;\n\n  runner.on('start', function(){\n    process.stdout.write('\\n  ');\n  });\n\n  runner.on('pending', function(test){\n    if (++n % width == 0) process.stdout.write('\\n  ');\n    process.stdout.write(color('pending', Base.symbols.dot));\n  });\n\n  runner.on('pass', function(test){\n    if (++n % width == 0) process.stdout.write('\\n  ');\n    if ('slow' == test.speed) {\n      process.stdout.write(color('bright yellow', Base.symbols.dot));\n    } else {\n      process.stdout.write(color(test.speed, Base.symbols.dot));\n    }\n  });\n\n  runner.on('fail', function(test, err){\n    if (++n % width == 0) process.stdout.write('\\n  ');\n    process.stdout.write(color('fail', Base.symbols.dot));\n  });\n\n  runner.on('end', function(){\n    console.log();\n    self.epilogue();\n  });\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nDot.prototype = new F;\nDot.prototype.constructor = Dot;\n\n\n}); // module: reporters/dot.js\n\nrequire.register(\"reporters/html-cov.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar JSONCov = require('./json-cov')\n  , fs = require('browser/fs');\n\n/**\n * Expose `HTMLCov`.\n */\n\nexports = module.exports = HTMLCov;\n\n/**\n * Initialize a new `JsCoverage` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction HTMLCov(runner) {\n  var jade = require('jade')\n    , file = __dirname + '/templates/coverage.jade'\n    , str = fs.readFileSync(file, 'utf8')\n    , fn = jade.compile(str, { filename: file })\n    , self = this;\n\n  JSONCov.call(this, runner, false);\n\n  runner.on('end', function(){\n    process.stdout.write(fn({\n        cov: self.cov\n      , coverageClass: coverageClass\n    }));\n  });\n}\n\n/**\n * Return coverage class for `n`.\n *\n * @return {String}\n * @api private\n */\n\nfunction coverageClass(n) {\n  if (n >= 75) return 'high';\n  if (n >= 50) return 'medium';\n  if (n >= 25) return 'low';\n  return 'terrible';\n}\n}); // module: reporters/html-cov.js\n\nrequire.register(\"reporters/html.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , utils = require('../utils')\n  , Progress = require('../browser/progress')\n  , escape = utils.escape;\n\n/**\n * Save timer references to avoid Sinon interfering (see GH-237).\n */\n\nvar Date = global.Date\n  , setTimeout = global.setTimeout\n  , setInterval = global.setInterval\n  , clearTimeout = global.clearTimeout\n  , clearInterval = global.clearInterval;\n\n/**\n * Expose `HTML`.\n */\n\nexports = module.exports = HTML;\n\n/**\n * Stats template.\n */\n\nvar statsTemplate = '<ul id=\"mocha-stats\">'\n  + '<li class=\"progress\"><canvas width=\"40\" height=\"40\"></canvas></li>'\n  + '<li class=\"passes\"><a href=\"#\">passes:</a> <em>0</em></li>'\n  + '<li class=\"failures\"><a href=\"#\">failures:</a> <em>0</em></li>'\n  + '<li class=\"duration\">duration: <em>0</em>s</li>'\n  + '</ul>';\n\n/**\n * Initialize a new `HTML` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction HTML(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , total = runner.total\n    , stat = fragment(statsTemplate)\n    , items = stat.getElementsByTagName('li')\n    , passes = items[1].getElementsByTagName('em')[0]\n    , passesLink = items[1].getElementsByTagName('a')[0]\n    , failures = items[2].getElementsByTagName('em')[0]\n    , failuresLink = items[2].getElementsByTagName('a')[0]\n    , duration = items[3].getElementsByTagName('em')[0]\n    , canvas = stat.getElementsByTagName('canvas')[0]\n    , report = fragment('<ul id=\"mocha-report\"></ul>')\n    , stack = [report]\n    , progress\n    , ctx\n    , root = document.getElementById('mocha');\n\n  if (canvas.getContext) {\n    var ratio = window.devicePixelRatio || 1;\n    canvas.style.width = canvas.width;\n    canvas.style.height = canvas.height;\n    canvas.width *= ratio;\n    canvas.height *= ratio;\n    ctx = canvas.getContext('2d');\n    ctx.scale(ratio, ratio);\n    progress = new Progress;\n  }\n\n  if (!root) return error('#mocha div missing, add it to your document');\n\n  // pass toggle\n  on(passesLink, 'click', function(){\n    unhide();\n    var name = /pass/.test(report.className) ? '' : ' pass';\n    report.className = report.className.replace(/fail|pass/g, '') + name;\n    if (report.className.trim()) hideSuitesWithout('test pass');\n  });\n\n  // failure toggle\n  on(failuresLink, 'click', function(){\n    unhide();\n    var name = /fail/.test(report.className) ? '' : ' fail';\n    report.className = report.className.replace(/fail|pass/g, '') + name;\n    if (report.className.trim()) hideSuitesWithout('test fail');\n  });\n\n  root.appendChild(stat);\n  root.appendChild(report);\n\n  if (progress) progress.size(40);\n\n  runner.on('suite', function(suite){\n    if (suite.root) return;\n\n    // suite\n    var url = self.suiteURL(suite);\n    var el = fragment('<li class=\"suite\"><h1><a href=\"%s\">%s</a></h1></li>', url, escape(suite.title));\n\n    // container\n    stack[0].appendChild(el);\n    stack.unshift(document.createElement('ul'));\n    el.appendChild(stack[0]);\n  });\n\n  runner.on('suite end', function(suite){\n    if (suite.root) return;\n    stack.shift();\n  });\n\n  runner.on('fail', function(test, err){\n    if ('hook' == test.type) runner.emit('test end', test);\n  });\n\n  runner.on('test end', function(test){\n    // TODO: add to stats\n    var percent = stats.tests / this.total * 100 | 0;\n    if (progress) progress.update(percent).draw(ctx);\n\n    // update stats\n    var ms = new Date - stats.start;\n    text(passes, stats.passes);\n    text(failures, stats.failures);\n    text(duration, (ms / 1000).toFixed(2));\n\n    // test\n    if ('passed' == test.state) {\n      var url = self.testURL(test);\n      var el = fragment('<li class=\"test pass %e\"><h2>%e<span class=\"duration\">%ems</span> <a href=\"%s\" class=\"replay\">‣</a></h2></li>', test.speed, test.title, test.duration, url);\n    } else if (test.pending) {\n      var el = fragment('<li class=\"test pass pending\"><h2>%e</h2></li>', test.title);\n    } else {\n      var el = fragment('<li class=\"test fail\"><h2>%e <a href=\"?grep=%e\" class=\"replay\">‣</a></h2></li>', test.title, encodeURIComponent(test.fullTitle()));\n      var str = test.err.stack || test.err.toString();\n\n      // FF / Opera do not add the message\n      if (!~str.indexOf(test.err.message)) {\n        str = test.err.message + '\\n' + str;\n      }\n\n      // <=IE7 stringifies to [Object Error]. Since it can be overloaded, we\n      // check for the result of the stringifying.\n      if ('[object Error]' == str) str = test.err.message;\n\n      // Safari doesn't give you a stack. Let's at least provide a source line.\n      if (!test.err.stack && test.err.sourceURL && test.err.line !== undefined) {\n        str += \"\\n(\" + test.err.sourceURL + \":\" + test.err.line + \")\";\n      }\n\n      el.appendChild(fragment('<pre class=\"error\">%e</pre>', str));\n    }\n\n    // toggle code\n    // TODO: defer\n    if (!test.pending) {\n      var h2 = el.getElementsByTagName('h2')[0];\n\n      on(h2, 'click', function(){\n        pre.style.display = 'none' == pre.style.display\n          ? 'block'\n          : 'none';\n      });\n\n      var pre = fragment('<pre><code>%e</code></pre>', utils.clean(test.fn.toString()));\n      el.appendChild(pre);\n      pre.style.display = 'none';\n    }\n\n    // Don't call .appendChild if #mocha-report was already .shift()'ed off the stack.\n    if (stack[0]) stack[0].appendChild(el);\n  });\n}\n\n/**\n * Provide suite URL\n *\n * @param {Object} [suite]\n */\n\nHTML.prototype.suiteURL = function(suite){\n  return '?grep=' + encodeURIComponent(suite.fullTitle());\n};\n\n/**\n * Provide test URL\n *\n * @param {Object} [test]\n */\n\nHTML.prototype.testURL = function(test){\n  return '?grep=' + encodeURIComponent(test.fullTitle());\n};\n\n/**\n * Display error `msg`.\n */\n\nfunction error(msg) {\n  document.body.appendChild(fragment('<div id=\"mocha-error\">%s</div>', msg));\n}\n\n/**\n * Return a DOM fragment from `html`.\n */\n\nfunction fragment(html) {\n  var args = arguments\n    , div = document.createElement('div')\n    , i = 1;\n\n  div.innerHTML = html.replace(/%([se])/g, function(_, type){\n    switch (type) {\n      case 's': return String(args[i++]);\n      case 'e': return escape(args[i++]);\n    }\n  });\n\n  return div.firstChild;\n}\n\n/**\n * Check for suites that do not have elements\n * with `classname`, and hide them.\n */\n\nfunction hideSuitesWithout(classname) {\n  var suites = document.getElementsByClassName('suite');\n  for (var i = 0; i < suites.length; i++) {\n    var els = suites[i].getElementsByClassName(classname);\n    if (0 == els.length) suites[i].className += ' hidden';\n  }\n}\n\n/**\n * Unhide .hidden suites.\n */\n\nfunction unhide() {\n  var els = document.getElementsByClassName('suite hidden');\n  for (var i = 0; i < els.length; ++i) {\n    els[i].className = els[i].className.replace('suite hidden', 'suite');\n  }\n}\n\n/**\n * Set `el` text to `str`.\n */\n\nfunction text(el, str) {\n  if (el.textContent) {\n    el.textContent = str;\n  } else {\n    el.innerText = str;\n  }\n}\n\n/**\n * Listen on `event` with callback `fn`.\n */\n\nfunction on(el, event, fn) {\n  if (el.addEventListener) {\n    el.addEventListener(event, fn, false);\n  } else {\n    el.attachEvent('on' + event, fn);\n  }\n}\n\n}); // module: reporters/html.js\n\nrequire.register(\"reporters/index.js\", function(module, exports, require){\n\nexports.Base = require('./base');\nexports.Dot = require('./dot');\nexports.Doc = require('./doc');\nexports.TAP = require('./tap');\nexports.JSON = require('./json');\nexports.HTML = require('./html');\nexports.List = require('./list');\nexports.Min = require('./min');\nexports.Spec = require('./spec');\nexports.Nyan = require('./nyan');\nexports.XUnit = require('./xunit');\nexports.Markdown = require('./markdown');\nexports.Progress = require('./progress');\nexports.Landing = require('./landing');\nexports.JSONCov = require('./json-cov');\nexports.HTMLCov = require('./html-cov');\nexports.JSONStream = require('./json-stream');\n\n}); // module: reporters/index.js\n\nrequire.register(\"reporters/json-cov.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base');\n\n/**\n * Expose `JSONCov`.\n */\n\nexports = module.exports = JSONCov;\n\n/**\n * Initialize a new `JsCoverage` reporter.\n *\n * @param {Runner} runner\n * @param {Boolean} output\n * @api public\n */\n\nfunction JSONCov(runner, output) {\n  var self = this\n    , output = 1 == arguments.length ? true : output;\n\n  Base.call(this, runner);\n\n  var tests = []\n    , failures = []\n    , passes = [];\n\n  runner.on('test end', function(test){\n    tests.push(test);\n  });\n\n  runner.on('pass', function(test){\n    passes.push(test);\n  });\n\n  runner.on('fail', function(test){\n    failures.push(test);\n  });\n\n  runner.on('end', function(){\n    var cov = global._$jscoverage || {};\n    var result = self.cov = map(cov);\n    result.stats = self.stats;\n    result.tests = tests.map(clean);\n    result.failures = failures.map(clean);\n    result.passes = passes.map(clean);\n    if (!output) return;\n    process.stdout.write(JSON.stringify(result, null, 2 ));\n  });\n}\n\n/**\n * Map jscoverage data to a JSON structure\n * suitable for reporting.\n *\n * @param {Object} cov\n * @return {Object}\n * @api private\n */\n\nfunction map(cov) {\n  var ret = {\n      instrumentation: 'node-jscoverage'\n    , sloc: 0\n    , hits: 0\n    , misses: 0\n    , coverage: 0\n    , files: []\n  };\n\n  for (var filename in cov) {\n    var data = coverage(filename, cov[filename]);\n    ret.files.push(data);\n    ret.hits += data.hits;\n    ret.misses += data.misses;\n    ret.sloc += data.sloc;\n  }\n\n  ret.files.sort(function(a, b) {\n    return a.filename.localeCompare(b.filename);\n  });\n\n  if (ret.sloc > 0) {\n    ret.coverage = (ret.hits / ret.sloc) * 100;\n  }\n\n  return ret;\n};\n\n/**\n * Map jscoverage data for a single source file\n * to a JSON structure suitable for reporting.\n *\n * @param {String} filename name of the source file\n * @param {Object} data jscoverage coverage data\n * @return {Object}\n * @api private\n */\n\nfunction coverage(filename, data) {\n  var ret = {\n    filename: filename,\n    coverage: 0,\n    hits: 0,\n    misses: 0,\n    sloc: 0,\n    source: {}\n  };\n\n  data.source.forEach(function(line, num){\n    num++;\n\n    if (data[num] === 0) {\n      ret.misses++;\n      ret.sloc++;\n    } else if (data[num] !== undefined) {\n      ret.hits++;\n      ret.sloc++;\n    }\n\n    ret.source[num] = {\n        source: line\n      , coverage: data[num] === undefined\n        ? ''\n        : data[num]\n    };\n  });\n\n  ret.coverage = ret.hits / ret.sloc * 100;\n\n  return ret;\n}\n\n/**\n * Return a plain-object representation of `test`\n * free of cyclic properties etc.\n *\n * @param {Object} test\n * @return {Object}\n * @api private\n */\n\nfunction clean(test) {\n  return {\n      title: test.title\n    , fullTitle: test.fullTitle()\n    , duration: test.duration\n  }\n}\n\n}); // module: reporters/json-cov.js\n\nrequire.register(\"reporters/json-stream.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , color = Base.color;\n\n/**\n * Expose `List`.\n */\n\nexports = module.exports = List;\n\n/**\n * Initialize a new `List` test reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction List(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , total = runner.total;\n\n  runner.on('start', function(){\n    console.log(JSON.stringify(['start', { total: total }]));\n  });\n\n  runner.on('pass', function(test){\n    console.log(JSON.stringify(['pass', clean(test)]));\n  });\n\n  runner.on('fail', function(test, err){\n    console.log(JSON.stringify(['fail', clean(test)]));\n  });\n\n  runner.on('end', function(){\n    process.stdout.write(JSON.stringify(['end', self.stats]));\n  });\n}\n\n/**\n * Return a plain-object representation of `test`\n * free of cyclic properties etc.\n *\n * @param {Object} test\n * @return {Object}\n * @api private\n */\n\nfunction clean(test) {\n  return {\n      title: test.title\n    , fullTitle: test.fullTitle()\n    , duration: test.duration\n  }\n}\n}); // module: reporters/json-stream.js\n\nrequire.register(\"reporters/json.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `JSON`.\n */\n\nexports = module.exports = JSONReporter;\n\n/**\n * Initialize a new `JSON` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction JSONReporter(runner) {\n  var self = this;\n  Base.call(this, runner);\n\n  var tests = []\n    , failures = []\n    , passes = [];\n\n  runner.on('test end', function(test){\n    tests.push(test);\n  });\n\n  runner.on('pass', function(test){\n    passes.push(test);\n  });\n\n  runner.on('fail', function(test, err){\n    failures.push(test);\n    if (err === Object(err)) {\n      test.errMsg = err.message;\n      test.errStack = err.stack;\n    }\n  });\n\n  runner.on('end', function(){\n    var obj = {\n      stats: self.stats,\n      tests: tests.map(clean),\n      failures: failures.map(clean),\n      passes: passes.map(clean)\n    };\n    runner.testResults = obj;\n\n    process.stdout.write(JSON.stringify(obj, null, 2));\n  });\n}\n\n/**\n * Return a plain-object representation of `test`\n * free of cyclic properties etc.\n *\n * @param {Object} test\n * @return {Object}\n * @api private\n */\n\nfunction clean(test) {\n  return {\n    title: test.title,\n    fullTitle: test.fullTitle(),\n    duration: test.duration,\n    err: test.err,\n    errStack: test.err.stack,\n    errMessage: test.err.message\n  }\n}\n\n}); // module: reporters/json.js\n\nrequire.register(\"reporters/landing.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `Landing`.\n */\n\nexports = module.exports = Landing;\n\n/**\n * Airplane color.\n */\n\nBase.colors.plane = 0;\n\n/**\n * Airplane crash color.\n */\n\nBase.colors['plane crash'] = 31;\n\n/**\n * Runway color.\n */\n\nBase.colors.runway = 90;\n\n/**\n * Initialize a new `Landing` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Landing(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , width = Base.window.width * .75 | 0\n    , total = runner.total\n    , stream = process.stdout\n    , plane = color('plane', '✈')\n    , crashed = -1\n    , n = 0;\n\n  function runway() {\n    var buf = Array(width).join('-');\n    return '  ' + color('runway', buf);\n  }\n\n  runner.on('start', function(){\n    stream.write('\\n  ');\n    cursor.hide();\n  });\n\n  runner.on('test end', function(test){\n    // check if the plane crashed\n    var col = -1 == crashed\n      ? width * ++n / total | 0\n      : crashed;\n\n    // show the crash\n    if ('failed' == test.state) {\n      plane = color('plane crash', '✈');\n      crashed = col;\n    }\n\n    // render landing strip\n    stream.write('\\u001b[4F\\n\\n');\n    stream.write(runway());\n    stream.write('\\n  ');\n    stream.write(color('runway', Array(col).join('⋅')));\n    stream.write(plane)\n    stream.write(color('runway', Array(width - col).join('⋅') + '\\n'));\n    stream.write(runway());\n    stream.write('\\u001b[0m');\n  });\n\n  runner.on('end', function(){\n    cursor.show();\n    console.log();\n    self.epilogue();\n  });\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nLanding.prototype = new F;\nLanding.prototype.constructor = Landing;\n\n}); // module: reporters/landing.js\n\nrequire.register(\"reporters/list.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `List`.\n */\n\nexports = module.exports = List;\n\n/**\n * Initialize a new `List` test reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction List(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , n = 0;\n\n  runner.on('start', function(){\n    console.log();\n  });\n\n  runner.on('test', function(test){\n    process.stdout.write(color('pass', '    ' + test.fullTitle() + ': '));\n  });\n\n  runner.on('pending', function(test){\n    var fmt = color('checkmark', '  -')\n      + color('pending', ' %s');\n    console.log(fmt, test.fullTitle());\n  });\n\n  runner.on('pass', function(test){\n    var fmt = color('checkmark', '  '+Base.symbols.dot)\n      + color('pass', ' %s: ')\n      + color(test.speed, '%dms');\n    cursor.CR();\n    console.log(fmt, test.fullTitle(), test.duration);\n  });\n\n  runner.on('fail', function(test, err){\n    cursor.CR();\n    console.log(color('fail', '  %d) %s'), ++n, test.fullTitle());\n  });\n\n  runner.on('end', self.epilogue.bind(self));\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nList.prototype = new F;\nList.prototype.constructor = List;\n\n\n}); // module: reporters/list.js\n\nrequire.register(\"reporters/markdown.js\", function(module, exports, require){\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , utils = require('../utils');\n\n/**\n * Expose `Markdown`.\n */\n\nexports = module.exports = Markdown;\n\n/**\n * Initialize a new `Markdown` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Markdown(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , level = 0\n    , buf = '';\n\n  function title(str) {\n    return Array(level).join('#') + ' ' + str;\n  }\n\n  function indent() {\n    return Array(level).join('  ');\n  }\n\n  function mapTOC(suite, obj) {\n    var ret = obj;\n    obj = obj[suite.title] = obj[suite.title] || { suite: suite };\n    suite.suites.forEach(function(suite){\n      mapTOC(suite, obj);\n    });\n    return ret;\n  }\n\n  function stringifyTOC(obj, level) {\n    ++level;\n    var buf = '';\n    var link;\n    for (var key in obj) {\n      if ('suite' == key) continue;\n      if (key) link = ' - [' + key + '](#' + utils.slug(obj[key].suite.fullTitle()) + ')\\n';\n      if (key) buf += Array(level).join('  ') + link;\n      buf += stringifyTOC(obj[key], level);\n    }\n    --level;\n    return buf;\n  }\n\n  function generateTOC(suite) {\n    var obj = mapTOC(suite, {});\n    return stringifyTOC(obj, 0);\n  }\n\n  generateTOC(runner.suite);\n\n  runner.on('suite', function(suite){\n    ++level;\n    var slug = utils.slug(suite.fullTitle());\n    buf += '<a name=\"' + slug + '\"></a>' + '\\n';\n    buf += title(suite.title) + '\\n';\n  });\n\n  runner.on('suite end', function(suite){\n    --level;\n  });\n\n  runner.on('pass', function(test){\n    var code = utils.clean(test.fn.toString());\n    buf += test.title + '.\\n';\n    buf += '\\n```js\\n';\n    buf += code + '\\n';\n    buf += '```\\n\\n';\n  });\n\n  runner.on('end', function(){\n    process.stdout.write('# TOC\\n');\n    process.stdout.write(generateTOC(runner.suite));\n    process.stdout.write(buf);\n  });\n}\n}); // module: reporters/markdown.js\n\nrequire.register(\"reporters/min.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base');\n\n/**\n * Expose `Min`.\n */\n\nexports = module.exports = Min;\n\n/**\n * Initialize a new `Min` minimal test reporter (best used with --watch).\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Min(runner) {\n  Base.call(this, runner);\n\n  runner.on('start', function(){\n    // clear screen\n    process.stdout.write('\\u001b[2J');\n    // set cursor position\n    process.stdout.write('\\u001b[1;3H');\n  });\n\n  runner.on('end', this.epilogue.bind(this));\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nMin.prototype = new F;\nMin.prototype.constructor = Min;\n\n\n}); // module: reporters/min.js\n\nrequire.register(\"reporters/nyan.js\", function(module, exports, require){\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , color = Base.color;\n\n/**\n * Expose `Dot`.\n */\n\nexports = module.exports = NyanCat;\n\n/**\n * Initialize a new `Dot` matrix test reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction NyanCat(runner) {\n  Base.call(this, runner);\n  var self = this\n    , stats = this.stats\n    , width = Base.window.width * .75 | 0\n    , rainbowColors = this.rainbowColors = self.generateColors()\n    , colorIndex = this.colorIndex = 0\n    , numerOfLines = this.numberOfLines = 4\n    , trajectories = this.trajectories = [[], [], [], []]\n    , nyanCatWidth = this.nyanCatWidth = 11\n    , trajectoryWidthMax = this.trajectoryWidthMax = (width - nyanCatWidth)\n    , scoreboardWidth = this.scoreboardWidth = 5\n    , tick = this.tick = 0\n    , n = 0;\n\n  runner.on('start', function(){\n    Base.cursor.hide();\n    self.draw();\n  });\n\n  runner.on('pending', function(test){\n    self.draw();\n  });\n\n  runner.on('pass', function(test){\n    self.draw();\n  });\n\n  runner.on('fail', function(test, err){\n    self.draw();\n  });\n\n  runner.on('end', function(){\n    Base.cursor.show();\n    for (var i = 0; i < self.numberOfLines; i++) write('\\n');\n    self.epilogue();\n  });\n}\n\n/**\n * Draw the nyan cat\n *\n * @api private\n */\n\nNyanCat.prototype.draw = function(){\n  this.appendRainbow();\n  this.drawScoreboard();\n  this.drawRainbow();\n  this.drawNyanCat();\n  this.tick = !this.tick;\n};\n\n/**\n * Draw the \"scoreboard\" showing the number\n * of passes, failures and pending tests.\n *\n * @api private\n */\n\nNyanCat.prototype.drawScoreboard = function(){\n  var stats = this.stats;\n  var colors = Base.colors;\n\n  function draw(color, n) {\n    write(' ');\n    write('\\u001b[' + color + 'm' + n + '\\u001b[0m');\n    write('\\n');\n  }\n\n  draw(colors.green, stats.passes);\n  draw(colors.fail, stats.failures);\n  draw(colors.pending, stats.pending);\n  write('\\n');\n\n  this.cursorUp(this.numberOfLines);\n};\n\n/**\n * Append the rainbow.\n *\n * @api private\n */\n\nNyanCat.prototype.appendRainbow = function(){\n  var segment = this.tick ? '_' : '-';\n  var rainbowified = this.rainbowify(segment);\n\n  for (var index = 0; index < this.numberOfLines; index++) {\n    var trajectory = this.trajectories[index];\n    if (trajectory.length >= this.trajectoryWidthMax) trajectory.shift();\n    trajectory.push(rainbowified);\n  }\n};\n\n/**\n * Draw the rainbow.\n *\n * @api private\n */\n\nNyanCat.prototype.drawRainbow = function(){\n  var self = this;\n\n  this.trajectories.forEach(function(line, index) {\n    write('\\u001b[' + self.scoreboardWidth + 'C');\n    write(line.join(''));\n    write('\\n');\n  });\n\n  this.cursorUp(this.numberOfLines);\n};\n\n/**\n * Draw the nyan cat\n *\n * @api private\n */\n\nNyanCat.prototype.drawNyanCat = function() {\n  var self = this;\n  var startWidth = this.scoreboardWidth + this.trajectories[0].length;\n  var color = '\\u001b[' + startWidth + 'C';\n  var padding = '';\n\n  write(color);\n  write('_,------,');\n  write('\\n');\n\n  write(color);\n  padding = self.tick ? '  ' : '   ';\n  write('_|' + padding + '/\\\\_/\\\\ ');\n  write('\\n');\n\n  write(color);\n  padding = self.tick ? '_' : '__';\n  var tail = self.tick ? '~' : '^';\n  var face;\n  write(tail + '|' + padding + this.face() + ' ');\n  write('\\n');\n\n  write(color);\n  padding = self.tick ? ' ' : '  ';\n  write(padding + '\"\"  \"\" ');\n  write('\\n');\n\n  this.cursorUp(this.numberOfLines);\n};\n\n/**\n * Draw nyan cat face.\n *\n * @return {String}\n * @api private\n */\n\nNyanCat.prototype.face = function() {\n  var stats = this.stats;\n  if (stats.failures) {\n    return '( x .x)';\n  } else if (stats.pending) {\n    return '( o .o)';\n  } else if(stats.passes) {\n    return '( ^ .^)';\n  } else {\n    return '( - .-)';\n  }\n}\n\n/**\n * Move cursor up `n`.\n *\n * @param {Number} n\n * @api private\n */\n\nNyanCat.prototype.cursorUp = function(n) {\n  write('\\u001b[' + n + 'A');\n};\n\n/**\n * Move cursor down `n`.\n *\n * @param {Number} n\n * @api private\n */\n\nNyanCat.prototype.cursorDown = function(n) {\n  write('\\u001b[' + n + 'B');\n};\n\n/**\n * Generate rainbow colors.\n *\n * @return {Array}\n * @api private\n */\n\nNyanCat.prototype.generateColors = function(){\n  var colors = [];\n\n  for (var i = 0; i < (6 * 7); i++) {\n    var pi3 = Math.floor(Math.PI / 3);\n    var n = (i * (1.0 / 6));\n    var r = Math.floor(3 * Math.sin(n) + 3);\n    var g = Math.floor(3 * Math.sin(n + 2 * pi3) + 3);\n    var b = Math.floor(3 * Math.sin(n + 4 * pi3) + 3);\n    colors.push(36 * r + 6 * g + b + 16);\n  }\n\n  return colors;\n};\n\n/**\n * Apply rainbow to the given `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nNyanCat.prototype.rainbowify = function(str){\n  var color = this.rainbowColors[this.colorIndex % this.rainbowColors.length];\n  this.colorIndex += 1;\n  return '\\u001b[38;5;' + color + 'm' + str + '\\u001b[0m';\n};\n\n/**\n * Stdout helper.\n */\n\nfunction write(string) {\n  process.stdout.write(string);\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nNyanCat.prototype = new F;\nNyanCat.prototype.constructor = NyanCat;\n\n\n}); // module: reporters/nyan.js\n\nrequire.register(\"reporters/progress.js\", function(module, exports, require){\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `Progress`.\n */\n\nexports = module.exports = Progress;\n\n/**\n * General progress bar color.\n */\n\nBase.colors.progress = 90;\n\n/**\n * Initialize a new `Progress` bar test reporter.\n *\n * @param {Runner} runner\n * @param {Object} options\n * @api public\n */\n\nfunction Progress(runner, options) {\n  Base.call(this, runner);\n\n  var self = this\n    , options = options || {}\n    , stats = this.stats\n    , width = Base.window.width * .50 | 0\n    , total = runner.total\n    , complete = 0\n    , max = Math.max\n    , lastN = -1;\n\n  // default chars\n  options.open = options.open || '[';\n  options.complete = options.complete || '▬';\n  options.incomplete = options.incomplete || Base.symbols.dot;\n  options.close = options.close || ']';\n  options.verbose = false;\n\n  // tests started\n  runner.on('start', function(){\n    console.log();\n    cursor.hide();\n  });\n\n  // tests complete\n  runner.on('test end', function(){\n    complete++;\n    var incomplete = total - complete\n      , percent = complete / total\n      , n = width * percent | 0\n      , i = width - n;\n\n    if (lastN === n && !options.verbose) {\n      // Don't re-render the line if it hasn't changed\n      return;\n    }\n    lastN = n;\n\n    cursor.CR();\n    process.stdout.write('\\u001b[J');\n    process.stdout.write(color('progress', '  ' + options.open));\n    process.stdout.write(Array(n).join(options.complete));\n    process.stdout.write(Array(i).join(options.incomplete));\n    process.stdout.write(color('progress', options.close));\n    if (options.verbose) {\n      process.stdout.write(color('progress', ' ' + complete + ' of ' + total));\n    }\n  });\n\n  // tests are complete, output some stats\n  // and the failures if any\n  runner.on('end', function(){\n    cursor.show();\n    console.log();\n    self.epilogue();\n  });\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nProgress.prototype = new F;\nProgress.prototype.constructor = Progress;\n\n\n}); // module: reporters/progress.js\n\nrequire.register(\"reporters/spec.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `Spec`.\n */\n\nexports = module.exports = Spec;\n\n/**\n * Initialize a new `Spec` test reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction Spec(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , indents = 0\n    , n = 0;\n\n  function indent() {\n    return Array(indents).join('  ')\n  }\n\n  runner.on('start', function(){\n    console.log();\n  });\n\n  runner.on('suite', function(suite){\n    ++indents;\n    console.log(color('suite', '%s%s'), indent(), suite.title);\n  });\n\n  runner.on('suite end', function(suite){\n    --indents;\n    if (1 == indents) console.log();\n  });\n\n  runner.on('pending', function(test){\n    var fmt = indent() + color('pending', '  - %s');\n    console.log(fmt, test.title);\n  });\n\n  runner.on('pass', function(test){\n    if ('fast' == test.speed) {\n      var fmt = indent()\n        + color('checkmark', '  ' + Base.symbols.ok)\n        + color('pass', ' %s ');\n      cursor.CR();\n      console.log(fmt, test.title);\n    } else {\n      var fmt = indent()\n        + color('checkmark', '  ' + Base.symbols.ok)\n        + color('pass', ' %s ')\n        + color(test.speed, '(%dms)');\n      cursor.CR();\n      console.log(fmt, test.title, test.duration);\n    }\n  });\n\n  runner.on('fail', function(test, err){\n    cursor.CR();\n    console.log(indent() + color('fail', '  %d) %s'), ++n, test.title);\n  });\n\n  runner.on('end', self.epilogue.bind(self));\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nSpec.prototype = new F;\nSpec.prototype.constructor = Spec;\n\n\n}); // module: reporters/spec.js\n\nrequire.register(\"reporters/tap.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , cursor = Base.cursor\n  , color = Base.color;\n\n/**\n * Expose `TAP`.\n */\n\nexports = module.exports = TAP;\n\n/**\n * Initialize a new `TAP` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction TAP(runner) {\n  Base.call(this, runner);\n\n  var self = this\n    , stats = this.stats\n    , n = 1\n    , passes = 0\n    , failures = 0;\n\n  runner.on('start', function(){\n    var total = runner.grepTotal(runner.suite);\n    console.log('%d..%d', 1, total);\n  });\n\n  runner.on('test end', function(){\n    ++n;\n  });\n\n  runner.on('pending', function(test){\n    console.log('ok %d %s # SKIP -', n, title(test));\n  });\n\n  runner.on('pass', function(test){\n    passes++;\n    console.log('ok %d %s', n, title(test));\n  });\n\n  runner.on('fail', function(test, err){\n    failures++;\n    console.log('not ok %d %s', n, title(test));\n    if (err.stack) console.log(err.stack.replace(/^/gm, '  '));\n  });\n\n  runner.on('end', function(){\n    console.log('# tests ' + (passes + failures));\n    console.log('# pass ' + passes);\n    console.log('# fail ' + failures);\n  });\n}\n\n/**\n * Return a TAP-safe title of `test`\n *\n * @param {Object} test\n * @return {String}\n * @api private\n */\n\nfunction title(test) {\n  return test.fullTitle().replace(/#/g, '');\n}\n\n}); // module: reporters/tap.js\n\nrequire.register(\"reporters/xunit.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Base = require('./base')\n  , utils = require('../utils')\n  , escape = utils.escape;\n\n/**\n * Save timer references to avoid Sinon interfering (see GH-237).\n */\n\nvar Date = global.Date\n  , setTimeout = global.setTimeout\n  , setInterval = global.setInterval\n  , clearTimeout = global.clearTimeout\n  , clearInterval = global.clearInterval;\n\n/**\n * Expose `XUnit`.\n */\n\nexports = module.exports = XUnit;\n\n/**\n * Initialize a new `XUnit` reporter.\n *\n * @param {Runner} runner\n * @api public\n */\n\nfunction XUnit(runner) {\n  Base.call(this, runner);\n  var stats = this.stats\n    , tests = []\n    , self = this;\n\n  runner.on('pending', function(test){\n    tests.push(test);\n  });\n\n  runner.on('pass', function(test){\n    tests.push(test);\n  });\n\n  runner.on('fail', function(test){\n    tests.push(test);\n  });\n\n  runner.on('end', function(){\n    console.log(tag('testsuite', {\n        name: 'Mocha Tests'\n      , tests: stats.tests\n      , failures: stats.failures\n      , errors: stats.failures\n      , skipped: stats.tests - stats.failures - stats.passes\n      , timestamp: (new Date).toUTCString()\n      , time: (stats.duration / 1000) || 0\n    }, false));\n\n    tests.forEach(test);\n    console.log('</testsuite>');\n  });\n}\n\n/**\n * Inherit from `Base.prototype`.\n */\n\nfunction F(){};\nF.prototype = Base.prototype;\nXUnit.prototype = new F;\nXUnit.prototype.constructor = XUnit;\n\n\n/**\n * Output tag for the given `test.`\n */\n\nfunction test(test) {\n  var attrs = {\n      classname: test.parent.fullTitle()\n    , name: test.title\n    , time: (test.duration / 1000) || 0\n  };\n\n  if ('failed' == test.state) {\n    var err = test.err;\n    console.log(tag('testcase', attrs, false, tag('failure', {}, false, cdata(escape(err.message) + \"\\n\" + err.stack))));\n  } else if (test.pending) {\n    console.log(tag('testcase', attrs, false, tag('skipped', {}, true)));\n  } else {\n    console.log(tag('testcase', attrs, true) );\n  }\n}\n\n/**\n * HTML tag helper.\n */\n\nfunction tag(name, attrs, close, content) {\n  var end = close ? '/>' : '>'\n    , pairs = []\n    , tag;\n\n  for (var key in attrs) {\n    pairs.push(key + '=\"' + escape(attrs[key]) + '\"');\n  }\n\n  tag = '<' + name + (pairs.length ? ' ' + pairs.join(' ') : '') + end;\n  if (content) tag += content + '</' + name + end;\n  return tag;\n}\n\n/**\n * Return cdata escaped CDATA `str`.\n */\n\nfunction cdata(str) {\n  return '<![CDATA[' + escape(str) + ']]>';\n}\n\n}); // module: reporters/xunit.js\n\nrequire.register(\"runnable.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar EventEmitter = require('browser/events').EventEmitter\n  , debug = require('browser/debug')('mocha:runnable')\n  , milliseconds = require('./ms');\n\n/**\n * Save timer references to avoid Sinon interfering (see GH-237).\n */\n\nvar Date = global.Date\n  , setTimeout = global.setTimeout\n  , setInterval = global.setInterval\n  , clearTimeout = global.clearTimeout\n  , clearInterval = global.clearInterval;\n\n/**\n * Object#toString().\n */\n\nvar toString = Object.prototype.toString;\n\n/**\n * Expose `Runnable`.\n */\n\nmodule.exports = Runnable;\n\n/**\n * Initialize a new `Runnable` with the given `title` and callback `fn`.\n *\n * @param {String} title\n * @param {Function} fn\n * @api private\n */\n\nfunction Runnable(title, fn) {\n  this.title = title;\n  this.fn = fn;\n  this.async = fn && fn.length;\n  this.sync = ! this.async;\n  this._timeout = 2000;\n  this._slow = 75;\n  this._enableTimeouts = true;\n  this.timedOut = false;\n}\n\n/**\n * Inherit from `EventEmitter.prototype`.\n */\n\nfunction F(){};\nF.prototype = EventEmitter.prototype;\nRunnable.prototype = new F;\nRunnable.prototype.constructor = Runnable;\n\n\n/**\n * Set & get timeout `ms`.\n *\n * @param {Number|String} ms\n * @return {Runnable|Number} ms or self\n * @api private\n */\n\nRunnable.prototype.timeout = function(ms){\n  if (0 == arguments.length) return this._timeout;\n  if ('string' == typeof ms) ms = milliseconds(ms);\n  debug('timeout %d', ms);\n  this._timeout = ms;\n  if (this.timer) this.resetTimeout();\n  return this;\n};\n\n/**\n * Set & get slow `ms`.\n *\n * @param {Number|String} ms\n * @return {Runnable|Number} ms or self\n * @api private\n */\n\nRunnable.prototype.slow = function(ms){\n  if (0 === arguments.length) return this._slow;\n  if ('string' == typeof ms) ms = milliseconds(ms);\n  debug('timeout %d', ms);\n  this._slow = ms;\n  return this;\n};\n\n/**\n * Set and & get timeout `enabled`.\n *\n * @param {Boolean} enabled\n * @return {Runnable|Boolean} enabled or self\n * @api private\n */\n\nRunnable.prototype.enableTimeouts = function(enabled){\n  if (arguments.length === 0) return this._enableTimeouts;\n  debug('enableTimeouts %s', enabled);\n  this._enableTimeouts = enabled;\n  return this;\n};\n\n/**\n * Return the full title generated by recursively\n * concatenating the parent's full title.\n *\n * @return {String}\n * @api public\n */\n\nRunnable.prototype.fullTitle = function(){\n  return this.parent.fullTitle() + ' ' + this.title;\n};\n\n/**\n * Clear the timeout.\n *\n * @api private\n */\n\nRunnable.prototype.clearTimeout = function(){\n  clearTimeout(this.timer);\n};\n\n/**\n * Inspect the runnable void of private properties.\n *\n * @return {String}\n * @api private\n */\n\nRunnable.prototype.inspect = function(){\n  return JSON.stringify(this, function(key, val){\n    if ('_' == key[0]) return;\n    if ('parent' == key) return '#<Suite>';\n    if ('ctx' == key) return '#<Context>';\n    return val;\n  }, 2);\n};\n\n/**\n * Reset the timeout.\n *\n * @api private\n */\n\nRunnable.prototype.resetTimeout = function(){\n  var self = this;\n  var ms = this.timeout() || 1e9;\n\n  if (!this._enableTimeouts) return;\n  this.clearTimeout();\n  this.timer = setTimeout(function(){\n    self.callback(new Error('timeout of ' + ms + 'ms exceeded'));\n    self.timedOut = true;\n  }, ms);\n};\n\n/**\n * Whitelist these globals for this test run\n *\n * @api private\n */\nRunnable.prototype.globals = function(arr){\n  var self = this;\n  this._allowedGlobals = arr;\n};\n\n/**\n * Run the test and invoke `fn(err)`.\n *\n * @param {Function} fn\n * @api private\n */\n\nRunnable.prototype.run = function(fn){\n  var self = this\n    , start = new Date\n    , ctx = this.ctx\n    , finished\n    , emitted;\n\n  // Some times the ctx exists but it is not runnable\n  if (ctx && ctx.runnable) ctx.runnable(this);\n\n  // called multiple times\n  function multiple(err) {\n    if (emitted) return;\n    emitted = true;\n    self.emit('error', err || new Error('done() called multiple times'));\n  }\n\n  // finished\n  function done(err) {\n    var ms = self.timeout();\n    if (self.timedOut) return;\n    if (finished) return multiple(err);\n    self.clearTimeout();\n    self.duration = new Date - start;\n    finished = true;\n    if (!err && self.duration > ms && self._enableTimeouts) err = new Error('timeout of ' + ms + 'ms exceeded');\n    fn(err);\n  }\n\n  // for .resetTimeout()\n  this.callback = done;\n\n  // explicit async with `done` argument\n  if (this.async) {\n    this.resetTimeout();\n\n    try {\n      this.fn.call(ctx, function(err){\n        if (err instanceof Error || toString.call(err) === \"[object Error]\") return done(err);\n        if (null != err) {\n          if (Object.prototype.toString.call(err) === '[object Object]') {\n            return done(new Error('done() invoked with non-Error: ' + JSON.stringify(err)));\n          } else {\n            return done(new Error('done() invoked with non-Error: ' + err));\n          }\n        }\n        done();\n      });\n    } catch (err) {\n      done(err);\n    }\n    return;\n  }\n\n  if (this.asyncOnly) {\n    return done(new Error('--async-only option in use without declaring `done()`'));\n  }\n\n  // sync or promise-returning\n  try {\n    if (this.pending) {\n      done();\n    } else {\n      callFn(this.fn);\n    }\n  } catch (err) {\n    done(err);\n  }\n\n  function callFn(fn) {\n    var result = fn.call(ctx);\n    if (result && typeof result.then === 'function') {\n      self.resetTimeout();\n      result\n        .then(function() {\n          done()\n        },\n        function(reason) {\n          done(reason || new Error('Promise rejected with no or falsy reason'))\n        });\n    } else {\n      done();\n    }\n  }\n};\n\n}); // module: runnable.js\n\nrequire.register(\"runner.js\", function(module, exports, require){\n/**\n * Module dependencies.\n */\n\nvar EventEmitter = require('browser/events').EventEmitter\n  , debug = require('browser/debug')('mocha:runner')\n  , Test = require('./test')\n  , utils = require('./utils')\n  , filter = utils.filter\n  , keys = utils.keys;\n\n/**\n * Non-enumerable globals.\n */\n\nvar globals = [\n  'setTimeout',\n  'clearTimeout',\n  'setInterval',\n  'clearInterval',\n  'XMLHttpRequest',\n  'Date'\n];\n\n/**\n * Expose `Runner`.\n */\n\nmodule.exports = Runner;\n\n/**\n * Initialize a `Runner` for the given `suite`.\n *\n * Events:\n *\n *   - `start`  execution started\n *   - `end`  execution complete\n *   - `suite`  (suite) test suite execution started\n *   - `suite end`  (suite) all tests (and sub-suites) have finished\n *   - `test`  (test) test execution started\n *   - `test end`  (test) test completed\n *   - `hook`  (hook) hook execution started\n *   - `hook end`  (hook) hook complete\n *   - `pass`  (test) test passed\n *   - `fail`  (test, err) test failed\n *   - `pending`  (test) test pending\n *\n * @api public\n */\n\nfunction Runner(suite) {\n  var self = this;\n  this._globals = [];\n  this._abort = false;\n  this.suite = suite;\n  this.total = suite.total();\n  this.failures = 0;\n  this.on('test end', function(test){ self.checkGlobals(test); });\n  this.on('hook end', function(hook){ self.checkGlobals(hook); });\n  this.grep(/.*/);\n  this.globals(this.globalProps().concat(extraGlobals()));\n}\n\n/**\n * Wrapper for setImmediate, process.nextTick, or browser polyfill.\n *\n * @param {Function} fn\n * @api private\n */\n\nRunner.immediately = global.setImmediate || process.nextTick;\n\n/**\n * Inherit from `EventEmitter.prototype`.\n */\n\nfunction F(){};\nF.prototype = EventEmitter.prototype;\nRunner.prototype = new F;\nRunner.prototype.constructor = Runner;\n\n\n/**\n * Run tests with full titles matching `re`. Updates runner.total\n * with number of tests matched.\n *\n * @param {RegExp} re\n * @param {Boolean} invert\n * @return {Runner} for chaining\n * @api public\n */\n\nRunner.prototype.grep = function(re, invert){\n  debug('grep %s', re);\n  this._grep = re;\n  this._invert = invert;\n  this.total = this.grepTotal(this.suite);\n  return this;\n};\n\n/**\n * Returns the number of tests matching the grep search for the\n * given suite.\n *\n * @param {Suite} suite\n * @return {Number}\n * @api public\n */\n\nRunner.prototype.grepTotal = function(suite) {\n  var self = this;\n  var total = 0;\n\n  suite.eachTest(function(test){\n    var match = self._grep.test(test.fullTitle());\n    if (self._invert) match = !match;\n    if (match) total++;\n  });\n\n  return total;\n};\n\n/**\n * Return a list of global properties.\n *\n * @return {Array}\n * @api private\n */\n\nRunner.prototype.globalProps = function() {\n  var props = utils.keys(global);\n\n  // non-enumerables\n  for (var i = 0; i < globals.length; ++i) {\n    if (~utils.indexOf(props, globals[i])) continue;\n    props.push(globals[i]);\n  }\n\n  return props;\n};\n\n/**\n * Allow the given `arr` of globals.\n *\n * @param {Array} arr\n * @return {Runner} for chaining\n * @api public\n */\n\nRunner.prototype.globals = function(arr){\n  if (0 == arguments.length) return this._globals;\n  debug('globals %j', arr);\n  this._globals = this._globals.concat(arr);\n  return this;\n};\n\n/**\n * Check for global variable leaks.\n *\n * @api private\n */\n\nRunner.prototype.checkGlobals = function(test){\n  if (this.ignoreLeaks) return;\n  var ok = this._globals;\n\n  var globals = this.globalProps();\n  var leaks;\n\n  if (test) {\n    ok = ok.concat(test._allowedGlobals || []);\n  }\n\n  if(this.prevGlobalsLength == globals.length) return;\n  this.prevGlobalsLength = globals.length;\n\n  leaks = filterLeaks(ok, globals);\n  this._globals = this._globals.concat(leaks);\n\n  if (leaks.length > 1) {\n    this.fail(test, new Error('global leaks detected: ' + leaks.join(', ') + ''));\n  } else if (leaks.length) {\n    this.fail(test, new Error('global leak detected: ' + leaks[0]));\n  }\n};\n\n/**\n * Fail the given `test`.\n *\n * @param {Test} test\n * @param {Error} err\n * @api private\n */\n\nRunner.prototype.fail = function(test, err){\n  ++this.failures;\n  test.state = 'failed';\n\n  if ('string' == typeof err) {\n    err = new Error('the string \"' + err + '\" was thrown, throw an Error :)');\n  }\n\n  this.emit('fail', test, err);\n};\n\n/**\n * Fail the given `hook` with `err`.\n *\n * Hook failures work in the following pattern:\n * - If bail, then exit\n * - Failed `before` hook skips all tests in a suite and subsuites,\n *   but jumps to corresponding `after` hook\n * - Failed `before each` hook skips remaining tests in a\n *   suite and jumps to corresponding `after each` hook,\n *   which is run only once\n * - Failed `after` hook does not alter\n *   execution order\n * - Failed `after each` hook skips remaining tests in a\n *   suite and subsuites, but executes other `after each`\n *   hooks\n *\n * @param {Hook} hook\n * @param {Error} err\n * @api private\n */\n\nRunner.prototype.failHook = function(hook, err){\n  this.fail(hook, err);\n  if (this.suite.bail()) {\n    this.emit('end');\n  }\n};\n\n/**\n * Run hook `name` callbacks and then invoke `fn()`.\n *\n * @param {String} name\n * @param {Function} function\n * @api private\n */\n\nRunner.prototype.hook = function(name, fn){\n  var suite = this.suite\n    , hooks = suite['_' + name]\n    , self = this\n    , timer;\n\n  function next(i) {\n    var hook = hooks[i];\n    if (!hook) return fn();\n    if (self.failures && suite.bail()) return fn();\n    self.currentRunnable = hook;\n\n    hook.ctx.currentTest = self.test;\n\n    self.emit('hook', hook);\n\n    hook.on('error', function(err){\n      self.failHook(hook, err);\n    });\n\n    hook.run(function(err){\n      hook.removeAllListeners('error');\n      var testError = hook.error();\n      if (testError) self.fail(self.test, testError);\n      if (err) {\n        self.failHook(hook, err);\n\n        // stop executing hooks, notify callee of hook err\n        return fn(err);\n      }\n      self.emit('hook end', hook);\n      delete hook.ctx.currentTest;\n      next(++i);\n    });\n  }\n\n  Runner.immediately(function(){\n    next(0);\n  });\n};\n\n/**\n * Run hook `name` for the given array of `suites`\n * in order, and callback `fn(err, errSuite)`.\n *\n * @param {String} name\n * @param {Array} suites\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.hooks = function(name, suites, fn){\n  var self = this\n    , orig = this.suite;\n\n  function next(suite) {\n    self.suite = suite;\n\n    if (!suite) {\n      self.suite = orig;\n      return fn();\n    }\n\n    self.hook(name, function(err){\n      if (err) {\n        var errSuite = self.suite;\n        self.suite = orig;\n        return fn(err, errSuite);\n      }\n\n      next(suites.pop());\n    });\n  }\n\n  next(suites.pop());\n};\n\n/**\n * Run hooks from the top level down.\n *\n * @param {String} name\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.hookUp = function(name, fn){\n  var suites = [this.suite].concat(this.parents()).reverse();\n  this.hooks(name, suites, fn);\n};\n\n/**\n * Run hooks from the bottom up.\n *\n * @param {String} name\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.hookDown = function(name, fn){\n  var suites = [this.suite].concat(this.parents());\n  this.hooks(name, suites, fn);\n};\n\n/**\n * Return an array of parent Suites from\n * closest to furthest.\n *\n * @return {Array}\n * @api private\n */\n\nRunner.prototype.parents = function(){\n  var suite = this.suite\n    , suites = [];\n  while (suite = suite.parent) suites.push(suite);\n  return suites;\n};\n\n/**\n * Run the current test and callback `fn(err)`.\n *\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.runTest = function(fn){\n  var test = this.test\n    , self = this;\n\n  if (this.asyncOnly) test.asyncOnly = true;\n\n  try {\n    test.on('error', function(err){\n      self.fail(test, err);\n    });\n    test.run(fn);\n  } catch (err) {\n    fn(err);\n  }\n};\n\n/**\n * Run tests in the given `suite` and invoke\n * the callback `fn()` when complete.\n *\n * @param {Suite} suite\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.runTests = function(suite, fn){\n  var self = this\n    , tests = suite.tests.slice()\n    , test;\n\n\n  function hookErr(err, errSuite, after) {\n    // before/after Each hook for errSuite failed:\n    var orig = self.suite;\n\n    // for failed 'after each' hook start from errSuite parent,\n    // otherwise start from errSuite itself\n    self.suite = after ? errSuite.parent : errSuite;\n\n    if (self.suite) {\n      // call hookUp afterEach\n      self.hookUp('afterEach', function(err2, errSuite2) {\n        self.suite = orig;\n        // some hooks may fail even now\n        if (err2) return hookErr(err2, errSuite2, true);\n        // report error suite\n        fn(errSuite);\n      });\n    } else {\n      // there is no need calling other 'after each' hooks\n      self.suite = orig;\n      fn(errSuite);\n    }\n  }\n\n  function next(err, errSuite) {\n    // if we bail after first err\n    if (self.failures && suite._bail) return fn();\n\n    if (self._abort) return fn();\n\n    if (err) return hookErr(err, errSuite, true);\n\n    // next test\n    test = tests.shift();\n\n    // all done\n    if (!test) return fn();\n\n    // grep\n    var match = self._grep.test(test.fullTitle());\n    if (self._invert) match = !match;\n    if (!match) return next();\n\n    // pending\n    if (test.pending) {\n      self.emit('pending', test);\n      self.emit('test end', test);\n      return next();\n    }\n\n    // execute test and hook(s)\n    self.emit('test', self.test = test);\n    self.hookDown('beforeEach', function(err, errSuite){\n\n      if (err) return hookErr(err, errSuite, false);\n\n      self.currentRunnable = self.test;\n      self.runTest(function(err){\n        test = self.test;\n\n        if (err) {\n          self.fail(test, err);\n          self.emit('test end', test);\n          return self.hookUp('afterEach', next);\n        }\n\n        test.state = 'passed';\n        self.emit('pass', test);\n        self.emit('test end', test);\n        self.hookUp('afterEach', next);\n      });\n    });\n  }\n\n  this.next = next;\n  next();\n};\n\n/**\n * Run the given `suite` and invoke the\n * callback `fn()` when complete.\n *\n * @param {Suite} suite\n * @param {Function} fn\n * @api private\n */\n\nRunner.prototype.runSuite = function(suite, fn){\n  var total = this.grepTotal(suite)\n    , self = this\n    , i = 0;\n\n  debug('run suite %s', suite.fullTitle());\n\n  if (!total) return fn();\n\n  this.emit('suite', this.suite = suite);\n\n  function next(errSuite) {\n    if (errSuite) {\n      // current suite failed on a hook from errSuite\n      if (errSuite == suite) {\n        // if errSuite is current suite\n        // continue to the next sibling suite\n        return done();\n      } else {\n        // errSuite is among the parents of current suite\n        // stop execution of errSuite and all sub-suites\n        return done(errSuite);\n      }\n    }\n\n    if (self._abort) return done();\n\n    var curr = suite.suites[i++];\n    if (!curr) return done();\n    self.runSuite(curr, next);\n  }\n\n  function done(errSuite) {\n    self.suite = suite;\n    self.hook('afterAll', function(){\n      self.emit('suite end', suite);\n      fn(errSuite);\n    });\n  }\n\n  this.hook('beforeAll', function(err){\n    if (err) return done();\n    self.runTests(suite, next);\n  });\n};\n\n/**\n * Handle uncaught exceptions.\n *\n * @param {Error} err\n * @api private\n */\n\nRunner.prototype.uncaught = function(err){\n  if (err) {\n    debug('uncaught exception %s', err.message);\n  } else {\n    debug('uncaught undefined exception');\n    err = new Error('Catched undefined error, did you throw without specifying what?');\n  }\n  \n  var runnable = this.currentRunnable;\n  if (!runnable || 'failed' == runnable.state) return;\n  runnable.clearTimeout();\n  err.uncaught = true;\n  this.fail(runnable, err);\n\n  // recover from test\n  if ('test' == runnable.type) {\n    this.emit('test end', runnable);\n    this.hookUp('afterEach', this.next);\n    return;\n  }\n\n  // bail on hooks\n  this.emit('end');\n};\n\n/**\n * Run the root suite and invoke `fn(failures)`\n * on completion.\n *\n * @param {Function} fn\n * @return {Runner} for chaining\n * @api public\n */\n\nRunner.prototype.run = function(fn){\n  var self = this\n    , fn = fn || function(){};\n\n  function uncaught(err){\n    self.uncaught(err);\n  }\n\n  debug('start');\n\n  // callback\n  this.on('end', function(){\n    debug('end');\n    process.removeListener('uncaughtException', uncaught);\n    fn(self.failures);\n  });\n\n  // run suites\n  this.emit('start');\n  this.runSuite(this.suite, function(){\n    debug('finished running');\n    self.emit('end');\n  });\n\n  // uncaught exception\n  process.on('uncaughtException', uncaught);\n\n  return this;\n};\n\n/**\n * Cleanly abort execution\n *\n * @return {Runner} for chaining\n * @api public\n */\nRunner.prototype.abort = function(){\n  debug('aborting');\n  this._abort = true;\n}\n\n/**\n * Filter leaks with the given globals flagged as `ok`.\n *\n * @param {Array} ok\n * @param {Array} globals\n * @return {Array}\n * @api private\n */\n\nfunction filterLeaks(ok, globals) {\n  return filter(globals, function(key){\n    // Firefox and Chrome exposes iframes as index inside the window object\n    if (/^d+/.test(key)) return false;\n\n    // in firefox\n    // if runner runs in an iframe, this iframe's window.getInterface method not init at first\n    // it is assigned in some seconds\n    if (global.navigator && /^getInterface/.test(key)) return false;\n\n    // an iframe could be approached by window[iframeIndex]\n    // in ie6,7,8 and opera, iframeIndex is enumerable, this could cause leak\n    if (global.navigator && /^\\d+/.test(key)) return false;\n\n    // Opera and IE expose global variables for HTML element IDs (issue #243)\n    if (/^mocha-/.test(key)) return false;\n\n    var matched = filter(ok, function(ok){\n      if (~ok.indexOf('*')) return 0 == key.indexOf(ok.split('*')[0]);\n      return key == ok;\n    });\n    return matched.length == 0 && (!global.navigator || 'onerror' !== key);\n  });\n}\n\n/**\n * Array of globals dependent on the environment.\n *\n * @return {Array}\n * @api private\n */\n\n function extraGlobals() {\n  if (typeof(process) === 'object' &&\n      typeof(process.version) === 'string') {\n\n    var nodeVersion = process.version.split('.').reduce(function(a, v) {\n      return a << 8 | v;\n    });\n\n    // 'errno' was renamed to process._errno in v0.9.11.\n\n    if (nodeVersion < 0x00090B) {\n      return ['errno'];\n    }\n  }\n\n  return [];\n }\n\n}); // module: runner.js\n\nrequire.register(\"suite.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar EventEmitter = require('browser/events').EventEmitter\n  , debug = require('browser/debug')('mocha:suite')\n  , milliseconds = require('./ms')\n  , utils = require('./utils')\n  , Hook = require('./hook');\n\n/**\n * Expose `Suite`.\n */\n\nexports = module.exports = Suite;\n\n/**\n * Create a new `Suite` with the given `title`\n * and parent `Suite`. When a suite with the\n * same title is already present, that suite\n * is returned to provide nicer reporter\n * and more flexible meta-testing.\n *\n * @param {Suite} parent\n * @param {String} title\n * @return {Suite}\n * @api public\n */\n\nexports.create = function(parent, title){\n  var suite = new Suite(title, parent.ctx);\n  suite.parent = parent;\n  if (parent.pending) suite.pending = true;\n  title = suite.fullTitle();\n  parent.addSuite(suite);\n  return suite;\n};\n\n/**\n * Initialize a new `Suite` with the given\n * `title` and `ctx`.\n *\n * @param {String} title\n * @param {Context} ctx\n * @api private\n */\n\nfunction Suite(title, parentContext) {\n  this.title = title;\n  var context = function() {};\n  context.prototype = parentContext;\n  this.ctx = new context();\n  this.suites = [];\n  this.tests = [];\n  this.pending = false;\n  this._beforeEach = [];\n  this._beforeAll = [];\n  this._afterEach = [];\n  this._afterAll = [];\n  this.root = !title;\n  this._timeout = 2000;\n  this._enableTimeouts = true;\n  this._slow = 75;\n  this._bail = false;\n}\n\n/**\n * Inherit from `EventEmitter.prototype`.\n */\n\nfunction F(){};\nF.prototype = EventEmitter.prototype;\nSuite.prototype = new F;\nSuite.prototype.constructor = Suite;\n\n\n/**\n * Return a clone of this `Suite`.\n *\n * @return {Suite}\n * @api private\n */\n\nSuite.prototype.clone = function(){\n  var suite = new Suite(this.title);\n  debug('clone');\n  suite.ctx = this.ctx;\n  suite.timeout(this.timeout());\n  suite.enableTimeouts(this.enableTimeouts());\n  suite.slow(this.slow());\n  suite.bail(this.bail());\n  return suite;\n};\n\n/**\n * Set timeout `ms` or short-hand such as \"2s\".\n *\n * @param {Number|String} ms\n * @return {Suite|Number} for chaining\n * @api private\n */\n\nSuite.prototype.timeout = function(ms){\n  if (0 == arguments.length) return this._timeout;\n  if ('string' == typeof ms) ms = milliseconds(ms);\n  debug('timeout %d', ms);\n  this._timeout = parseInt(ms, 10);\n  return this;\n};\n\n/**\n  * Set timeout `enabled`.\n  *\n  * @param {Boolean} enabled\n  * @return {Suite|Boolean} self or enabled\n  * @api private\n  */\n\nSuite.prototype.enableTimeouts = function(enabled){\n  if (arguments.length === 0) return this._enableTimeouts;\n  debug('enableTimeouts %s', enabled);\n  this._enableTimeouts = enabled;\n  return this;\n}\n\n/**\n * Set slow `ms` or short-hand such as \"2s\".\n *\n * @param {Number|String} ms\n * @return {Suite|Number} for chaining\n * @api private\n */\n\nSuite.prototype.slow = function(ms){\n  if (0 === arguments.length) return this._slow;\n  if ('string' == typeof ms) ms = milliseconds(ms);\n  debug('slow %d', ms);\n  this._slow = ms;\n  return this;\n};\n\n/**\n * Sets whether to bail after first error.\n *\n * @parma {Boolean} bail\n * @return {Suite|Number} for chaining\n * @api private\n */\n\nSuite.prototype.bail = function(bail){\n  if (0 == arguments.length) return this._bail;\n  debug('bail %s', bail);\n  this._bail = bail;\n  return this;\n};\n\n/**\n * Run `fn(test[, done])` before running tests.\n *\n * @param {Function} fn\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.beforeAll = function(title, fn){\n  if (this.pending) return this;\n  if ('function' === typeof title) {\n    fn = title;\n    title = fn.name;\n  }\n  title = '\"before all\" hook' + (title ? ': ' + title : '');\n\n  var hook = new Hook(title, fn);\n  hook.parent = this;\n  hook.timeout(this.timeout());\n  hook.enableTimeouts(this.enableTimeouts());\n  hook.slow(this.slow());\n  hook.ctx = this.ctx;\n  this._beforeAll.push(hook);\n  this.emit('beforeAll', hook);\n  return this;\n};\n\n/**\n * Run `fn(test[, done])` after running tests.\n *\n * @param {Function} fn\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.afterAll = function(title, fn){\n  if (this.pending) return this;\n  if ('function' === typeof title) {\n    fn = title;\n    title = fn.name;\n  }\n  title = '\"after all\" hook' + (title ? ': ' + title : '');\n\n  var hook = new Hook(title, fn);\n  hook.parent = this;\n  hook.timeout(this.timeout());\n  hook.enableTimeouts(this.enableTimeouts());\n  hook.slow(this.slow());\n  hook.ctx = this.ctx;\n  this._afterAll.push(hook);\n  this.emit('afterAll', hook);\n  return this;\n};\n\n/**\n * Run `fn(test[, done])` before each test case.\n *\n * @param {Function} fn\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.beforeEach = function(title, fn){\n  if (this.pending) return this;\n  if ('function' === typeof title) {\n    fn = title;\n    title = fn.name;\n  }\n  title = '\"before each\" hook' + (title ? ': ' + title : '');\n\n  var hook = new Hook(title, fn);\n  hook.parent = this;\n  hook.timeout(this.timeout());\n  hook.enableTimeouts(this.enableTimeouts());\n  hook.slow(this.slow());\n  hook.ctx = this.ctx;\n  this._beforeEach.push(hook);\n  this.emit('beforeEach', hook);\n  return this;\n};\n\n/**\n * Run `fn(test[, done])` after each test case.\n *\n * @param {Function} fn\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.afterEach = function(title, fn){\n  if (this.pending) return this;\n  if ('function' === typeof title) {\n    fn = title;\n    title = fn.name;\n  }\n  title = '\"after each\" hook' + (title ? ': ' + title : '');\n\n  var hook = new Hook(title, fn);\n  hook.parent = this;\n  hook.timeout(this.timeout());\n  hook.enableTimeouts(this.enableTimeouts());\n  hook.slow(this.slow());\n  hook.ctx = this.ctx;\n  this._afterEach.push(hook);\n  this.emit('afterEach', hook);\n  return this;\n};\n\n/**\n * Add a test `suite`.\n *\n * @param {Suite} suite\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.addSuite = function(suite){\n  suite.parent = this;\n  suite.timeout(this.timeout());\n  suite.enableTimeouts(this.enableTimeouts());\n  suite.slow(this.slow());\n  suite.bail(this.bail());\n  this.suites.push(suite);\n  this.emit('suite', suite);\n  return this;\n};\n\n/**\n * Add a `test` to this suite.\n *\n * @param {Test} test\n * @return {Suite} for chaining\n * @api private\n */\n\nSuite.prototype.addTest = function(test){\n  test.parent = this;\n  test.timeout(this.timeout());\n  test.enableTimeouts(this.enableTimeouts());\n  test.slow(this.slow());\n  test.ctx = this.ctx;\n  this.tests.push(test);\n  this.emit('test', test);\n  return this;\n};\n\n/**\n * Return the full title generated by recursively\n * concatenating the parent's full title.\n *\n * @return {String}\n * @api public\n */\n\nSuite.prototype.fullTitle = function(){\n  if (this.parent) {\n    var full = this.parent.fullTitle();\n    if (full) return full + ' ' + this.title;\n  }\n  return this.title;\n};\n\n/**\n * Return the total number of tests.\n *\n * @return {Number}\n * @api public\n */\n\nSuite.prototype.total = function(){\n  return utils.reduce(this.suites, function(sum, suite){\n    return sum + suite.total();\n  }, 0) + this.tests.length;\n};\n\n/**\n * Iterates through each suite recursively to find\n * all tests. Applies a function in the format\n * `fn(test)`.\n *\n * @param {Function} fn\n * @return {Suite}\n * @api private\n */\n\nSuite.prototype.eachTest = function(fn){\n  utils.forEach(this.tests, fn);\n  utils.forEach(this.suites, function(suite){\n    suite.eachTest(fn);\n  });\n  return this;\n};\n\n}); // module: suite.js\n\nrequire.register(\"test.js\", function(module, exports, require){\n\n/**\n * Module dependencies.\n */\n\nvar Runnable = require('./runnable');\n\n/**\n * Expose `Test`.\n */\n\nmodule.exports = Test;\n\n/**\n * Initialize a new `Test` with the given `title` and callback `fn`.\n *\n * @param {String} title\n * @param {Function} fn\n * @api private\n */\n\nfunction Test(title, fn) {\n  Runnable.call(this, title, fn);\n  this.pending = !fn;\n  this.type = 'test';\n}\n\n/**\n * Inherit from `Runnable.prototype`.\n */\n\nfunction F(){};\nF.prototype = Runnable.prototype;\nTest.prototype = new F;\nTest.prototype.constructor = Test;\n\n\n}); // module: test.js\n\nrequire.register(\"utils.js\", function(module, exports, require){\n/**\n * Module dependencies.\n */\n\nvar fs = require('browser/fs')\n  , path = require('browser/path')\n  , join = path.join\n  , debug = require('browser/debug')('mocha:watch');\n\n/**\n * Ignored directories.\n */\n\nvar ignore = ['node_modules', '.git'];\n\n/**\n * Escape special characters in the given string of html.\n *\n * @param  {String} html\n * @return {String}\n * @api private\n */\n\nexports.escape = function(html){\n  return String(html)\n    .replace(/&/g, '&amp;')\n    .replace(/\"/g, '&quot;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;');\n};\n\n/**\n * Array#forEach (<=IE8)\n *\n * @param {Array} array\n * @param {Function} fn\n * @param {Object} scope\n * @api private\n */\n\nexports.forEach = function(arr, fn, scope){\n  for (var i = 0, l = arr.length; i < l; i++)\n    fn.call(scope, arr[i], i);\n};\n\n/**\n * Array#map (<=IE8)\n *\n * @param {Array} array\n * @param {Function} fn\n * @param {Object} scope\n * @api private\n */\n\nexports.map = function(arr, fn, scope){\n  var result = [];\n  for (var i = 0, l = arr.length; i < l; i++)\n    result.push(fn.call(scope, arr[i], i));\n  return result;\n};\n\n/**\n * Array#indexOf (<=IE8)\n *\n * @parma {Array} arr\n * @param {Object} obj to find index of\n * @param {Number} start\n * @api private\n */\n\nexports.indexOf = function(arr, obj, start){\n  for (var i = start || 0, l = arr.length; i < l; i++) {\n    if (arr[i] === obj)\n      return i;\n  }\n  return -1;\n};\n\n/**\n * Array#reduce (<=IE8)\n *\n * @param {Array} array\n * @param {Function} fn\n * @param {Object} initial value\n * @api private\n */\n\nexports.reduce = function(arr, fn, val){\n  var rval = val;\n\n  for (var i = 0, l = arr.length; i < l; i++) {\n    rval = fn(rval, arr[i], i, arr);\n  }\n\n  return rval;\n};\n\n/**\n * Array#filter (<=IE8)\n *\n * @param {Array} array\n * @param {Function} fn\n * @api private\n */\n\nexports.filter = function(arr, fn){\n  var ret = [];\n\n  for (var i = 0, l = arr.length; i < l; i++) {\n    var val = arr[i];\n    if (fn(val, i, arr)) ret.push(val);\n  }\n\n  return ret;\n};\n\n/**\n * Object.keys (<=IE8)\n *\n * @param {Object} obj\n * @return {Array} keys\n * @api private\n */\n\nexports.keys = Object.keys || function(obj) {\n  var keys = []\n    , has = Object.prototype.hasOwnProperty // for `window` on <=IE8\n\n  for (var key in obj) {\n    if (has.call(obj, key)) {\n      keys.push(key);\n    }\n  }\n\n  return keys;\n};\n\n/**\n * Watch the given `files` for changes\n * and invoke `fn(file)` on modification.\n *\n * @param {Array} files\n * @param {Function} fn\n * @api private\n */\n\nexports.watch = function(files, fn){\n  var options = { interval: 100 };\n  files.forEach(function(file){\n    debug('file %s', file);\n    fs.watchFile(file, options, function(curr, prev){\n      if (prev.mtime < curr.mtime) fn(file);\n    });\n  });\n};\n\n/**\n * Ignored files.\n */\n\nfunction ignored(path){\n  return !~ignore.indexOf(path);\n}\n\n/**\n * Lookup files in the given `dir`.\n *\n * @return {Array}\n * @api private\n */\n\nexports.files = function(dir, ext, ret){\n  ret = ret || [];\n  ext = ext || ['js'];\n\n  var re = new RegExp('\\\\.(' + ext.join('|') + ')$');\n\n  fs.readdirSync(dir)\n  .filter(ignored)\n  .forEach(function(path){\n    path = join(dir, path);\n    if (fs.statSync(path).isDirectory()) {\n      exports.files(path, ext, ret);\n    } else if (path.match(re)) {\n      ret.push(path);\n    }\n  });\n\n  return ret;\n};\n\n/**\n * Compute a slug from the given `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.slug = function(str){\n  return str\n    .toLowerCase()\n    .replace(/ +/g, '-')\n    .replace(/[^-\\w]/g, '');\n};\n\n/**\n * Strip the function definition from `str`,\n * and re-indent for pre whitespace.\n */\n\nexports.clean = function(str) {\n  str = str\n    .replace(/\\r\\n?|[\\n\\u2028\\u2029]/g, \"\\n\").replace(/^\\uFEFF/, '')\n    .replace(/^function *\\(.*\\) *{|\\(.*\\) *=> *{?/, '')\n    .replace(/\\s+\\}$/, '');\n\n  var spaces = str.match(/^\\n?( *)/)[1].length\n    , tabs = str.match(/^\\n?(\\t*)/)[1].length\n    , re = new RegExp('^\\n?' + (tabs ? '\\t' : ' ') + '{' + (tabs ? tabs : spaces) + '}', 'gm');\n\n  str = str.replace(re, '');\n\n  return exports.trim(str);\n};\n\n/**\n * Escape regular expression characters in `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.escapeRegexp = function(str){\n  return str.replace(/[-\\\\^$*+?.()|[\\]{}]/g, \"\\\\$&\");\n};\n\n/**\n * Trim the given `str`.\n *\n * @param {String} str\n * @return {String}\n * @api private\n */\n\nexports.trim = function(str){\n  return str.replace(/^\\s+|\\s+$/g, '');\n};\n\n/**\n * Parse the given `qs`.\n *\n * @param {String} qs\n * @return {Object}\n * @api private\n */\n\nexports.parseQuery = function(qs){\n  return exports.reduce(qs.replace('?', '').split('&'), function(obj, pair){\n    var i = pair.indexOf('=')\n      , key = pair.slice(0, i)\n      , val = pair.slice(++i);\n\n    obj[key] = decodeURIComponent(val);\n    return obj;\n  }, {});\n};\n\n/**\n * Highlight the given string of `js`.\n *\n * @param {String} js\n * @return {String}\n * @api private\n */\n\nfunction highlight(js) {\n  return js\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\\/\\/(.*)/gm, '<span class=\"comment\">//$1</span>')\n    .replace(/('.*?')/gm, '<span class=\"string\">$1</span>')\n    .replace(/(\\d+\\.\\d+)/gm, '<span class=\"number\">$1</span>')\n    .replace(/(\\d+)/gm, '<span class=\"number\">$1</span>')\n    .replace(/\\bnew[ \\t]+(\\w+)/gm, '<span class=\"keyword\">new</span> <span class=\"init\">$1</span>')\n    .replace(/\\b(function|new|throw|return|var|if|else)\\b/gm, '<span class=\"keyword\">$1</span>')\n}\n\n/**\n * Highlight the contents of tag `name`.\n *\n * @param {String} name\n * @api private\n */\n\nexports.highlightTags = function(name) {\n  var code = document.getElementsByTagName(name);\n  for (var i = 0, len = code.length; i < len; ++i) {\n    code[i].innerHTML = highlight(code[i].innerHTML);\n  }\n};\n\n\n/**\n * Stringify `obj`.\n *\n * @param {Object} obj\n * @return {String}\n * @api private\n */\n\nexports.stringify = function(obj) {\n  if (obj instanceof RegExp) return obj.toString();\n  return JSON.stringify(exports.canonicalize(obj), null, 2).replace(/,(\\n|$)/g, '$1');\n}\n\n/**\n * Return a new object that has the keys in sorted order.\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nexports.canonicalize = function(obj, stack) {\n   stack = stack || [];\n\n   if (exports.indexOf(stack, obj) !== -1) return '[Circular]';\n\n   var canonicalizedObj;\n\n   if ({}.toString.call(obj) === '[object Array]') {\n     stack.push(obj);\n     canonicalizedObj = exports.map(obj, function(item) {\n       return exports.canonicalize(item, stack);\n     });\n     stack.pop();\n   } else if (typeof obj === 'object' && obj !== null) {\n     stack.push(obj);\n     canonicalizedObj = {};\n     exports.forEach(exports.keys(obj).sort(), function(key) {\n       canonicalizedObj[key] = exports.canonicalize(obj[key], stack);\n     });\n     stack.pop();\n   } else {\n     canonicalizedObj = obj;\n   }\n\n   return canonicalizedObj;\n }\n\n}); // module: utils.js\n// The global object is \"self\" in Web Workers.\nvar global = (function() { return this; })();\n\n/**\n * Save timer references to avoid Sinon interfering (see GH-237).\n */\n\nvar Date = global.Date;\nvar setTimeout = global.setTimeout;\nvar setInterval = global.setInterval;\nvar clearTimeout = global.clearTimeout;\nvar clearInterval = global.clearInterval;\n\n/**\n * Node shims.\n *\n * These are meant only to allow\n * mocha.js to run untouched, not\n * to allow running node code in\n * the browser.\n */\n\nvar process = {};\nprocess.exit = function(status){};\nprocess.stdout = {};\n\nvar uncaughtExceptionHandlers = [];\n\nvar originalOnerrorHandler = global.onerror;\n\n/**\n * Remove uncaughtException listener.\n * Revert to original onerror handler if previously defined.\n */\n\nprocess.removeListener = function(e, fn){\n  if ('uncaughtException' == e) {\n    if (originalOnerrorHandler) {\n      global.onerror = originalOnerrorHandler;\n    } else {\n      global.onerror = function() {};\n    }\n    var i = Mocha.utils.indexOf(uncaughtExceptionHandlers, fn);\n    if (i != -1) { uncaughtExceptionHandlers.splice(i, 1); }\n  }\n};\n\n/**\n * Implements uncaughtException listener.\n */\n\nprocess.on = function(e, fn){\n  if ('uncaughtException' == e) {\n    global.onerror = function(err, url, line){\n      fn(new Error(err + ' (' + url + ':' + line + ')'));\n      return true;\n    };\n    uncaughtExceptionHandlers.push(fn);\n  }\n};\n\n/**\n * Expose mocha.\n */\n\nvar Mocha = global.Mocha = require('mocha'),\n    mocha = global.mocha = new Mocha({ reporter: 'html' });\n\n// The BDD UI is registered by default, but no UI will be functional in the\n// browser without an explicit call to the overridden `mocha.ui` (see below).\n// Ensure that this default UI does not expose its methods to the global scope.\nmocha.suite.removeAllListeners('pre-require');\n\nvar immediateQueue = []\n  , immediateTimeout;\n\nfunction timeslice() {\n  var immediateStart = new Date().getTime();\n  while (immediateQueue.length && (new Date().getTime() - immediateStart) < 100) {\n    immediateQueue.shift()();\n  }\n  if (immediateQueue.length) {\n    immediateTimeout = setTimeout(timeslice, 0);\n  } else {\n    immediateTimeout = null;\n  }\n}\n\n/**\n * High-performance override of Runner.immediately.\n */\n\nMocha.Runner.immediately = function(callback) {\n  immediateQueue.push(callback);\n  if (!immediateTimeout) {\n    immediateTimeout = setTimeout(timeslice, 0);\n  }\n};\n\n/**\n * Function to allow assertion libraries to throw errors directly into mocha.\n * This is useful when running tests in a browser because window.onerror will\n * only receive the 'message' attribute of the Error.\n */\nmocha.throwError = function(err) {\n  Mocha.utils.forEach(uncaughtExceptionHandlers, function (fn) {\n    fn(err);\n  });\n  throw err;\n};\n\n/**\n * Override ui to ensure that the ui functions are initialized.\n * Normally this would happen in Mocha.prototype.loadFiles.\n */\n\nmocha.ui = function(ui){\n  Mocha.prototype.ui.call(this, ui);\n  this.suite.emit('pre-require', global, null, this);\n  return this;\n};\n\n/**\n * Setup mocha with the given setting options.\n */\n\nmocha.setup = function(opts){\n  if ('string' == typeof opts) opts = { ui: opts };\n  for (var opt in opts) this[opt](opts[opt]);\n  return this;\n};\n\n/**\n * Run mocha, returning the Runner.\n */\n\nmocha.run = function(fn){\n  var options = mocha.options;\n  mocha.globals('location');\n\n  var query = Mocha.utils.parseQuery(global.location.search || '');\n  if (query.grep) mocha.grep(query.grep);\n  if (query.invert) mocha.invert();\n\n  return Mocha.prototype.run.call(mocha, function(err){\n    // The DOM Document is not available in Web Workers.\n    if (global.document) {\n      Mocha.utils.highlightTags('code');\n    }\n    if (fn) fn(err);\n  });\n};\n\n/**\n * Expose the process shim.\n */\n\nMocha.process = process;\n})();","@charset \"utf-8\";\n\nbody {\n  margin:0;\n}\n\n#mocha {\n  font: 20px/1.5 \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n  margin: 60px 50px;\n}\n\n#mocha ul,\n#mocha li {\n  margin: 0;\n  padding: 0;\n}\n\n#mocha ul {\n  list-style: none;\n}\n\n#mocha h1,\n#mocha h2 {\n  margin: 0;\n}\n\n#mocha h1 {\n  margin-top: 15px;\n  font-size: 1em;\n  font-weight: 200;\n}\n\n#mocha h1 a {\n  text-decoration: none;\n  color: inherit;\n}\n\n#mocha h1 a:hover {\n  text-decoration: underline;\n}\n\n#mocha .suite .suite h1 {\n  margin-top: 0;\n  font-size: .8em;\n}\n\n#mocha .hidden {\n  display: none;\n}\n\n#mocha h2 {\n  font-size: 12px;\n  font-weight: normal;\n  cursor: pointer;\n}\n\n#mocha .suite {\n  margin-left: 15px;\n}\n\n#mocha .test {\n  margin-left: 15px;\n  overflow: hidden;\n}\n\n#mocha .test.pending:hover h2::after {\n  content: '(pending)';\n  font-family: arial, sans-serif;\n}\n\n#mocha .test.pass.medium .duration {\n  background: #c09853;\n}\n\n#mocha .test.pass.slow .duration {\n  background: #b94a48;\n}\n\n#mocha .test.pass::before {\n  content: '✓';\n  font-size: 12px;\n  display: block;\n  float: left;\n  margin-right: 5px;\n  color: #00d6b2;\n}\n\n#mocha .test.pass .duration {\n  font-size: 9px;\n  margin-left: 5px;\n  padding: 2px 5px;\n  color: #fff;\n  -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n  -moz-box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n  box-shadow: inset 0 1px 1px rgba(0,0,0,.2);\n  -webkit-border-radius: 5px;\n  -moz-border-radius: 5px;\n  -ms-border-radius: 5px;\n  -o-border-radius: 5px;\n  border-radius: 5px;\n}\n\n#mocha .test.pass.fast .duration {\n  display: none;\n}\n\n#mocha .test.pending {\n  color: #0b97c4;\n}\n\n#mocha .test.pending::before {\n  content: '◦';\n  color: #0b97c4;\n}\n\n#mocha .test.fail {\n  color: #c00;\n}\n\n#mocha .test.fail pre {\n  color: black;\n}\n\n#mocha .test.fail::before {\n  content: '✖';\n  font-size: 12px;\n  display: block;\n  float: left;\n  margin-right: 5px;\n  color: #c00;\n}\n\n#mocha .test pre.error {\n  color: #c00;\n  max-height: 300px;\n  overflow: auto;\n}\n\n/**\n * (1): approximate for browsers not supporting calc\n * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)\n *      ^^ seriously\n */\n#mocha .test pre {\n  display: block;\n  float: left;\n  clear: left;\n  font: 12px/1.5 monaco, monospace;\n  margin: 5px;\n  padding: 15px;\n  border: 1px solid #eee;\n  max-width: 85%; /*(1)*/\n  max-width: calc(100% - 42px); /*(2)*/\n  word-wrap: break-word;\n  border-bottom-color: #ddd;\n  -webkit-border-radius: 3px;\n  -webkit-box-shadow: 0 1px 3px #eee;\n  -moz-border-radius: 3px;\n  -moz-box-shadow: 0 1px 3px #eee;\n  border-radius: 3px;\n}\n\n#mocha .test h2 {\n  position: relative;\n}\n\n#mocha .test a.replay {\n  position: absolute;\n  top: 3px;\n  right: 0;\n  text-decoration: none;\n  vertical-align: middle;\n  display: block;\n  width: 15px;\n  height: 15px;\n  line-height: 15px;\n  text-align: center;\n  background: #eee;\n  font-size: 15px;\n  -moz-border-radius: 15px;\n  border-radius: 15px;\n  -webkit-transition: opacity 200ms;\n  -moz-transition: opacity 200ms;\n  transition: opacity 200ms;\n  opacity: 0.3;\n  color: #888;\n}\n\n#mocha .test:hover a.replay {\n  opacity: 1;\n}\n\n#mocha-report.pass .test.fail {\n  display: none;\n}\n\n#mocha-report.fail .test.pass {\n  display: none;\n}\n\n#mocha-report.pending .test.pass,\n#mocha-report.pending .test.fail {\n  display: none;\n}\n#mocha-report.pending .test.pass.pending {\n  display: block;\n}\n\n#mocha-error {\n  color: #c00;\n  font-size: 1.5em;\n  font-weight: 100;\n  letter-spacing: 1px;\n}\n\n#mocha-stats {\n  position: fixed;\n  top: 15px;\n  right: 10px;\n  font-size: 12px;\n  margin: 0;\n  color: #888;\n  z-index: 1;\n}\n\n#mocha-stats .progress {\n  float: right;\n  padding-top: 0;\n}\n\n#mocha-stats em {\n  color: black;\n}\n\n#mocha-stats a {\n  text-decoration: none;\n  color: inherit;\n}\n\n#mocha-stats a:hover {\n  border-bottom: 1px solid #eee;\n}\n\n#mocha-stats li {\n  display: inline-block;\n  margin: 0 5px;\n  list-style: none;\n  padding-top: 11px;\n}\n\n#mocha-stats canvas {\n  width: 40px;\n  height: 40px;\n}\n\n#mocha code .comment { color: #ddd; }\n#mocha code .init { color: #2f6fad; }\n#mocha code .string { color: #5890ad; }\n#mocha code .keyword { color: #8a6343; }\n#mocha code .number { color: #2f6fad; }\n\n@media screen and (max-device-width: 480px) {\n  #mocha {\n    margin: 60px 0px;\n  }\n\n  #mocha #stats {\n    position: absolute;\n  }\n}\n","// Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n//\n// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt\n// The complete set of authors may be found at polymer.github.io/AUTHORS.txt\n// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt\n// Code distributed by Google as part of the polymer project is also subject to\n// an additional IP rights grant found at polymer.github.io/PATENTS.txt\n(function(scope) {\n'use strict';\n\nfunction parse(stack) {\n  var rawLines = stack.split('\\n');\n\n  var stackyLines = compact(rawLines.map(parseStackyLine));\n  if (stackyLines.length === rawLines.length) return stackyLines;\n\n  var v8Lines = compact(rawLines.map(parseV8Line));\n  if (v8Lines.length > 0) return v8Lines;\n\n  var geckoLines = compact(rawLines.map(parseGeckoLine));\n  if (geckoLines.length > 0) return geckoLines;\n\n  throw new Error('Unknown stack format: ' + stack);\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/Stack\nvar GECKO_LINE = /^(?:([^@]*)@)?(.*?):(\\d+)(?::(\\d+))?$/;\n\nfunction parseGeckoLine(line) {\n  var match = line.match(GECKO_LINE);\n  if (!match) return null;\n  return {\n    method:   match[1] || '',\n    location: match[2] || '',\n    line:     parseInt(match[3]) || 0,\n    column:   parseInt(match[4]) || 0,\n  };\n}\n\n// https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi\nvar V8_OUTER1 = /^\\s*(eval )?at (.*) \\((.*)\\)$/;\nvar V8_OUTER2 = /^\\s*at()() (\\S+)$/;\nvar V8_INNER  = /^\\(?([^\\(]+):(\\d+):(\\d+)\\)?$/;\n\nfunction parseV8Line(line) {\n  var outer = line.match(V8_OUTER1) || line.match(V8_OUTER2);\n  if (!outer) return null;\n  var inner = outer[3].match(V8_INNER);\n  if (!inner) return null;\n\n  var method = outer[2] || '';\n  if (outer[1]) method = 'eval at ' + method;\n  return {\n    method:   method,\n    location: inner[1] || '',\n    line:     parseInt(inner[2]) || 0,\n    column:   parseInt(inner[3]) || 0,\n  };\n}\n\n// Stacky.formatting.pretty\n\nvar STACKY_LINE = /^\\s*(.+) at (.+):(\\d+):(\\d+)$/;\n\nfunction parseStackyLine(line) {\n  var match = line.match(STACKY_LINE);\n  if (!match) return null;\n  return {\n    method:   match[1] || '',\n    location: match[2] || '',\n    line:     parseInt(match[3]) || 0,\n    column:   parseInt(match[4]) || 0,\n  };\n}\n\n// Helpers\n\nfunction compact(array) {\n  var result = [];\n  array.forEach(function(value) {\n    if (value) {\n      result.push(value);\n    }\n  });\n  return result;\n}\n\nscope.parse           = parse;\nscope.parseGeckoLine  = parseGeckoLine;\nscope.parseV8Line     = parseV8Line;\nscope.parseStackyLine = parseStackyLine;\n})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {}));\n","// Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n//\n// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt\n// The complete set of authors may be found at polymer.github.io/AUTHORS.txt\n// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt\n// Code distributed by Google as part of the polymer project is also subject to\n// an additional IP rights grant found at polymer.github.io/PATENTS.txt\n(function(scope) {\n'use strict';\n\nvar parse = scope.parse || require('./parsing').parse;\n\nscope.defaults = {\n  // Methods are aligned up to this much padding.\n  maxMethodPadding: 40,\n  // A string to prefix each line with.\n  indent: '',\n  // A string to show for stack lines that are missing a method.\n  methodPlaceholder: '<unknown>',\n  // A list of Strings/RegExps that will be stripped from `location` values on\n  // each line (via `String#replace`).\n  locationStrip: [],\n  // A list of Strings/RegExps that indicate that a line is *not* important, and\n  // should be styled as such.\n  unimportantLocation: [],\n  // A filter function to completely remove lines\n  filter: function() { return false; },\n  // styles are functions that take a string and return that string when styled.\n  styles: {\n    method:      passthrough,\n    location:    passthrough,\n    line:        passthrough,\n    column:      passthrough,\n    unimportant: passthrough,\n  },\n};\n\n// For Stacky-in-Node, we default to colored stacks.\nif (typeof require === 'function') {\n  var chalk = require('chalk');\n\n  scope.defaults.styles = {\n    method:      chalk.magenta,\n    location:    chalk.blue,\n    line:        chalk.cyan,\n    column:      chalk.cyan,\n    unimportant: chalk.dim,\n  };\n}\n\nfunction pretty(stackOrParsed, options) {\n  options = mergeDefaults(options || {}, scope.defaults);\n  var lines = Array.isArray(stackOrParsed) ? stackOrParsed : parse(stackOrParsed);\n  lines = clean(lines, options);\n\n  var padSize = methodPadding(lines, options);\n  var parts = lines.map(function(line) {\n    var method   = line.method || options.methodPlaceholder;\n    var pad      = options.indent + padding(padSize - method.length);\n    var location = [\n      options.styles.location(line.location),\n      options.styles.line(line.line),\n      options.styles.column(line.column),\n    ].join(':');\n\n    var text = pad + options.styles.method(method) + ' at ' + location;\n    if (!line.important) {\n      text = options.styles.unimportant(text);\n    }\n    return text;\n  });\n\n  return parts.join('\\n');\n}\n\nfunction clean(lines, options) {\n  var result = [];\n  for (var i = 0, line; line = lines[i]; i++) {\n    if (options.filter(line)) continue;\n    line.location  = cleanLocation(line.location, options);\n    line.important = isImportant(line, options);\n    result.push(line);\n  }\n\n  return result;\n}\n\n// Utility\n\nfunction passthrough(string) {\n  return string;\n}\n\nfunction mergeDefaults(options, defaults) {\n  var result = Object.create(defaults);\n  Object.keys(options).forEach(function(key) {\n    var value = options[key];\n    if (typeof value === 'object' && !Array.isArray(value)) {\n      value = mergeDefaults(value, defaults[key]);\n    }\n    result[key] = value;\n  });\n  return result;\n}\n\nfunction methodPadding(lines, options) {\n  var size = options.methodPlaceholder.length;\n  for (var i = 0, line; line = lines[i]; i++) {\n    size = Math.min(options.maxMethodPadding, Math.max(size, line.method.length));\n  }\n  return size;\n}\n\nfunction padding(length) {\n  var result = '';\n  for (var i = 0; i < length; i++) {\n    result = result + ' ';\n  }\n  return result;\n}\n\nfunction cleanLocation(location, options) {\n  if (options.locationStrip) {\n    for (var i = 0, matcher; matcher = options.locationStrip[i]; i++) {\n      location = location.replace(matcher, '');\n    }\n  }\n\n  return location;\n}\n\nfunction isImportant(line, options) {\n  if (options.unimportantLocation) {\n    for (var i = 0, matcher; matcher = options.unimportantLocation[i]; i++) {\n      if (line.location.match(matcher)) return false;\n    }\n  }\n\n  return true;\n}\n\nscope.clean  = clean;\nscope.pretty = pretty;\n})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {}));\n\n","// Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n//\n// This code may only be used under the BSD style license found at polymer.github.io/LICENSE.txt\n// The complete set of authors may be found at polymer.github.io/AUTHORS.txt\n// The complete set of contributors may be found at polymer.github.io/CONTRIBUTORS.txt\n// Code distributed by Google as part of the polymer project is also subject to\n// an additional IP rights grant found at polymer.github.io/PATENTS.txt\n(function(scope) {\n'use strict';\n\nvar parse  = scope.parse  || require('./parsing').parse;\nvar pretty = scope.pretty || require('./formatting').pretty;\n\nfunction normalize(error, prettyOptions) {\n  if (error.parsedStack) return error;\n  var message = error.message || error.description || error || '<unknown error>';\n  var parsedStack = [];\n  try {\n    parsedStack = parse(error.stack || error.toString());\n  } catch (error) {\n    // Ah well.\n  }\n\n  if (parsedStack.length === 0 && error.fileName) {\n    parsedStack.push({\n      method:   '',\n      location: error.fileName,\n      line:     error.lineNumber,\n      column:   error.columnNumber,\n    });\n  }\n\n  var prettyStack = message;\n  if (parsedStack.length > 0) {\n    prettyStack = prettyStack + '\\n' + pretty(parsedStack, prettyOptions);\n  }\n\n  return {\n    message:     message,\n    stack:       prettyStack,\n    parsedStack: parsedStack,\n  };\n}\n\nscope.normalize = normalize;\n})(typeof module !== 'undefined' ? module.exports : (this.Stacky = this.Stacky || {}));\n\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n/**\n * @fileoverview\n *\n * Your entry point into `web-component-tester`'s environment and configuration.\n */\n(function() {\n\nvar WCT = window.WCT = {\n  reporters: {},\n};\n\n// Configuration\n\n/** By default, we wait for any web component frameworks to load. */\nWCT.waitForFrameworks = true;\n\n/** How many `.html` suites that can be concurrently loaded & run. */\nWCT.numConcurrentSuites = 1;\n\n// Helpers\n\n// Evaluated in mocha/run.js.\nWCT._suitesToLoad = [];\nWCT._dependencies = [];\n\n// Used to share data between subSuites on client and reporters on server\nWCT.share = {};\n\n/**\n * Loads suites of tests, supporting `.js` as well as `.html` files.\n *\n * @param {!Array.<string>} files The files to load.\n */\nWCT.loadSuites = function loadSuites(files) {\n  files.forEach(function(file) {\n    if (file.slice(-3) === '.js') {\n      WCT._dependencies.push(file);\n    } else if (file.slice(-5) === '.html') {\n      WCT._suitesToLoad.push(file);\n    } else {\n      throw new Error('Unknown resource type: ' + file);\n    }\n  });\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.util = {};\n\n/**\n * @param {function()} callback A function to call when the active web component\n *     frameworks have loaded.\n */\nWCT.util.whenFrameworksReady = function(callback) {\n  WCT.util.debug(window.location.pathname, 'WCT.util.whenFrameworksReady');\n  var done = function() {\n    WCT.util.debug(window.location.pathname, 'WCT.util.whenFrameworksReady done');\n    callback();\n  };\n\n  function importsReady() {\n    window.removeEventListener('HTMLImportsLoaded', importsReady);\n    WCT.util.debug(window.location.pathname, 'HTMLImportsLoaded');\n\n    if (window.Polymer && Polymer.whenReady) {\n      Polymer.whenReady(function() {\n        WCT.util.debug(window.location.pathname, 'polymer-ready');\n        done();\n      });\n    } else {\n      done();\n    }\n  }\n\n  // All our supported framework configurations depend on imports.\n  if (!window.HTMLImports) {\n    done();\n  } else if (HTMLImports.ready) {\n    importsReady();\n  } else {\n    window.addEventListener('HTMLImportsLoaded', importsReady);\n  }\n};\n\n/**\n * @param {number} count\n * @param {string} kind\n * @return {string} '<count> <kind> tests' or '<count> <kind> test'.\n */\nWCT.util.pluralizedStat = function pluralizedStat(count, kind) {\n  if (count === 1) {\n    return count + ' ' + kind + ' test';\n  } else {\n    return count + ' ' + kind + ' tests';\n  }\n};\n\n/**\n * @param {string} path The URI of the script to load.\n * @param {function} done\n */\nWCT.util.loadScript = function loadScript(path, done) {\n  var script = document.createElement('script');\n  script.src = path + '?' + Math.random();\n  script.onload = done.bind(null, null);\n  script.onerror = done.bind(null, 'Failed to load script ' + script.src);\n  document.head.appendChild(script);\n};\n\n/**\n * @param {...*} var_args Logs values to the console when `WCT.debug` is true.\n */\nWCT.util.debug = function debug(var_args) {\n  if (!WCT.debug) return;\n  console.debug.apply(console, arguments);\n};\n\n// URL Processing\n\n/**\n * @param {string} opt_query A query string to parse.\n * @return {!Object.<string, !Array.<string>>} All params on the URL's query.\n */\nWCT.util.getParams = function getParams(opt_query) {\n  var query = opt_query || window.location.search;\n  if (query.substring(0, 1) === '?') {\n    query = query.substring(1);\n  }\n  // python's SimpleHTTPServer tacks a `/` on the end of query strings :(\n  if (query.slice(-1) === '/') {\n    query = query.substring(0, query.length - 1);\n  }\n  if (query === '') return {};\n\n  var result = {};\n  query.split('&').forEach(function(part) {\n    var pair = part.split('=');\n    if (pair.length !== 2) {\n      console.warn('Invalid URL query part:', part);\n      return;\n    }\n    var key   = decodeURIComponent(pair[0]);\n    var value = decodeURIComponent(pair[1]);\n\n    if (!result[key]) {\n      result[key] = [];\n    }\n    result[key].push(value);\n  });\n\n  return result;\n};\n\n/**\n * @param {string} param The param to return a value for.\n * @return {?string} The first value for `param`, if found.\n */\nWCT.util.getParam = function getParam(param) {\n  var params = WCT.util.getParams();\n  return params[param] ? params[param][0] : null;\n};\n\n/**\n * @param {!Object.<string, !Array.<string>>} params\n * @return {string} `params` encoded as a URI query.\n */\nWCT.util.paramsToQuery = function paramsToQuery(params) {\n  var pairs = [];\n  Object.keys(params).forEach(function(key) {\n    params[key].forEach(function(value) {\n      pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    });\n  });\n  return '?' + pairs.join('&');\n};\n\n/** @return {string} `location` relative to the current window. */\nWCT.util.relativeLocation = function relativeLocation(location) {\n  var path = location.pathname;\n  var basePath = window.location.pathname.match(/^.*\\//)[0];\n  if (path.indexOf(basePath) === 0) {\n    path = path.substring(basePath.length);\n  }\n  return path;\n};\n\n/**\n * Like `async.parallelLimit`, but our own so that we don't force a dependency\n * on downstream code.\n *\n * @param {!Array.<function(function(*))>} runners Runners that call their given\n *     Node-style callback when done.\n * @param {number|function(*)} limit Maximum number of concurrent runners.\n *     (optional).\n * @param {?function(*)} done Callback that should be triggered once all runners\n *     have completed, or encountered an error.\n */\nWCT.util.parallel = function parallel(runners, limit, done) {\n  if (typeof limit !== 'number') {\n    done  = limit;\n    limit = 0;\n  }\n  if (!runners.length) return done();\n\n  var called    = false;\n  var total     = runners.length;\n  var numActive = 0;\n  var numDone   = 0;\n\n  function runnerDone(error) {\n    if (called) return;\n    numDone = numDone + 1;\n    numActive = numActive - 1;\n\n    if (error || numDone >= total) {\n      called = true;\n      done(error);\n    } else {\n      runOne();\n    }\n  }\n\n  function runOne() {\n    if (limit && numActive >= limit) return;\n    if (!runners.length) return;\n    numActive = numActive + 1;\n    runners.shift()(runnerDone);\n  }\n  runners.forEach(runOne);\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.CLISocket = CLISocket;\n\nvar SOCKETIO_ENDPOINT = window.location.protocol + '//' + window.location.host;\nvar SOCKETIO_LIBRARY  = SOCKETIO_ENDPOINT + '/socket.io/socket.io.js';\n\n/**\n * A socket for communication between the CLI and browser runners.\n *\n * @param {string} browserId An ID generated by the CLI runner.\n * @param {!io.Socket} socket The socket.io `Socket` to communicate over.\n */\nfunction CLISocket(browserId, socket) {\n  this.browserId = browserId;\n  this.socket    = socket;\n}\n\n/**\n * @param {!Mocha.Runner} runner The Mocha `Runner` to observe, reporting\n *     interesting events back to the CLI runner.\n */\nCLISocket.prototype.observe = function observe(runner) {\n  this.emitEvent('browser-start', {\n    url: window.location.toString(),\n  });\n\n  // We only emit a subset of events that we care about, and follow a more\n  // general event format that is hopefully applicable to test runners beyond\n  // mocha.\n  //\n  // For all possible mocha events, see:\n  // https://github.com/visionmedia/mocha/blob/master/lib/runner.js#L36\n  runner.on('test', function(test) {\n    this.emitEvent('test-start', {test: getTitles(test)});\n  }.bind(this));\n\n  runner.on('test end', function(test) {\n    this.emitEvent('test-end', {\n      state:    getState(test),\n      test:     getTitles(test),\n      duration: test.duration,\n      error:    test.err,\n    });\n  }.bind(this));\n\n  runner.on('subSuite start', function(subSuite) {\n    this.emitEvent('sub-suite-start', subSuite.share);\n  }.bind(this));\n\n  runner.on('subSuite end', function(subSuite) {\n    this.emitEvent('sub-suite-end', subSuite.share);\n  }.bind(this));\n\n  runner.on('end', function() {\n    this.emitEvent('browser-end');\n  }.bind(this));\n};\n\n/**\n * @param {string} event The name of the event to fire.\n * @param {*} data Additional data to pass with the event.\n */\nCLISocket.prototype.emitEvent = function emitEvent(event, data) {\n  this.socket.emit('client-event', {\n    browserId: this.browserId,\n    event:     event,\n    data:      data,\n  });\n};\n\n/**\n * Builds a `CLISocket` if we are within a CLI-run environment; short-circuits\n * otherwise.\n *\n * @param {function(*, CLISocket)} done Node-style callback.\n */\nCLISocket.init = function init(done) {\n  var browserId = WCT.util.getParam('cli_browser_id');\n  if (!browserId) return done();\n\n  WCT.util.loadScript(SOCKETIO_LIBRARY, function(error) {\n    if (error) return done(error);\n\n    var socket = io(SOCKETIO_ENDPOINT);\n    socket.on('error', function(error) {\n      socket.off();\n      done(error);\n    });\n\n    socket.on('connect', function() {\n      socket.off();\n      done(null, new CLISocket(browserId, socket));\n    });\n  });\n};\n\n// Misc Utility\n\n/**\n * @param {!Mocha.Runnable} runnable The test or suite to extract titles from.\n * @return {!Array.<string>} The titles of the runnable and its parents.\n */\nfunction getTitles(runnable) {\n  var titles = [];\n  while (runnable && !runnable.root && runnable.title) {\n    titles.unshift(runnable.title);\n    runnable = runnable.parent;\n  }\n  return titles;\n}\n\n/**\n * @param {!Mocha.Runnable} runnable\n * @return {string}\n */\nfunction getState(runnable) {\n  if (runnable.state === 'passed') {\n    return 'passing';\n  } else if (runnable.state == 'failed') {\n    return 'failing';\n  } else if (runnable.pending) {\n    return 'pending';\n  } else {\n    return 'unknown';\n  }\n}\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\n// TODO(thedeeno): Consider renaming subsuite. IIRC, subSuite is entirely\n// distinct from mocha suite, which tripped me up badly when trying to add\n// plugin support. Perhaps something like 'batch', or 'bundle'. Something that\n// has no mocha correlate. This may also eliminate the need for root/non-root\n// suite distinctions.\n\n/**\n * A Mocha suite (or suites) run within a child iframe, but reported as if they\n * are part of the current context.\n */\nfunction SubSuite(url, parentScope) {\n  var params = WCT.util.getParams(parentScope.location.search);\n  delete params.cli_browser_id;\n  params.bust = [Math.random()];\n\n  this.url         = url + WCT.util.paramsToQuery(params);\n  this.parentScope = parentScope;\n\n  this.state = 'initializing';\n}\nWCT.SubSuite = SubSuite;\n\n// SubSuites get a pretty generous load timeout by default.\nSubSuite.loadTimeout = 30000;\n\n// We can't maintain properties on iframe elements in Firefox/Safari/???, so we\n// track subSuites by URL.\nSubSuite._byUrl = {};\n\n/**\n * @return {SubSuite} The `SubSuite` that was registered for this window.\n */\nSubSuite.current = function() {\n  return SubSuite.get(window);\n};\n\n/**\n * @param {!Window} target A window to find the SubSuite of.\n * @param {boolean} traversal Whether this is a traversal from a child window.\n * @return {SubSuite} The `SubSuite` that was registered for `target`.\n */\nSubSuite.get = function(target, traversal) {\n  var subSuite = SubSuite._byUrl[target.location.href];\n  if (subSuite) return subSuite;\n  if (window.parent === window) {\n    if (traversal) {\n      // I really hope there's no legit case for this. Infinite reloads are no good.\n      console.warn('Subsuite loaded but was never registered. This most likely is due to wonky history behavior. Reloading...');\n      window.location.reload();\n    } else {\n      return null;\n    }\n  }\n  // Otherwise, traverse.\n  return window.parent.WCT.SubSuite.get(target, true);\n};\n\n/**\n * Hangs a reference to the SubSuite's iframe-local wct object\n *\n * TODO(thedeeno): This method is odd to document so the achitecture might need\n * a little rework here. Maybe another named concept? Seeing WCT everywhere is\n * pretty confusing. Also, I don't think we need the parentScope.WCT; to limit\n * confusion I didn't include it.\n *\n * @param {object} wct The SubSuite's iframe-local wct object\n */\nSubSuite.prototype.prepare = function(wct) {\n  this.share = wct.share;\n};\n\n/**\n * Loads and runs the subsuite.\n *\n * @param {function} done Node-style callback.\n */\nSubSuite.prototype.run = function(done) {\n  WCT.util.debug('SubSuite#run', this.url);\n  this.state = 'loading';\n  this.onRunComplete = done;\n\n  this.iframe = document.createElement('iframe');\n  this.iframe.src = this.url;\n  this.iframe.classList.add('subsuite');\n\n  var container = document.getElementById('subsuites');\n  if (!container) {\n    container = document.createElement('div');\n    container.id = 'subsuites';\n    document.body.appendChild(container);\n  }\n  container.appendChild(this.iframe);\n\n  // let the iframe expand the URL for us.\n  this.url = this.iframe.src;\n  SubSuite._byUrl[this.url] = this;\n\n  this.timeoutId = setTimeout(\n      this.loaded.bind(this, new Error('Timed out loading ' + this.url)), SubSuite.loadTimeout);\n\n  this.iframe.addEventListener('error',\n      this.loaded.bind(this, new Error('Failed to load document ' + this.url)));\n\n  this.iframe.contentWindow.addEventListener('DOMContentLoaded', this.loaded.bind(this, null));\n};\n\n/**\n * Called when the sub suite's iframe has loaded (or errored during load).\n *\n * @param {*} error The error that occured, if any.\n */\nSubSuite.prototype.loaded = function(error) {\n  WCT.util.debug('SubSuite#loaded', this.url, error);\n  if (this.timeoutId) {\n    clearTimeout(this.timeoutId);\n  }\n  if (error) {\n    this.signalRunComplete(error);\n    this.done();\n  }\n};\n\n/** Called when the sub suite's tests are complete, so that it can clean up. */\nSubSuite.prototype.done = function done() {\n  WCT.util.debug('SubSuite#done', this.url, arguments);\n\n  this.signalRunComplete();\n\n  if (!this.iframe) return;\n  this.iframe.parentNode.removeChild(this.iframe);\n};\n\nSubSuite.prototype.signalRunComplete = function signalRunComplete(error) {\n  if (!this.onRunComplete) return;\n  this.state = 'complete';\n  this.onRunComplete(error);\n  this.onRunComplete = null;\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\n// polymer-test-tools (and Polymer/tools) support HTML tests where each file is\n// expected to call `done()`, which posts a message to the parent window.\nwindow.addEventListener('message', function(event) {\n  if (!event.data || (event.data !== 'ok' && !event.data.error)) return;\n  var subSuite = WCT.SubSuite.get(event.source);\n  if (!subSuite) return;\n\n  // The name of the suite as exposed to the user.\n  var path = WCT.util.relativeLocation(event.source.location);\n  var parentRunner = subSuite.parentScope.WCT._multiRunner;\n  parentRunner.emitOutOfBandTest('page-wide tests via global done()', event.data.error, path, true);\n\n  subSuite.done();\n});\n\n// Attempt to ensure that we complete a test suite if it is interrupted by a\n// document unload.\nwindow.addEventListener('unload', function(event) {\n  // Mocha's hook queue is asynchronous; but we want synchronous behavior if\n  // we've gotten to the point of unloading the document.\n  Mocha.Runner.immediately = function(callback) { callback(); };\n});\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\n/**\n * Runs `stepFn`, catching any error and passing it to `callback` (Node-style).\n * Otherwise, calls `callback` with no arguments on success.\n *\n * @param {function()} callback\n * @param {function()} stepFn\n */\nwindow.safeStep = function safeStep(callback, stepFn) {\n  var err;\n  try {\n    stepFn();\n  } catch (error) {\n    err = error;\n  }\n  callback(err);\n};\n\n/**\n * Runs your test at declaration time (before Mocha has begun tests). Handy for\n * when you need to test document initialization.\n *\n * Be aware that any errors thrown asynchronously cannot be tied to your test.\n * You may want to catch them and pass them to the done event, instead. See\n * `safeStep`.\n *\n * @param {string} name The name of the test.\n * @param {function(?function())} testFn The test function. If an argument is\n *     accepted, the test will be treated as async, just like Mocha tests.\n */\nwindow.testImmediate = function testImmediate(name, testFn) {\n  if (testFn.length > 0) {\n    return testImmediateAsync(name, testFn);\n  }\n\n  var err;\n  try {\n    testFn();\n  } catch (error) {\n    err = error;\n  }\n\n  test(name, function(done) {\n    done(err);\n  });\n};\n\n/**\n * An async-only variant of `testImmediate`.\n *\n * @param {string} name\n * @param {function(?function())} testFn\n */\nwindow.testImmediateAsync = function testImmediateAsync(name, testFn) {\n  var testComplete = false;\n  var err;\n\n  test(name, function(done) {\n    var intervalId = setInterval(function() {\n      if (!testComplete) return;\n      clearInterval(intervalId);\n      done(err);\n    }, 10);\n  });\n\n  try {\n    testFn(function(error) {\n      if (error) err = error;\n      testComplete = true;\n    });\n  } catch (error) {\n    err = error;\n  }\n};\n\n/**\n * Triggers a flush of any pending events, observations, etc and calls you back\n * after they have been processed.\n *\n * @param {function()} callback\n */\nwindow.flush = function flush(callback) {\n  // Ideally, this function would be a call to Polymer.flush, but that doesn't\n  // support a callback yet (https://github.com/Polymer/polymer-dev/issues/115),\n  // ...and there's cross-browser flakiness to deal with.\n\n  // Make sure that we're invoking the callback with no arguments so that the\n  // caller can pass Mocha callbacks, etc.\n  var done = function done() { callback(); };\n\n  // Because endOfMicrotask is flaky for IE, we perform microtask checkpoints\n  // ourselves (https://github.com/Polymer/polymer-dev/issues/114):\n  var isIE = navigator.appName == 'Microsoft Internet Explorer';\n  if (isIE && window.Platform && window.Platform.performMicrotaskCheckpoint) {\n    var reallyDone = done;\n    done = function doneIE() {\n      Platform.performMicrotaskCheckpoint();\n      setTimeout(reallyDone, 0);\n    };\n  }\n\n  // Everyone else gets a regular flush.\n  var scope = window.Polymer || window.WebComponents;\n  if (scope && scope.flush) {\n    scope.flush();\n  }\n\n  // Ensure that we are creating a new _task_ to allow all active microtasks to\n  // finish (the code you're testing may be using endOfMicrotask, too).\n  setTimeout(done, 0);\n};\n\n/**\n * Advances a single animation frame.\n *\n * Calls `flush`, `requestAnimationFrame`, `flush`, and `callback` sequentially\n * @param {function()} callback\n */\nwindow.animationFrameFlush = function animationFrameFlush(callback) {\n  flush(function() {\n    requestAnimationFrame(function() {\n      flush(callback);\n    });\n  });\n};\n\n/**\n * DEPRECATED: Use `flush`.\n * @param {function} callback\n */\nwindow.asyncPlatformFlush = function asyncPlatformFlush(callback) {\n  console.warn('asyncPlatformFlush is deprecated in favor of the more terse flush()');\n  return window.flush(callback);\n};\n\n/**\n *\n */\nwindow.waitFor = function waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime) {\n  timeoutTime = timeoutTime || Date.now() + (timeout || 1000);\n  intervalOrMutationEl = intervalOrMutationEl || 32;\n  try {\n    fn();\n  } catch (e) {\n    if (Date.now() > timeoutTime) {\n      throw e;\n    } else {\n      if (isNaN(intervalOrMutationEl)) {\n        intervalOrMutationEl.onMutation(intervalOrMutationEl, function() {\n          waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime);\n        });\n      } else {\n        setTimeout(function() {\n          waitFor(fn, next, intervalOrMutationEl, timeout, timeoutTime);\n        }, intervalOrMutationEl);\n      }\n      return;\n    }\n  }\n  next();\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.MultiRunner = MultiRunner;\n\nvar STACKY_CONFIG = {\n  indent: '  ',\n  locationStrip: [\n    /^https?:\\/\\/[^\\/]+/,\n    /\\?[\\d\\.]+$/,\n  ],\n  filter: function(line) {\n    return line.location.match(/web-component-tester\\/browser.js/);\n  },\n};\n\n// https://github.com/visionmedia/mocha/blob/master/lib/runner.js#L36-46\nvar MOCHA_EVENTS = [\n  'start',\n  'end',\n  'suite',\n  'suite end',\n  'test',\n  'test end',\n  'hook',\n  'hook end',\n  'pass',\n  'fail',\n  'pending',\n];\n\n// Until a suite has loaded, we assume this many tests in it.\nvar ESTIMATED_TESTS_PER_SUITE = 3;\n\n/**\n * A Mocha-like runner that combines the output of multiple Mocha suites.\n *\n * @param {number} numSuites The number of suites that will be run, in order to\n *     estimate the total number of tests that will be performed.\n * @param {!Array.<!Mocha.reporters.Base>} reporters The set of reporters that\n *     should receive the unified event stream.\n */\nfunction MultiRunner(numSuites, reporters) {\n  this.reporters = reporters.map(function(reporter) {\n    return new reporter(this);\n  }.bind(this));\n\n  this.total = numSuites * ESTIMATED_TESTS_PER_SUITE;\n  // Mocha reporters assume a stream of events, so we have to be careful to only\n  // report on one runner at a time...\n  this.currentRunner = null;\n  // ...while we buffer events for any other active runners.\n  this.pendingEvents = [];\n\n  this.emit('start');\n}\n// Mocha doesn't expose its `EventEmitter` shim directly, so:\nMultiRunner.prototype = Object.create(Object.getPrototypeOf(Mocha.Runner.prototype));\n\n/**\n * @return {!Mocha.reporters.Base} A reporter-like \"class\" for each child suite\n *     that should be passed to `mocha.run`.\n */\nMultiRunner.prototype.childReporter = function childReporter(name) {\n  // The reporter is used as a constructor, so we can't depend on `this` being\n  // properly bound.\n  var self = this;\n  function reporter(runner) {\n    runner.name = name;\n    self.bindChildRunner(runner);\n  }\n  reporter.title = name;\n  return reporter;\n};\n\n/** Must be called once all runners have finished. */\nMultiRunner.prototype.done = function done() {\n  this.complete = true;\n  this.emit('end');\n  this.flushPendingEvents();\n};\n\n/**\n * Emit a top level test that is not part of any suite managed by this runner.\n *\n * Helpful for reporting on global errors, loading issues, etc.\n *\n * @param {string} title The title of the test.\n * @param {*} opt_error An error associated with this test. If falsy, test is\n *     considered to be passing.\n * @param {string} opt_suiteTitle Title for the suite that's wrapping the test.\n * @param {?boolean} opt_estimated If this test was included in the original\n *     estimate of `numSuites`.\n */\nMultiRunner.prototype.emitOutOfBandTest = function emitOutOfBandTest(title, opt_error, opt_suiteTitle, opt_estimated) {\n  WCT.util.debug('MultiRunner#emitOutOfBandTest(', arguments, ')');\n  var root = new Mocha.Suite();\n  root.title = opt_suiteTitle;\n  var test = new Mocha.Test(title, function() {\n  });\n  test.parent = root;\n  test.state  = opt_error ? 'failed' : 'passed';\n  test.err    = opt_error;\n\n  if (!opt_estimated) {\n    this.total = this.total + ESTIMATED_TESTS_PER_SUITE;\n  }\n\n  var runner = {total: 1};\n  this.proxyEvent('start', runner);\n  this.proxyEvent('suite', runner, root);\n  this.proxyEvent('test', runner, test);\n  if (opt_error) {\n    this.proxyEvent('fail', runner, test, opt_error);\n  } else {\n    this.proxyEvent('pass', runner, test);\n  }\n  this.proxyEvent('test end', runner, test);\n  this.proxyEvent('suite end', runner, root);\n  this.proxyEvent('end', runner);\n};\n\n// Internal Interface\n\n/** @param {!Mocha.runners.Base} runner The runner to listen to events for. */\nMultiRunner.prototype.bindChildRunner = function bindChildRunner(runner) {\n  MOCHA_EVENTS.forEach(function(eventName) {\n    runner.on(eventName, this.proxyEvent.bind(this, eventName, runner));\n  }.bind(this));\n};\n\n/**\n * Evaluates an event fired by `runner`, proxying it forward or buffering it.\n *\n * @param {string} eventName\n * @param {!Mocha.runners.Base} runner The runner that emitted this event.\n * @param {...*} var_args Any additional data passed as part of the event.\n */\nMultiRunner.prototype.proxyEvent = function proxyEvent(eventName, runner, var_args) {\n  var extraArgs = Array.prototype.slice.call(arguments, 2);\n  if (this.complete) {\n    console.warn('out of order Mocha event for ' + runner.name + ':', eventName, extraArgs);\n    return;\n  }\n\n  if (this.currentRunner && runner !== this.currentRunner) {\n    this.pendingEvents.push(arguments);\n    return;\n  }\n  WCT.util.debug('MultiRunner#proxyEvent(', arguments, ')');\n\n  // This appears to be a Mocha bug: Tests failed by passing an error to their\n  // done function don't set `err` properly.\n  //\n  // TODO(nevir): Track down.\n  if (eventName === 'fail' && !extraArgs[0].err) {\n    extraArgs[0].err = extraArgs[1];\n  }\n\n  if (eventName === 'start') {\n    this.onRunnerStart(runner);\n  } else if (eventName === 'end') {\n    this.onRunnerEnd(runner);\n  } else {\n    this.cleanEvent(eventName, runner, extraArgs);\n    this.emit.apply(this, [eventName].concat(extraArgs));\n  }\n};\n\n/**\n * Cleans or modifies an event if needed.\n *\n * @param {string} eventName\n * @param {!Mocha.runners.Base} runner The runner that emitted this event.\n * @param {!Array.<*>} extraArgs\n */\nMultiRunner.prototype.cleanEvent = function cleanEvent(eventName, runner, extraArgs) {\n  // Suite hierarchy\n  if (extraArgs[0]) {\n    extraArgs[0] = this.showRootSuite(extraArgs[0]);\n  }\n\n  // Normalize errors\n  if (eventName === 'fail') {\n    extraArgs[1] = Stacky.normalize(extraArgs[1], STACKY_CONFIG);\n  }\n  if (extraArgs[0] && extraArgs[0].err) {\n    extraArgs[0].err = Stacky.normalize(extraArgs[0].err, STACKY_CONFIG);\n  }\n};\n\n/**\n * We like to show the root suite's title, which requires a little bit of\n * trickery in the suite hierarchy.\n *\n * @param {!Mocha.Runnable} node\n */\nMultiRunner.prototype.showRootSuite = function showRootSuite(node) {\n  var leaf = node = Object.create(node);\n  while (node && !node.root) {\n    var wrappedParent = Object.create(node.parent);\n    node.parent = wrappedParent;\n    node = wrappedParent;\n  }\n  node.root = false;\n\n  return leaf;\n};\n\n/** @param {!Mocha.runners.Base} runner */\nMultiRunner.prototype.onRunnerStart = function onRunnerStart(runner) {\n  WCT.util.debug('MultiRunner#onRunnerStart:', runner.name);\n  this.total = this.total - ESTIMATED_TESTS_PER_SUITE + runner.total;\n  this.currentRunner = runner;\n};\n\n/** @param {!Mocha.runners.Base} runner */\nMultiRunner.prototype.onRunnerEnd = function onRunnerEnd(runner) {\n  WCT.util.debug('MultiRunner#onRunnerEnd:', runner.name);\n  this.currentRunner = null;\n  this.flushPendingEvents();\n};\n\n/**\n * Flushes any buffered events and runs them through `proxyEvent`. This will\n * loop until all buffered runners are complete, or we have run out of buffered\n * events.\n */\nMultiRunner.prototype.flushPendingEvents = function flushPendingEvents() {\n  var events = this.pendingEvents;\n  this.pendingEvents = [];\n  events.forEach(function(eventArgs) {\n    this.proxyEvent.apply(this, eventArgs);\n  }.bind(this));\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n/**\n * @fileoverview\n *\n * Runs all tests described by this document, after giving the document a chance\n * to load.\n *\n * If `WCT.waitForFrameworks` is true (the default), we will also wait for any\n * present web component frameworks to have fully initialized as well.\n */\n(function() {\n\n// We do a bit of our own grep processing to speed things up.\nvar grep = WCT.util.getParam('grep');\n\n// environment.js is optional; we need to take a look at our script's URL in\n// order to determine how (or not) to load it.\nvar prefix  = window.WCTPrefix;\nvar loadEnv = !window.WCTSkipEnvironment;\n\nvar scripts = document.querySelectorAll('script[src*=\"browser.js\"]');\nif (scripts.length !== 1 && !prefix) {\n  throw new Error('Unable to detect root URL for WCT. Please set WCTPrefix before including browser.js');\n}\nif (scripts[0]) {\n  var thisScript = scripts[0].src;\n  prefix  = thisScript.substring(0, thisScript.indexOf('browser.js'));\n  // You can tack ?skipEnv onto the browser URL to skip the default environment.\n  loadEnv = thisScript.indexOf('skipEnv') === -1;\n}\nif (loadEnv) {\n  // Synchronous load so that we can guarantee it is set up for early tests.\n  document.write('<script src=\"' + prefix + 'environment.js\"></script>'); // jshint ignore:line\n}\n\n// Give any scripts on the page a chance to twiddle the environment.\ndocument.addEventListener('DOMContentLoaded', function() {\n  WCT.util.debug('run stage: DOMContentLoaded');\n  var subSuite = WCT.SubSuite.current();\n  if (subSuite) {\n    WCT.util.debug('run stage: subsuite');\n    // Give the subsuite time to complete its load (see `SubSuite.load`).\n    setTimeout(runSubSuite.bind(null, subSuite), 0);\n    return;\n  }\n\n  // Before anything else, we need to ensure our communication channel with the\n  // CLI runner is established (if we're running in that context). Less\n  // buffering to deal with.\n  WCT.CLISocket.init(function(error, socket) {\n    WCT.util.debug('run stage: WCT.CLISocket.init done', error);\n    if (error) throw error;\n    var subsuites = WCT._suitesToLoad;\n    if (grep) {\n      var cleanSubsuites = [];\n      for (var i = 0, subsuite; subsuite = subsuites[i]; i++) {\n        if (subsuite.indexOf(grep) === 0) {\n          cleanSubsuites.push(subsuite);\n        }\n      }\n      subsuites = cleanSubsuites;\n    }\n\n    var runner = newMultiSuiteRunner(subsuites, determineReporters(socket));\n\n    loadDependencies(runner, function(error) {\n      WCT.util.debug('run stage: loadDependencies done', error);\n      if (error) throw error;\n\n      runMultiSuite(runner, subsuites);\n    });\n  });\n});\n\n/**\n * Loads any dependencies of the _current_ suite (e.g. `.js` sources).\n *\n * @param {!WCT.MultiRunner} runner The runner where errors should be reported.\n * @param {function} done A node style callback.\n */\nfunction loadDependencies(runner, done) {\n  WCT.util.debug('loadDependencies:', WCT._dependencies);\n\n  function onError(event) {\n    runner.emitOutOfBandTest('Test Suite Initialization', event.error);\n  }\n  window.addEventListener('error', onError);\n\n  var loaders = WCT._dependencies.map(function(file) {\n    // We only support `.js` dependencies for now.\n    return WCT.util.loadScript.bind(WCT.util, file);\n  });\n\n  WCT.util.parallel(loaders, function(error) {\n    window.removeEventListener('error', onError);\n    done(error);\n  });\n}\n\n/**\n * @param {!WCT.SubSuite} subSuite The `SubSuite` for this frame, that `mocha`\n *     should be run for.\n */\nfunction runSubSuite(subSuite) {\n  WCT.util.debug('runSubSuite', window.location.pathname);\n  // Not very pretty.\n  var parentWCT = subSuite.parentScope.WCT;\n  subSuite.prepare(WCT);\n\n  var suiteName = parentWCT.util.relativeLocation(window.location);\n  var reporter  = parentWCT._multiRunner.childReporter(suiteName);\n  runMocha(reporter, subSuite.done.bind(subSuite));\n}\n\n/**\n * @param {!Array.<string>} subsuites The subsuites that will be run.\n * @param {!Array.<!Mocha.reporters.Base>} reporters The reporters that should\n *     consume the output of this `MultiRunner`.\n * @return {!WCT.MultiRunner} The runner for our root suite.\n */\nfunction newMultiSuiteRunner(subsuites, reporters) {\n  WCT.util.debug('newMultiSuiteRunner', window.location.pathname);\n  WCT._multiRunner = new WCT.MultiRunner(subsuites.length + 1, reporters);\n  return WCT._multiRunner;\n}\n\n/**\n * @param {!WCT.MultiRunner} The runner built via `newMultiSuiteRunner`.\n * @param {!Array.<string>} subsuites The subsuites to run.\n */\nfunction runMultiSuite(runner, subsuites) {\n  WCT.util.debug('runMultiSuite', window.location.pathname);\n  var rootName = WCT.util.relativeLocation(window.location);\n\n  var suiteRunners = [\n    // Run the local tests (if any) first, not stopping on error;\n    runMocha.bind(null, runner.childReporter(rootName)),\n  ];\n\n  // As well as any sub suites. Again, don't stop on error.\n  subsuites.forEach(function(file) {\n    suiteRunners.push(function(next) {\n      var subSuite = new WCT.SubSuite(file, window);\n      runner.emit('subSuite start', subSuite);\n      subSuite.run(function(error) {\n        runner.emit('subSuite end', subSuite);\n\n        if (error) runner.emitOutOfBandTest(file, error);\n        next();\n      });\n    });\n  });\n\n  WCT.util.parallel(suiteRunners, WCT.numConcurrentSuites, function(error) {\n    WCT.util.debug('runMultiSuite done', error);\n    runner.done();\n  });\n}\n\n/**\n * Kicks off a mocha run, waiting for frameworks to load if necessary.\n *\n * @param {!Mocha.reporters.Base} reporter The reporter to pass to `mocha.run`.\n * @param {function} done A callback fired, _no error is passed_.\n */\nfunction runMocha(reporter, done, waited) {\n  if (WCT.waitForFrameworks && !waited) {\n    WCT.util.whenFrameworksReady(runMocha.bind(null, reporter, done, true));\n    return;\n  }\n  WCT.util.debug('runMocha', window.location.pathname);\n\n  mocha.reporter(reporter);\n  mocha.suite.title = reporter.title;\n  mocha.grep(grep);\n\n  // We can't use `mocha.run` because it bashes over grep, invert, and friends.\n  // See https://github.com/visionmedia/mocha/blob/master/support/tail.js#L137\n  var runner = Mocha.prototype.run.call(mocha, function(error) {\n    Mocha.utils.highlightTags('code');\n    done();  // We ignore the Mocha failure count.\n  });\n\n  // Mocha's default `onerror` handling strips the stack (to support really old\n  // browsers). We upgrade this to get better stacks for async errors.\n  //\n  // TODO(nevir): Can we expand support to other browsers?\n  if (navigator.userAgent.match(/chrome/i)) {\n    window.onerror = null;\n    window.addEventListener('error', function(event) {\n      if (!event.error) return;\n      if (event.error.ignore) return;\n      runner.uncaught(event.error);\n    });\n  }\n}\n\n/**\n * Figure out which reporters should be used for the current `window`.\n *\n * @param {WCT.CLISocket} socket The CLI socket, if present.\n */\nfunction determineReporters(socket) {\n  var reporters = [\n    WCT.reporters.Title,\n    WCT.reporters.Console,\n  ];\n\n  if (socket) {\n    reporters.push(function(runner) {\n      socket.observe(runner);\n    });\n  }\n\n  if (WCT._suitesToLoad.length > 0 || WCT._dependencies.length > 0) {\n    reporters.push(WCT.reporters.HTML);\n  }\n\n  return reporters;\n}\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n/**\n * @fileoverview\n *\n * Provides automatic configuration of Mocha by stubbing out potential Mocha\n * methods, and configuring Mocha appropriately once you call them.\n *\n * Just call `suite`, `describe`, etc normally, and everything should Just Work.\n */\n(function() {\n\n// Mocha global helpers, broken out by testing method.\nvar MOCHA_EXPORTS = {\n  // https://github.com/visionmedia/mocha/blob/master/lib/interfaces/tdd.js\n  tdd: [\n    'setup',\n    'teardown',\n    'suiteSetup',\n    'suiteTeardown',\n    'suite',\n    'test',\n  ],\n  // https://github.com/visionmedia/mocha/blob/master/lib/interfaces/tdd.js\n  bdd: [\n    'before',\n    'after',\n    'beforeEach',\n    'afterEach',\n    'describe',\n    'xdescribe',\n    'xcontext',\n    'it',\n    'xit',\n    'xspecify',\n  ],\n};\n\n// We expose all Mocha methods up front, configuring and running mocha\n// automatically when you call them.\n//\n// The assumption is that it is a one-off (sub-)suite of tests being run.\nObject.keys(MOCHA_EXPORTS).forEach(function(ui) {\n  MOCHA_EXPORTS[ui].forEach(function(key) {\n    window[key] = function wrappedMochaFunction() {\n      WCT.setupMocha(ui);\n      if (!window[key] || window[key] === wrappedMochaFunction) {\n        throw new Error('Expected mocha.setup to define ' + key);\n      }\n      window[key].apply(window, arguments);\n    };\n  });\n});\n\n/**\n * @param {string} ui Sets up mocha to run `ui`-style tests.\n */\nWCT.setupMocha = function setupMocha(ui) {\n  if (WCT._mochaUI && WCT._mochaUI === ui) return;\n  if (WCT._mochaUI && WCT._mochaUI !== ui) {\n    throw new Error('Mixing ' + WCT._mochaUI + ' and ' + ui + ' Mocha styles is not supported.');\n  }\n  mocha.setup({ui: ui, timeout: 60 * 1000});  // Note that the reporter is configured in run.js.\n  WCT.mochaIsSetup = true;\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.reporters.Console = Console;\n\n// We capture console events when running tests; so make sure we have a\n// reference to the original one.\nvar console = window.console;\n\nvar FONT = ';font: normal 13px \"Roboto\", \"Helvetica Neue\", \"Helvetica\", sans-serif;';\nvar STYLES = {\n  plain:   FONT,\n  suite:   'color: #5c6bc0' + FONT,\n  test:    FONT,\n  passing: 'color: #259b24' + FONT,\n  pending: 'color: #e65100' + FONT,\n  failing: 'color: #c41411' + FONT,\n  stack:   'color: #c41411',\n  results: FONT + 'font-size: 16px',\n};\n\n// I don't think we can feature detect this one...\nvar userAgent = navigator.userAgent.toLowerCase();\nvar CAN_STYLE_LOG   = userAgent.match('firefox') || userAgent.match('webkit');\nvar CAN_STYLE_GROUP = userAgent.match('webkit');\n// Track the indent for faked `console.group`\nvar logIndent = '';\n\nfunction log(text, style) {\n  text = text.split('\\n').map(function(l) { return logIndent + l; }).join('\\n');\n  if (CAN_STYLE_LOG) {\n    console.log('%c' + text, STYLES[style] || STYLES.plain);\n  } else {\n    console.log(text);\n  }\n}\n\nfunction logGroup(text, style) {\n  if (CAN_STYLE_GROUP) {\n    console.group('%c' + text, STYLES[style] || STYLES.plain);\n  } else if (console.group) {\n    console.group(text);\n  } else {\n    logIndent = logIndent + '  ';\n    log(text, style);\n  }\n}\n\nfunction logGroupEnd() {\n  if (console.groupEnd) {\n    console.groupEnd();\n  } else {\n    logIndent = logIndent.substr(0, logIndent.length - 2);\n  }\n}\n\nfunction logException(error) {\n  log(error.stack || error.message || error, 'stack');\n}\n\n/**\n * A Mocha reporter that logs results out to the web `console`.\n *\n * @param {!Mocha.Runner} runner The runner that is being reported on.\n */\nfunction Console(runner) {\n  Mocha.reporters.Base.call(this, runner);\n\n  runner.on('suite', function(suite) {\n    if (suite.root) return;\n    logGroup(suite.title, 'suite');\n  }.bind(this));\n\n  runner.on('suite end', function(suite) {\n    if (suite.root) return;\n    logGroupEnd();\n  }.bind(this));\n\n  runner.on('test', function(test) {\n    logGroup(test.title, 'test');\n  }.bind(this));\n\n  runner.on('pending', function(test) {\n    logGroup(test.title, 'pending');\n  }.bind(this));\n\n  runner.on('fail', function(test, error) {\n    logException(error);\n  }.bind(this));\n\n  runner.on('test end', function(test) {\n    logGroupEnd();\n  }.bind(this));\n\n  runner.on('end', this.logSummary.bind(this));\n}\nConsole.prototype = Object.create(Mocha.reporters.Base.prototype);\n\n/** Prints out a final summary of test results. */\nConsole.prototype.logSummary = function logSummary() {\n  logGroup('Test Results', 'results');\n\n  if (this.stats.failures > 0) {\n    log(WCT.util.pluralizedStat(this.stats.failures, 'failing'), 'failing');\n  }\n  if (this.stats.pending > 0) {\n    log(WCT.util.pluralizedStat(this.stats.pending, 'pending'), 'pending');\n  }\n  log(WCT.util.pluralizedStat(this.stats.passes, 'passing'));\n\n  if (!this.stats.failures) {\n    log('test suite passed', 'passing');\n  }\n  log('Evaluated ' + this.stats.tests + ' tests in ' + this.stats.duration + 'ms.');\n  logGroupEnd();\n};\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.reporters.HTML = HTML;\n\n/**\n * WCT-specific behavior on top of Mocha's default HTML reporter.\n *\n * @param {!Mocha.Runner} runner The runner that is being reported on.\n */\nfunction HTML(runner) {\n  var output = document.createElement('div');\n  output.id = 'mocha';\n  document.body.appendChild(output);\n\n  runner.on('suite', function(test) {\n    this.total = runner.total;\n  }.bind(this));\n\n  Mocha.reporters.HTML.call(this, runner);\n}\nHTML.prototype = Object.create(Mocha.reporters.HTML.prototype);\n\n})();\n","/**\n * @license\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\n(function() {\n\nWCT.reporters.Title = Title;\n\nvar ARC_OFFSET = 0; // start at the right.\nvar ARC_WIDTH  = 6;\n\n/**\n * A Mocha reporter that updates the document's title and favicon with\n * at-a-glance stats.\n *\n * @param {!Mocha.Runner} runner The runner that is being reported on.\n */\nfunction Title(runner) {\n  Mocha.reporters.Base.call(this, runner);\n\n  runner.on('test end', this.report.bind(this));\n}\n\n/** Reports current stats via the page title and favicon. */\nTitle.prototype.report = function report() {\n  this.updateTitle();\n  this.updateFavicon();\n};\n\n/** Updates the document title with a summary of current stats. */\nTitle.prototype.updateTitle = function updateTitle() {\n  if (this.stats.failures > 0) {\n    document.title = WCT.util.pluralizedStat(this.stats.failures, 'failing');\n  } else {\n    document.title = WCT.util.pluralizedStat(this.stats.passes, 'passing');\n  }\n};\n\n/**\n * Draws an arc for the favicon status, relative to the total number of tests.\n *\n * @param {!CanvasRenderingContext2D} context\n * @param {number} total\n * @param {number} start\n * @param {number} length\n * @param {string} color\n */\nfunction drawFaviconArc(context, total, start, length, color) {\n  var arcStart = ARC_OFFSET + Math.PI * 2 * (start / total);\n  var arcEnd   = ARC_OFFSET + Math.PI * 2 * ((start + length) / total);\n\n  context.beginPath();\n  context.strokeStyle = color;\n  context.lineWidth   = ARC_WIDTH;\n  context.arc(16, 16, 16 - ARC_WIDTH / 2, arcStart, arcEnd);\n  context.stroke();\n}\n\n/** Updates the document's favicon w/ a summary of current stats. */\nTitle.prototype.updateFavicon = function updateFavicon() {\n  var canvas = document.createElement('canvas');\n  canvas.height = canvas.width = 32;\n  var context = canvas.getContext('2d');\n\n  var passing = this.stats.passes;\n  var pending = this.stats.pending;\n  var failing = this.stats.failures;\n  var total   = Math.max(this.runner.total, passing + pending + failing);\n  drawFaviconArc(context, total, 0,                 passing, '#0e9c57');\n  drawFaviconArc(context, total, passing,           pending, '#f3b300');\n  drawFaviconArc(context, total, pending + passing, failing, '#ff5621');\n\n  this.setFavicon(canvas.toDataURL());\n};\n\n/** Sets the current favicon by URL. */\nTitle.prototype.setFavicon = function setFavicon(url) {\n  var current = document.head.querySelector('link[rel=\"icon\"]');\n  if (current) {\n    document.head.removeChild(current);\n  }\n\n  var link = document.createElement('link');\n  link.rel = 'icon';\n  link.type = 'image/x-icon';\n  link.href = url;\n  link.setAttribute('sizes', '32x32');\n  document.head.appendChild(link);\n};\n\n})();\n","/**\n * Copyright (c) 2014 The Polymer Project Authors. All rights reserved.\n * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt\n * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt\n * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt\n * Code distributed by Google as part of the polymer project is also\n * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt\n */\nhtml, body {\n  height: 100%;\n  width:  100%;\n}\n\n#mocha, #subsuites {\n  height: 100%;\n  position: absolute;\n  top: 0;\n  width: 50%;\n}\n\n#mocha {\n  box-sizing: border-box;\n  margin: 0 !important;\n  overflow-y: auto;\n  padding: 60px 50px;\n  right: 0;\n}\n\n#subsuites {\n  -ms-flex-direction: column;\n  -webkit-flex-direction: column;\n  display: -ms-flexbox;\n  display: -webkit-flex;\n  display: flex;\n  flex-direction: column;\n  left: 0;\n}\n\n#subsuites .subsuite {\n  border: 0;\n  width: 100%;\n  height: 100%;\n}\n\n#mocha .test.pass .duration {\n  color: #555;\n}\n"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/components/web-component-tester/environment.js b/components/web-component-tester/environment.js new file mode 100644 index 00000000..90cb5046 --- /dev/null +++ b/components/web-component-tester/environment.js @@ -0,0 +1,21757 @@ +/*! + * async + * https://github.com/caolan/async + * + * Copyright 2010-2014 Caolan McMahon + * Released under the MIT license + */ +/*jshint onevar: false, indent:4 */ +/*global setImmediate: false, setTimeout: false, console: false */ +(function () { + + var async = {}; + + // global on the server, window in the browser + var root, previous_async; + + root = this; + if (root != null) { + previous_async = root.async; + } + + async.noConflict = function () { + root.async = previous_async; + return async; + }; + + function only_once(fn) { + var called = false; + return function() { + if (called) throw new Error("Callback was already called."); + called = true; + fn.apply(root, arguments); + } + } + + //// cross-browser compatiblity functions //// + + var _toString = Object.prototype.toString; + + var _isArray = Array.isArray || function (obj) { + return _toString.call(obj) === '[object Array]'; + }; + + var _each = function (arr, iterator) { + if (arr.forEach) { + return arr.forEach(iterator); + } + for (var i = 0; i < arr.length; i += 1) { + iterator(arr[i], i, arr); + } + }; + + var _map = function (arr, iterator) { + if (arr.map) { + return arr.map(iterator); + } + var results = []; + _each(arr, function (x, i, a) { + results.push(iterator(x, i, a)); + }); + return results; + }; + + var _reduce = function (arr, iterator, memo) { + if (arr.reduce) { + return arr.reduce(iterator, memo); + } + _each(arr, function (x, i, a) { + memo = iterator(memo, x, i, a); + }); + return memo; + }; + + var _keys = function (obj) { + if (Object.keys) { + return Object.keys(obj); + } + var keys = []; + for (var k in obj) { + if (obj.hasOwnProperty(k)) { + keys.push(k); + } + } + return keys; + }; + + //// exported async module functions //// + + //// nextTick implementation with browser-compatible fallback //// + if (typeof process === 'undefined' || !(process.nextTick)) { + if (typeof setImmediate === 'function') { + async.nextTick = function (fn) { + // not a direct alias for IE10 compatibility + setImmediate(fn); + }; + async.setImmediate = async.nextTick; + } + else { + async.nextTick = function (fn) { + setTimeout(fn, 0); + }; + async.setImmediate = async.nextTick; + } + } + else { + async.nextTick = process.nextTick; + if (typeof setImmediate !== 'undefined') { + async.setImmediate = function (fn) { + // not a direct alias for IE10 compatibility + setImmediate(fn); + }; + } + else { + async.setImmediate = async.nextTick; + } + } + + async.each = function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length) { + return callback(); + } + var completed = 0; + _each(arr, function (x) { + iterator(x, only_once(done) ); + }); + function done(err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + if (completed >= arr.length) { + callback(); + } + } + } + }; + async.forEach = async.each; + + async.eachSeries = function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length) { + return callback(); + } + var completed = 0; + var iterate = function () { + iterator(arr[completed], function (err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + if (completed >= arr.length) { + callback(); + } + else { + iterate(); + } + } + }); + }; + iterate(); + }; + async.forEachSeries = async.eachSeries; + + async.eachLimit = function (arr, limit, iterator, callback) { + var fn = _eachLimit(limit); + fn.apply(null, [arr, iterator, callback]); + }; + async.forEachLimit = async.eachLimit; + + var _eachLimit = function (limit) { + + return function (arr, iterator, callback) { + callback = callback || function () {}; + if (!arr.length || limit <= 0) { + return callback(); + } + var completed = 0; + var started = 0; + var running = 0; + + (function replenish () { + if (completed >= arr.length) { + return callback(); + } + + while (running < limit && started < arr.length) { + started += 1; + running += 1; + iterator(arr[started - 1], function (err) { + if (err) { + callback(err); + callback = function () {}; + } + else { + completed += 1; + running -= 1; + if (completed >= arr.length) { + callback(); + } + else { + replenish(); + } + } + }); + } + })(); + }; + }; + + + var doParallel = function (fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [async.each].concat(args)); + }; + }; + var doParallelLimit = function(limit, fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [_eachLimit(limit)].concat(args)); + }; + }; + var doSeries = function (fn) { + return function () { + var args = Array.prototype.slice.call(arguments); + return fn.apply(null, [async.eachSeries].concat(args)); + }; + }; + + + var _asyncMap = function (eachfn, arr, iterator, callback) { + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + if (!callback) { + eachfn(arr, function (x, callback) { + iterator(x.value, function (err) { + callback(err); + }); + }); + } else { + var results = []; + eachfn(arr, function (x, callback) { + iterator(x.value, function (err, v) { + results[x.index] = v; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + async.map = doParallel(_asyncMap); + async.mapSeries = doSeries(_asyncMap); + async.mapLimit = function (arr, limit, iterator, callback) { + return _mapLimit(limit)(arr, iterator, callback); + }; + + var _mapLimit = function(limit) { + return doParallelLimit(limit, _asyncMap); + }; + + // reduce only has a series version, as doing reduce in parallel won't + // work in many situations. + async.reduce = function (arr, memo, iterator, callback) { + async.eachSeries(arr, function (x, callback) { + iterator(memo, x, function (err, v) { + memo = v; + callback(err); + }); + }, function (err) { + callback(err, memo); + }); + }; + // inject alias + async.inject = async.reduce; + // foldl alias + async.foldl = async.reduce; + + async.reduceRight = function (arr, memo, iterator, callback) { + var reversed = _map(arr, function (x) { + return x; + }).reverse(); + async.reduce(reversed, memo, iterator, callback); + }; + // foldr alias + async.foldr = async.reduceRight; + + var _filter = function (eachfn, arr, iterator, callback) { + var results = []; + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + eachfn(arr, function (x, callback) { + iterator(x.value, function (v) { + if (v) { + results.push(x); + } + callback(); + }); + }, function (err) { + callback(_map(results.sort(function (a, b) { + return a.index - b.index; + }), function (x) { + return x.value; + })); + }); + }; + async.filter = doParallel(_filter); + async.filterSeries = doSeries(_filter); + // select alias + async.select = async.filter; + async.selectSeries = async.filterSeries; + + var _reject = function (eachfn, arr, iterator, callback) { + var results = []; + arr = _map(arr, function (x, i) { + return {index: i, value: x}; + }); + eachfn(arr, function (x, callback) { + iterator(x.value, function (v) { + if (!v) { + results.push(x); + } + callback(); + }); + }, function (err) { + callback(_map(results.sort(function (a, b) { + return a.index - b.index; + }), function (x) { + return x.value; + })); + }); + }; + async.reject = doParallel(_reject); + async.rejectSeries = doSeries(_reject); + + var _detect = function (eachfn, arr, iterator, main_callback) { + eachfn(arr, function (x, callback) { + iterator(x, function (result) { + if (result) { + main_callback(x); + main_callback = function () {}; + } + else { + callback(); + } + }); + }, function (err) { + main_callback(); + }); + }; + async.detect = doParallel(_detect); + async.detectSeries = doSeries(_detect); + + async.some = function (arr, iterator, main_callback) { + async.each(arr, function (x, callback) { + iterator(x, function (v) { + if (v) { + main_callback(true); + main_callback = function () {}; + } + callback(); + }); + }, function (err) { + main_callback(false); + }); + }; + // any alias + async.any = async.some; + + async.every = function (arr, iterator, main_callback) { + async.each(arr, function (x, callback) { + iterator(x, function (v) { + if (!v) { + main_callback(false); + main_callback = function () {}; + } + callback(); + }); + }, function (err) { + main_callback(true); + }); + }; + // all alias + async.all = async.every; + + async.sortBy = function (arr, iterator, callback) { + async.map(arr, function (x, callback) { + iterator(x, function (err, criteria) { + if (err) { + callback(err); + } + else { + callback(null, {value: x, criteria: criteria}); + } + }); + }, function (err, results) { + if (err) { + return callback(err); + } + else { + var fn = function (left, right) { + var a = left.criteria, b = right.criteria; + return a < b ? -1 : a > b ? 1 : 0; + }; + callback(null, _map(results.sort(fn), function (x) { + return x.value; + })); + } + }); + }; + + async.auto = function (tasks, callback) { + callback = callback || function () {}; + var keys = _keys(tasks); + var remainingTasks = keys.length + if (!remainingTasks) { + return callback(); + } + + var results = {}; + + var listeners = []; + var addListener = function (fn) { + listeners.unshift(fn); + }; + var removeListener = function (fn) { + for (var i = 0; i < listeners.length; i += 1) { + if (listeners[i] === fn) { + listeners.splice(i, 1); + return; + } + } + }; + var taskComplete = function () { + remainingTasks-- + _each(listeners.slice(0), function (fn) { + fn(); + }); + }; + + addListener(function () { + if (!remainingTasks) { + var theCallback = callback; + // prevent final callback from calling itself if it errors + callback = function () {}; + + theCallback(null, results); + } + }); + + _each(keys, function (k) { + var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]]; + var taskCallback = function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + if (err) { + var safeResults = {}; + _each(_keys(results), function(rkey) { + safeResults[rkey] = results[rkey]; + }); + safeResults[k] = args; + callback(err, safeResults); + // stop subsequent errors hitting callback multiple times + callback = function () {}; + } + else { + results[k] = args; + async.setImmediate(taskComplete); + } + }; + var requires = task.slice(0, Math.abs(task.length - 1)) || []; + var ready = function () { + return _reduce(requires, function (a, x) { + return (a && results.hasOwnProperty(x)); + }, true) && !results.hasOwnProperty(k); + }; + if (ready()) { + task[task.length - 1](taskCallback, results); + } + else { + var listener = function () { + if (ready()) { + removeListener(listener); + task[task.length - 1](taskCallback, results); + } + }; + addListener(listener); + } + }); + }; + + async.retry = function(times, task, callback) { + var DEFAULT_TIMES = 5; + var attempts = []; + // Use defaults if times not passed + if (typeof times === 'function') { + callback = task; + task = times; + times = DEFAULT_TIMES; + } + // Make sure times is a number + times = parseInt(times, 10) || DEFAULT_TIMES; + var wrappedTask = function(wrappedCallback, wrappedResults) { + var retryAttempt = function(task, finalAttempt) { + return function(seriesCallback) { + task(function(err, result){ + seriesCallback(!err || finalAttempt, {err: err, result: result}); + }, wrappedResults); + }; + }; + while (times) { + attempts.push(retryAttempt(task, !(times-=1))); + } + async.series(attempts, function(done, data){ + data = data[data.length - 1]; + (wrappedCallback || callback)(data.err, data.result); + }); + } + // If a callback is passed, run this as a controll flow + return callback ? wrappedTask() : wrappedTask + }; + + async.waterfall = function (tasks, callback) { + callback = callback || function () {}; + if (!_isArray(tasks)) { + var err = new Error('First argument to waterfall must be an array of functions'); + return callback(err); + } + if (!tasks.length) { + return callback(); + } + var wrapIterator = function (iterator) { + return function (err) { + if (err) { + callback.apply(null, arguments); + callback = function () {}; + } + else { + var args = Array.prototype.slice.call(arguments, 1); + var next = iterator.next(); + if (next) { + args.push(wrapIterator(next)); + } + else { + args.push(callback); + } + async.setImmediate(function () { + iterator.apply(null, args); + }); + } + }; + }; + wrapIterator(async.iterator(tasks))(); + }; + + var _parallel = function(eachfn, tasks, callback) { + callback = callback || function () {}; + if (_isArray(tasks)) { + eachfn.map(tasks, function (fn, callback) { + if (fn) { + fn(function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + callback.call(null, err, args); + }); + } + }, callback); + } + else { + var results = {}; + eachfn.each(_keys(tasks), function (k, callback) { + tasks[k](function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + results[k] = args; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + + async.parallel = function (tasks, callback) { + _parallel({ map: async.map, each: async.each }, tasks, callback); + }; + + async.parallelLimit = function(tasks, limit, callback) { + _parallel({ map: _mapLimit(limit), each: _eachLimit(limit) }, tasks, callback); + }; + + async.series = function (tasks, callback) { + callback = callback || function () {}; + if (_isArray(tasks)) { + async.mapSeries(tasks, function (fn, callback) { + if (fn) { + fn(function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + callback.call(null, err, args); + }); + } + }, callback); + } + else { + var results = {}; + async.eachSeries(_keys(tasks), function (k, callback) { + tasks[k](function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (args.length <= 1) { + args = args[0]; + } + results[k] = args; + callback(err); + }); + }, function (err) { + callback(err, results); + }); + } + }; + + async.iterator = function (tasks) { + var makeCallback = function (index) { + var fn = function () { + if (tasks.length) { + tasks[index].apply(null, arguments); + } + return fn.next(); + }; + fn.next = function () { + return (index < tasks.length - 1) ? makeCallback(index + 1): null; + }; + return fn; + }; + return makeCallback(0); + }; + + async.apply = function (fn) { + var args = Array.prototype.slice.call(arguments, 1); + return function () { + return fn.apply( + null, args.concat(Array.prototype.slice.call(arguments)) + ); + }; + }; + + var _concat = function (eachfn, arr, fn, callback) { + var r = []; + eachfn(arr, function (x, cb) { + fn(x, function (err, y) { + r = r.concat(y || []); + cb(err); + }); + }, function (err) { + callback(err, r); + }); + }; + async.concat = doParallel(_concat); + async.concatSeries = doSeries(_concat); + + async.whilst = function (test, iterator, callback) { + if (test()) { + iterator(function (err) { + if (err) { + return callback(err); + } + async.whilst(test, iterator, callback); + }); + } + else { + callback(); + } + }; + + async.doWhilst = function (iterator, test, callback) { + iterator(function (err) { + if (err) { + return callback(err); + } + var args = Array.prototype.slice.call(arguments, 1); + if (test.apply(null, args)) { + async.doWhilst(iterator, test, callback); + } + else { + callback(); + } + }); + }; + + async.until = function (test, iterator, callback) { + if (!test()) { + iterator(function (err) { + if (err) { + return callback(err); + } + async.until(test, iterator, callback); + }); + } + else { + callback(); + } + }; + + async.doUntil = function (iterator, test, callback) { + iterator(function (err) { + if (err) { + return callback(err); + } + var args = Array.prototype.slice.call(arguments, 1); + if (!test.apply(null, args)) { + async.doUntil(iterator, test, callback); + } + else { + callback(); + } + }); + }; + + async.queue = function (worker, concurrency) { + if (concurrency === undefined) { + concurrency = 1; + } + function _insert(q, data, pos, callback) { + if (!q.started){ + q.started = true; + } + if (!_isArray(data)) { + data = [data]; + } + if(data.length == 0) { + // call drain immediately if there are no tasks + return async.setImmediate(function() { + if (q.drain) { + q.drain(); + } + }); + } + _each(data, function(task) { + var item = { + data: task, + callback: typeof callback === 'function' ? callback : null + }; + + if (pos) { + q.tasks.unshift(item); + } else { + q.tasks.push(item); + } + + if (q.saturated && q.tasks.length === q.concurrency) { + q.saturated(); + } + async.setImmediate(q.process); + }); + } + + var workers = 0; + var q = { + tasks: [], + concurrency: concurrency, + saturated: null, + empty: null, + drain: null, + started: false, + paused: false, + push: function (data, callback) { + _insert(q, data, false, callback); + }, + kill: function () { + q.drain = null; + q.tasks = []; + }, + unshift: function (data, callback) { + _insert(q, data, true, callback); + }, + process: function () { + if (!q.paused && workers < q.concurrency && q.tasks.length) { + var task = q.tasks.shift(); + if (q.empty && q.tasks.length === 0) { + q.empty(); + } + workers += 1; + var next = function () { + workers -= 1; + if (task.callback) { + task.callback.apply(task, arguments); + } + if (q.drain && q.tasks.length + workers === 0) { + q.drain(); + } + q.process(); + }; + var cb = only_once(next); + worker(task.data, cb); + } + }, + length: function () { + return q.tasks.length; + }, + running: function () { + return workers; + }, + idle: function() { + return q.tasks.length + workers === 0; + }, + pause: function () { + if (q.paused === true) { return; } + q.paused = true; + q.process(); + }, + resume: function () { + if (q.paused === false) { return; } + q.paused = false; + q.process(); + } + }; + return q; + }; + + async.priorityQueue = function (worker, concurrency) { + + function _compareTasks(a, b){ + return a.priority - b.priority; + }; + + function _binarySearch(sequence, item, compare) { + var beg = -1, + end = sequence.length - 1; + while (beg < end) { + var mid = beg + ((end - beg + 1) >>> 1); + if (compare(item, sequence[mid]) >= 0) { + beg = mid; + } else { + end = mid - 1; + } + } + return beg; + } + + function _insert(q, data, priority, callback) { + if (!q.started){ + q.started = true; + } + if (!_isArray(data)) { + data = [data]; + } + if(data.length == 0) { + // call drain immediately if there are no tasks + return async.setImmediate(function() { + if (q.drain) { + q.drain(); + } + }); + } + _each(data, function(task) { + var item = { + data: task, + priority: priority, + callback: typeof callback === 'function' ? callback : null + }; + + q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item); + + if (q.saturated && q.tasks.length === q.concurrency) { + q.saturated(); + } + async.setImmediate(q.process); + }); + } + + // Start with a normal queue + var q = async.queue(worker, concurrency); + + // Override push to accept second parameter representing priority + q.push = function (data, priority, callback) { + _insert(q, data, priority, callback); + }; + + // Remove unshift function + delete q.unshift; + + return q; + }; + + async.cargo = function (worker, payload) { + var working = false, + tasks = []; + + var cargo = { + tasks: tasks, + payload: payload, + saturated: null, + empty: null, + drain: null, + drained: true, + push: function (data, callback) { + if (!_isArray(data)) { + data = [data]; + } + _each(data, function(task) { + tasks.push({ + data: task, + callback: typeof callback === 'function' ? callback : null + }); + cargo.drained = false; + if (cargo.saturated && tasks.length === payload) { + cargo.saturated(); + } + }); + async.setImmediate(cargo.process); + }, + process: function process() { + if (working) return; + if (tasks.length === 0) { + if(cargo.drain && !cargo.drained) cargo.drain(); + cargo.drained = true; + return; + } + + var ts = typeof payload === 'number' + ? tasks.splice(0, payload) + : tasks.splice(0, tasks.length); + + var ds = _map(ts, function (task) { + return task.data; + }); + + if(cargo.empty) cargo.empty(); + working = true; + worker(ds, function () { + working = false; + + var args = arguments; + _each(ts, function (data) { + if (data.callback) { + data.callback.apply(null, args); + } + }); + + process(); + }); + }, + length: function () { + return tasks.length; + }, + running: function () { + return working; + } + }; + return cargo; + }; + + var _console_fn = function (name) { + return function (fn) { + var args = Array.prototype.slice.call(arguments, 1); + fn.apply(null, args.concat([function (err) { + var args = Array.prototype.slice.call(arguments, 1); + if (typeof console !== 'undefined') { + if (err) { + if (console.error) { + console.error(err); + } + } + else if (console[name]) { + _each(args, function (x) { + console[name](x); + }); + } + } + }])); + }; + }; + async.log = _console_fn('log'); + async.dir = _console_fn('dir'); + /*async.info = _console_fn('info'); + async.warn = _console_fn('warn'); + async.error = _console_fn('error');*/ + + async.memoize = function (fn, hasher) { + var memo = {}; + var queues = {}; + hasher = hasher || function (x) { + return x; + }; + var memoized = function () { + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + var key = hasher.apply(null, args); + if (key in memo) { + async.nextTick(function () { + callback.apply(null, memo[key]); + }); + } + else if (key in queues) { + queues[key].push(callback); + } + else { + queues[key] = [callback]; + fn.apply(null, args.concat([function () { + memo[key] = arguments; + var q = queues[key]; + delete queues[key]; + for (var i = 0, l = q.length; i < l; i++) { + q[i].apply(null, arguments); + } + }])); + } + }; + memoized.memo = memo; + memoized.unmemoized = fn; + return memoized; + }; + + async.unmemoize = function (fn) { + return function () { + return (fn.unmemoized || fn).apply(null, arguments); + }; + }; + + async.times = function (count, iterator, callback) { + var counter = []; + for (var i = 0; i < count; i++) { + counter.push(i); + } + return async.map(counter, iterator, callback); + }; + + async.timesSeries = function (count, iterator, callback) { + var counter = []; + for (var i = 0; i < count; i++) { + counter.push(i); + } + return async.mapSeries(counter, iterator, callback); + }; + + async.seq = function (/* functions... */) { + var fns = arguments; + return function () { + var that = this; + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + async.reduce(fns, args, function (newargs, fn, cb) { + fn.apply(that, newargs.concat([function () { + var err = arguments[0]; + var nextargs = Array.prototype.slice.call(arguments, 1); + cb(err, nextargs); + }])) + }, + function (err, results) { + callback.apply(that, [err].concat(results)); + }); + }; + }; + + async.compose = function (/* functions... */) { + return async.seq.apply(null, Array.prototype.reverse.call(arguments)); + }; + + var _applyEach = function (eachfn, fns /*args...*/) { + var go = function () { + var that = this; + var args = Array.prototype.slice.call(arguments); + var callback = args.pop(); + return eachfn(fns, function (fn, cb) { + fn.apply(that, args.concat([cb])); + }, + callback); + }; + if (arguments.length > 2) { + var args = Array.prototype.slice.call(arguments, 2); + return go.apply(this, args); + } + else { + return go; + } + }; + async.applyEach = doParallel(_applyEach); + async.applyEachSeries = doSeries(_applyEach); + + async.forever = function (fn, callback) { + function next(err) { + if (err) { + if (callback) { + return callback(err); + } + throw err; + } + fn(next); + } + next(); + }; + + // Node.js + if (typeof module !== 'undefined' && module.exports) { + module.exports = async; + } + // AMD / RequireJS + else if (typeof define !== 'undefined' && define.amd) { + define([], function () { + return async; + }); + } + // included directly via diff --git a/components/x-elements/paper-ripple.html b/components/x-elements/paper-ripple.html new file mode 100644 index 00000000..ba191af7 --- /dev/null +++ b/components/x-elements/paper-ripple.html @@ -0,0 +1,419 @@ + + + + diff --git a/components/x-elements/paper-spinner.html b/components/x-elements/paper-spinner.html new file mode 100644 index 00000000..08c6e401 --- /dev/null +++ b/components/x-elements/paper-spinner.html @@ -0,0 +1,541 @@ + + + + + + + + + + + diff --git a/components/x-elements/x-ajax.html b/components/x-elements/x-ajax.html new file mode 100644 index 00000000..12238b6e --- /dev/null +++ b/components/x-elements/x-ajax.html @@ -0,0 +1,31 @@ + \ No newline at end of file diff --git a/components/x-elements/x-collapse.html b/components/x-elements/x-collapse.html new file mode 100644 index 00000000..a3a3e490 --- /dev/null +++ b/components/x-elements/x-collapse.html @@ -0,0 +1,58 @@ + + \ No newline at end of file diff --git a/components/x-elements/x-doc-viewer/README.md b/components/x-elements/x-doc-viewer/README.md new file mode 100644 index 00000000..f5cf656f --- /dev/null +++ b/components/x-elements/x-doc-viewer/README.md @@ -0,0 +1,7 @@ +core-doc-viewer +================ + +See the [component page](http://polymer-project.org/docs/elements/core-elements.html#core-doc-viewer) for more information. + + +**Note** If you update elements in this repo, you'll need to rebuild `build.sh` in [core-component-page-dev](https://github.com/Polymer/core-component-page-dev) so they're used in the compiled version (core-component-page). diff --git a/components/x-elements/x-doc-viewer/bower.json b/components/x-elements/x-doc-viewer/bower.json new file mode 100644 index 00000000..e69de29b diff --git a/components/x-elements/x-doc-viewer/demo.html b/components/x-elements/x-doc-viewer/demo.html new file mode 100644 index 00000000..1541b286 --- /dev/null +++ b/components/x-elements/x-doc-viewer/demo.html @@ -0,0 +1,45 @@ + + + + + + x-doc-viewer + + + + + + + + + + + + + + + + + + + + + diff --git a/components/x-elements/x-doc-viewer/elements/context-free-parser.html b/components/x-elements/x-doc-viewer/elements/context-free-parser.html new file mode 100644 index 00000000..7c75fa67 --- /dev/null +++ b/components/x-elements/x-doc-viewer/elements/context-free-parser.html @@ -0,0 +1,59 @@ + + + + + + + + diff --git a/components/x-elements/x-doc-viewer/elements/context-free-parser.js b/components/x-elements/x-doc-viewer/elements/context-free-parser.js new file mode 100644 index 00000000..bd70d4b0 --- /dev/null +++ b/components/x-elements/x-doc-viewer/elements/context-free-parser.js @@ -0,0 +1,130 @@ +/* + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ + +(function(scope) { + + var ContextFreeParser = { + parse: function(text) { + var top = {}; + var entities = []; + var current = top; + var subCurrent = {}; + + var scriptDocCommentClause = '\\/\\*\\*([\\s\\S]*?)\\*\\/'; + var htmlDocCommentClause = ''; + + // matches text between /** and */ inclusive and inclusive + var docCommentRegex = new RegExp(scriptDocCommentClause + '|' + htmlDocCommentClause, 'g'); + + // acquire all script doc comments + var docComments = text.match(docCommentRegex) || []; + + // each match represents a single block of doc comments + docComments.forEach(function(m) { + // unify line ends, remove all comment characters, split into individual lines + var lines = m.replace(/\r\n/g, '\n').replace(/^\s*\/\*\*|^\s*\*\/|^\s*\* ?|^\s*\<\!-\-|^s*\-\-\>/gm, '').split('\n'); + + // pragmas (@-rules) must occur on a line by themselves + var pragmas = []; + // filter lines whose first non-whitespace character is @ into the pragma list + // (and out of the `lines` array) + lines = lines.filter(function(l) { + var m = l.match(/\s*@([\w-]*) (.*)/); + if (!m) { + return true; + } + pragmas.push(m); + }); + + // collect all other text into a single block + var code = lines.join('\n'); + + // process pragmas + pragmas.forEach(function(m) { + var pragma = m[1], content = m[2]; + switch (pragma) { + + // currently all entities are either @class or @element + case 'class': + case 'element': + current = { + name: content, + description: code + }; + entities.push(current); + break; + + // an entity may have these describable sub-features + case 'attribute': + case 'property': + case 'method': + case 'event': + subCurrent = { + name: content, + description: code + }; + var label = pragma == 'property' ? 'properties' : pragma + 's'; + makePragma(current, label, subCurrent); + break; + + // sub-feature pragmas + case 'default': + case 'type': + subCurrent[pragma] = content; + break; + + case 'param': + var eventParmsRe = /\{(.+)\}\s+(\w+[.\w+]+)\s+(.*)$/; + + var params = content.match(eventParmsRe); + if (params) { + var subEventObj = { + type: params[1], + name: params[2], + description: params[3] + }; + makePragma(subCurrent, pragma + 's', subEventObj); + } + + break; + + // everything else + default: + current[pragma] = content; + break; + } + }); + + // utility function, yay hoisting + function makePragma(object, pragma, content) { + var p$ = object; + var p = p$[pragma]; + if (!p) { + p$[pragma] = p = []; + } + p.push(content); + } + + }); + + if (entities.length === 0) { + entities.push({name: 'Entity', description: '**Undocumented**'}); + } + return entities; + } + }; + + if (typeof module !== 'undefined' && module.exports) { + module.exports = ContextFreeParser; + } else { + scope.ContextFreeParser = ContextFreeParser; + } + +})(this); \ No newline at end of file diff --git a/components/x-elements/x-doc-viewer/elements/x-doc-page.html b/components/x-elements/x-doc-viewer/elements/x-doc-page.html new file mode 100644 index 00000000..577ff6a0 --- /dev/null +++ b/components/x-elements/x-doc-viewer/elements/x-doc-page.html @@ -0,0 +1,200 @@ + + + + + + + + + + + + diff --git a/components/x-elements/x-doc-viewer/elements/x-doc-toc.html b/components/x-elements/x-doc-viewer/elements/x-doc-toc.html new file mode 100644 index 00000000..b065f49b --- /dev/null +++ b/components/x-elements/x-doc-viewer/elements/x-doc-toc.html @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/components/x-elements/x-doc-viewer/x-doc-viewer.html b/components/x-elements/x-doc-viewer/x-doc-viewer.html new file mode 100644 index 00000000..d3528ecc --- /dev/null +++ b/components/x-elements/x-doc-viewer/x-doc-viewer.html @@ -0,0 +1,260 @@ + + + + + + + + + + + + + + + + + + + diff --git a/components/x-elements/x-drawer-panel.html b/components/x-elements/x-drawer-panel.html new file mode 100644 index 00000000..854864aa --- /dev/null +++ b/components/x-elements/x-drawer-panel.html @@ -0,0 +1,125 @@ + + + diff --git a/components/x-elements/x-drawer-panel2.html b/components/x-elements/x-drawer-panel2.html new file mode 100644 index 00000000..4e535393 --- /dev/null +++ b/components/x-elements/x-drawer-panel2.html @@ -0,0 +1,100 @@ + + + diff --git a/components/x-elements/x-drop-button.html b/components/x-elements/x-drop-button.html new file mode 100644 index 00000000..cf38bd40 --- /dev/null +++ b/components/x-elements/x-drop-button.html @@ -0,0 +1,53 @@ + + + + \ No newline at end of file diff --git a/components/x-elements/x-icon-button.html b/components/x-elements/x-icon-button.html new file mode 100644 index 00000000..615f0c50 --- /dev/null +++ b/components/x-elements/x-icon-button.html @@ -0,0 +1,70 @@ + + + \ No newline at end of file diff --git a/components/x-elements/x-icon.html b/components/x-elements/x-icon.html new file mode 100644 index 00000000..1b6d0fed --- /dev/null +++ b/components/x-elements/x-icon.html @@ -0,0 +1,55 @@ + + + + + \ No newline at end of file diff --git a/components/x-elements/x-item.html b/components/x-elements/x-item.html new file mode 100644 index 00000000..62e4ba5b --- /dev/null +++ b/components/x-elements/x-item.html @@ -0,0 +1,47 @@ + + + \ No newline at end of file diff --git a/components/x-elements/x-list.html b/components/x-elements/x-list.html new file mode 100644 index 00000000..b7778c0b --- /dev/null +++ b/components/x-elements/x-list.html @@ -0,0 +1,253 @@ + + + + \ No newline at end of file diff --git a/components/x-elements/x-media-query.html b/components/x-elements/x-media-query.html new file mode 100644 index 00000000..9f6b2fe7 --- /dev/null +++ b/components/x-elements/x-media-query.html @@ -0,0 +1,33 @@ + diff --git a/components/x-elements/x-overlay.html b/components/x-elements/x-overlay.html new file mode 100644 index 00000000..c3c249ca --- /dev/null +++ b/components/x-elements/x-overlay.html @@ -0,0 +1,123 @@ + + + + + \ No newline at end of file diff --git a/components/x-elements/x-pages.html b/components/x-elements/x-pages.html new file mode 100644 index 00000000..18750232 --- /dev/null +++ b/components/x-elements/x-pages.html @@ -0,0 +1,38 @@ + + + diff --git a/components/x-elements/x-repeater.html b/components/x-elements/x-repeater.html new file mode 100644 index 00000000..d081f688 --- /dev/null +++ b/components/x-elements/x-repeater.html @@ -0,0 +1,31 @@ + \ No newline at end of file diff --git a/components/x-elements/x-route/demo/app.html b/components/x-elements/x-route/demo/app.html new file mode 100644 index 00000000..ed080a5b --- /dev/null +++ b/components/x-elements/x-route/demo/app.html @@ -0,0 +1,32 @@ + + + + + + + Routing Test + + + + + + + + + + + + + + + + + + + + diff --git a/components/x-elements/x-route/demo/src/x-app.html b/components/x-elements/x-route/demo/src/x-app.html new file mode 100644 index 00000000..49ebb0a3 --- /dev/null +++ b/components/x-elements/x-route/demo/src/x-app.html @@ -0,0 +1,123 @@ + + + + + + + + + \ No newline at end of file diff --git a/components/x-elements/x-route/demo/src/x-user.html b/components/x-elements/x-route/demo/src/x-user.html new file mode 100644 index 00000000..3eff1ba9 --- /dev/null +++ b/components/x-elements/x-route/demo/src/x-user.html @@ -0,0 +1,29 @@ + + + + + + + + + \ No newline at end of file diff --git a/components/x-elements/x-route/x-route.html b/components/x-elements/x-route/x-route.html new file mode 100644 index 00000000..5563b501 --- /dev/null +++ b/components/x-elements/x-route/x-route.html @@ -0,0 +1,158 @@ + + + + diff --git a/components/x-elements/x-search-input.html b/components/x-elements/x-search-input.html new file mode 100644 index 00000000..35a4548e --- /dev/null +++ b/components/x-elements/x-search-input.html @@ -0,0 +1,46 @@ + + + + \ No newline at end of file diff --git a/components/x-elements/x-selector.html b/components/x-elements/x-selector.html new file mode 100644 index 00000000..816a0cc9 --- /dev/null +++ b/components/x-elements/x-selector.html @@ -0,0 +1,91 @@ + diff --git a/components/x-elements/x-submenu.html b/components/x-elements/x-submenu.html new file mode 100644 index 00000000..b3c7f62d --- /dev/null +++ b/components/x-elements/x-submenu.html @@ -0,0 +1,79 @@ + + + + + \ No newline at end of file diff --git a/components/x-elements/x-toolbar.html b/components/x-elements/x-toolbar.html new file mode 100644 index 00000000..659fefc8 --- /dev/null +++ b/components/x-elements/x-toolbar.html @@ -0,0 +1,22 @@ + + \ No newline at end of file