diff --git a/ajax/libs/analytics.js/1.5.3/analytics.js b/ajax/libs/analytics.js/1.5.3/analytics.js new file mode 100644 index 000000000..047f2ac58 --- /dev/null +++ b/ajax/libs/analytics.js/1.5.3/analytics.js @@ -0,0 +1,16038 @@ +;(function(){ + +/** + * Require the given path. + * + * @param {String} path + * @return {Object} exports + * @api public + */ + +function require(path, parent, orig) { + var resolved = require.resolve(path); + + // lookup failed + if (null == resolved) { + orig = orig || path; + parent = parent || 'root'; + var err = new Error('Failed to require "' + orig + '" from "' + parent + '"'); + err.path = orig; + err.parent = parent; + err.require = true; + throw err; + } + + var module = require.modules[resolved]; + + // perform real require() + // by invoking the module's + // registered function + if (!module._resolving && !module.exports) { + var mod = {}; + mod.exports = {}; + mod.client = mod.component = true; + module._resolving = true; + module.call(this, mod.exports, require.relative(resolved), mod); + delete module._resolving; + module.exports = mod.exports; + } + + return module.exports; +} + +/** + * Registered modules. + */ + +require.modules = {}; + +/** + * Registered aliases. + */ + +require.aliases = {}; + +/** + * Resolve `path`. + * + * Lookup: + * + * - PATH/index.js + * - PATH.js + * - PATH + * + * @param {String} path + * @return {String} path or null + * @api private + */ + +require.resolve = function(path) { + if (path.charAt(0) === '/') path = path.slice(1); + + var paths = [ + path, + path + '.js', + path + '.json', + path + '/index.js', + path + '/index.json' + ]; + + for (var i = 0; i < paths.length; i++) { + var path = paths[i]; + if (require.modules.hasOwnProperty(path)) return path; + if (require.aliases.hasOwnProperty(path)) return require.aliases[path]; + } +}; + +/** + * Normalize `path` relative to the current path. + * + * @param {String} curr + * @param {String} path + * @return {String} + * @api private + */ + +require.normalize = function(curr, path) { + var segs = []; + + if ('.' != path.charAt(0)) return path; + + curr = curr.split('/'); + path = path.split('/'); + + for (var i = 0; i < path.length; ++i) { + if ('..' == path[i]) { + curr.pop(); + } else if ('.' != path[i] && '' != path[i]) { + segs.push(path[i]); + } + } + + return curr.concat(segs).join('/'); +}; + +/** + * Register module at `path` with callback `definition`. + * + * @param {String} path + * @param {Function} definition + * @api private + */ + +require.register = function(path, definition) { + require.modules[path] = definition; +}; + +/** + * Alias a module definition. + * + * @param {String} from + * @param {String} to + * @api private + */ + +require.alias = function(from, to) { + if (!require.modules.hasOwnProperty(from)) { + throw new Error('Failed to alias "' + from + '", it does not exist'); + } + require.aliases[to] = from; +}; + +/** + * Return a require function relative to the `parent` path. + * + * @param {String} parent + * @return {Function} + * @api private + */ + +require.relative = function(parent) { + var p = require.normalize(parent, '..'); + + /** + * lastIndexOf helper. + */ + + function lastIndexOf(arr, obj) { + var i = arr.length; + while (i--) { + if (arr[i] === obj) return i; + } + return -1; + } + + /** + * The relative require() itself. + */ + + function localRequire(path) { + var resolved = localRequire.resolve(path); + return require(resolved, parent, path); + } + + /** + * Resolve relative to the parent. + */ + + localRequire.resolve = function(path) { + var c = path.charAt(0); + if ('/' == c) return path.slice(1); + if ('.' == c) return require.normalize(p, path); + + // resolve deps by returning + // the dep in the nearest "deps" + // directory + var segs = parent.split('/'); + var i = lastIndexOf(segs, 'deps') + 1; + if (!i) i = 0; + path = segs.slice(0, i + 1).join('/') + '/deps/' + path; + return path; + }; + + /** + * Check if module is defined at `path`. + */ + + localRequire.exists = function(path) { + return require.modules.hasOwnProperty(localRequire.resolve(path)); + }; + + return localRequire; +}; +require.register("avetisk-defaults/index.js", function(exports, require, module){ +'use strict'; + +/** + * Merge default values. + * + * @param {Object} dest + * @param {Object} defaults + * @return {Object} + * @api public + */ +var defaults = function (dest, src, recursive) { + for (var prop in src) { + if (recursive && dest[prop] instanceof Object && src[prop] instanceof Object) { + dest[prop] = defaults(dest[prop], src[prop], true); + } else if (! (prop in dest)) { + dest[prop] = src[prop]; + } + } + + return dest; +}; + +/** + * Expose `defaults`. + */ +module.exports = defaults; + +}); +require.register("component-type/index.js", function(exports, require, module){ + +/** + * toString ref. + */ + +var toString = Object.prototype.toString; + +/** + * Return the type of `val`. + * + * @param {Mixed} val + * @return {String} + * @api public + */ + +module.exports = function(val){ + switch (toString.call(val)) { + case '[object Function]': return 'function'; + case '[object Date]': return 'date'; + case '[object RegExp]': return 'regexp'; + case '[object Arguments]': return 'arguments'; + case '[object Array]': return 'array'; + case '[object String]': return 'string'; + } + + if (val === null) return 'null'; + if (val === undefined) return 'undefined'; + if (val && val.nodeType === 1) return 'element'; + if (val === Object(val)) return 'object'; + + return typeof val; +}; + +}); +require.register("component-clone/index.js", function(exports, require, module){ + +/** + * Module dependencies. + */ + +var type; + +try { + type = require('type'); +} catch(e){ + type = require('type-component'); +} + +/** + * Module exports. + */ + +module.exports = clone; + +/** + * Clones objects. + * + * @param {Mixed} any object + * @api public + */ + +function clone(obj){ + switch (type(obj)) { + case 'object': + var copy = {}; + for (var key in obj) { + if (obj.hasOwnProperty(key)) { + copy[key] = clone(obj[key]); + } + } + return copy; + + case 'array': + var copy = new Array(obj.length); + for (var i = 0, l = obj.length; i < l; i++) { + copy[i] = clone(obj[i]); + } + return copy; + + case 'regexp': + // from millermedeiros/amd-utils - MIT + var flags = ''; + flags += obj.multiline ? 'm' : ''; + flags += obj.global ? 'g' : ''; + flags += obj.ignoreCase ? 'i' : ''; + return new RegExp(obj.source, flags); + + case 'date': + return new Date(obj.getTime()); + + default: // string, number, boolean, … + return obj; + } +} + +}); +require.register("component-cookie/index.js", function(exports, require, module){ +/** + * Encode. + */ + +var encode = encodeURIComponent; + +/** + * Decode. + */ + +var decode = decodeURIComponent; + +/** + * Set or get cookie `name` with `value` and `options` object. + * + * @param {String} name + * @param {String} value + * @param {Object} options + * @return {Mixed} + * @api public + */ + +module.exports = function(name, value, options){ + switch (arguments.length) { + case 3: + case 2: + return set(name, value, options); + case 1: + return get(name); + default: + return all(); + } +}; + +/** + * Set cookie `name` to `value`. + * + * @param {String} name + * @param {String} value + * @param {Object} options + * @api private + */ + +function set(name, value, options) { + options = options || {}; + var str = encode(name) + '=' + encode(value); + + if (null == value) options.maxage = -1; + + if (options.maxage) { + options.expires = new Date(+new Date + options.maxage); + } + + if (options.path) str += '; path=' + options.path; + if (options.domain) str += '; domain=' + options.domain; + if (options.expires) str += '; expires=' + options.expires.toGMTString(); + if (options.secure) str += '; secure'; + + document.cookie = str; +} + +/** + * Return all cookies. + * + * @return {Object} + * @api private + */ + +function all() { + return parse(document.cookie); +} + +/** + * Get cookie `name`. + * + * @param {String} name + * @return {String} + * @api private + */ + +function get(name) { + return all()[name]; +} + +/** + * Parse cookie `str`. + * + * @param {String} str + * @return {Object} + * @api private + */ + +function parse(str) { + var obj = {}; + var pairs = str.split(/ *; */); + var pair; + if ('' == pairs[0]) return obj; + for (var i = 0; i < pairs.length; ++i) { + pair = pairs[i].split('='); + obj[decode(pair[0])] = decode(pair[1]); + } + return obj; +} + +}); +require.register("component-each/index.js", function(exports, require, module){ + +/** + * Module dependencies. + */ + +var type = require('type'); + +/** + * HOP reference. + */ + +var has = Object.prototype.hasOwnProperty; + +/** + * Iterate the given `obj` and invoke `fn(val, i)`. + * + * @param {String|Array|Object} obj + * @param {Function} fn + * @api public + */ + +module.exports = function(obj, fn){ + switch (type(obj)) { + case 'array': + return array(obj, fn); + case 'object': + if ('number' == typeof obj.length) return array(obj, fn); + return object(obj, fn); + case 'string': + return string(obj, fn); + } +}; + +/** + * Iterate string chars. + * + * @param {String} obj + * @param {Function} fn + * @api private + */ + +function string(obj, fn) { + for (var i = 0; i < obj.length; ++i) { + fn(obj.charAt(i), i); + } +} + +/** + * Iterate object keys. + * + * @param {Object} obj + * @param {Function} fn + * @api private + */ + +function object(obj, fn) { + for (var key in obj) { + if (has.call(obj, key)) { + fn(key, obj[key]); + } + } +} + +/** + * Iterate array-ish. + * + * @param {Array|Object} obj + * @param {Function} fn + * @api private + */ + +function array(obj, fn) { + for (var i = 0; i < obj.length; ++i) { + fn(obj[i], i); + } +} +}); +require.register("component-indexof/index.js", function(exports, require, module){ +module.exports = function(arr, obj){ + if (arr.indexOf) return arr.indexOf(obj); + for (var i = 0; i < arr.length; ++i) { + if (arr[i] === obj) return i; + } + return -1; +}; +}); +require.register("component-emitter/index.js", function(exports, require, module){ + +/** + * Module dependencies. + */ + +var index = require('indexof'); + +/** + * Expose `Emitter`. + */ + +module.exports = Emitter; + +/** + * Initialize a new `Emitter`. + * + * @api public + */ + +function Emitter(obj) { + if (obj) return mixin(obj); +}; + +/** + * Mixin the emitter properties. + * + * @param {Object} obj + * @return {Object} + * @api private + */ + +function mixin(obj) { + for (var key in Emitter.prototype) { + obj[key] = Emitter.prototype[key]; + } + return obj; +} + +/** + * Listen on the given `event` with `fn`. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.on = +Emitter.prototype.addEventListener = function(event, fn){ + this._callbacks = this._callbacks || {}; + (this._callbacks[event] = this._callbacks[event] || []) + .push(fn); + return this; +}; + +/** + * Adds an `event` listener that will be invoked a single + * time then automatically removed. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.once = function(event, fn){ + var self = this; + this._callbacks = this._callbacks || {}; + + function on() { + self.off(event, on); + fn.apply(this, arguments); + } + + fn._off = on; + this.on(event, on); + return this; +}; + +/** + * Remove the given callback for `event` or all + * registered callbacks. + * + * @param {String} event + * @param {Function} fn + * @return {Emitter} + * @api public + */ + +Emitter.prototype.off = +Emitter.prototype.removeListener = +Emitter.prototype.removeAllListeners = +Emitter.prototype.removeEventListener = function(event, fn){ + this._callbacks = this._callbacks || {}; + + // all + if (0 == arguments.length) { + this._callbacks = {}; + return this; + } + + // specific event + var callbacks = this._callbacks[event]; + if (!callbacks) return this; + + // remove all handlers + if (1 == arguments.length) { + delete this._callbacks[event]; + return this; + } + + // remove specific handler + var i = index(callbacks, fn._off || fn); + if (~i) callbacks.splice(i, 1); + return this; +}; + +/** + * Emit `event` with the given args. + * + * @param {String} event + * @param {Mixed} ... + * @return {Emitter} + */ + +Emitter.prototype.emit = function(event){ + this._callbacks = this._callbacks || {}; + var args = [].slice.call(arguments, 1) + , callbacks = this._callbacks[event]; + + if (callbacks) { + callbacks = callbacks.slice(0); + for (var i = 0, len = callbacks.length; i < len; ++i) { + callbacks[i].apply(this, args); + } + } + + return this; +}; + +/** + * Return array of callbacks for `event`. + * + * @param {String} event + * @return {Array} + * @api public + */ + +Emitter.prototype.listeners = function(event){ + this._callbacks = this._callbacks || {}; + return this._callbacks[event] || []; +}; + +/** + * Check if this emitter has `event` handlers. + * + * @param {String} event + * @return {Boolean} + * @api public + */ + +Emitter.prototype.hasListeners = function(event){ + return !! this.listeners(event).length; +}; + +}); +require.register("component-event/index.js", function(exports, require, module){ + +/** + * Bind `el` event `type` to `fn`. + * + * @param {Element} el + * @param {String} type + * @param {Function} fn + * @param {Boolean} capture + * @return {Function} + * @api public + */ + +exports.bind = function(el, type, fn, capture){ + if (el.addEventListener) { + el.addEventListener(type, fn, capture || false); + } else { + el.attachEvent('on' + type, fn); + } + return fn; +}; + +/** + * Unbind `el` event `type`'s callback `fn`. + * + * @param {Element} el + * @param {String} type + * @param {Function} fn + * @param {Boolean} capture + * @return {Function} + * @api public + */ + +exports.unbind = function(el, type, fn, capture){ + if (el.removeEventListener) { + el.removeEventListener(type, fn, capture || false); + } else { + el.detachEvent('on' + type, fn); + } + return fn; +}; + +}); +require.register("component-inherit/index.js", function(exports, require, module){ + +module.exports = function(a, b){ + var fn = function(){}; + fn.prototype = b.prototype; + a.prototype = new fn; + a.prototype.constructor = a; +}; +}); +require.register("component-object/index.js", function(exports, require, module){ + +/** + * HOP ref. + */ + +var has = Object.prototype.hasOwnProperty; + +/** + * Return own keys in `obj`. + * + * @param {Object} obj + * @return {Array} + * @api public + */ + +exports.keys = Object.keys || function(obj){ + var keys = []; + for (var key in obj) { + if (has.call(obj, key)) { + keys.push(key); + } + } + return keys; +}; + +/** + * Return own values in `obj`. + * + * @param {Object} obj + * @return {Array} + * @api public + */ + +exports.values = function(obj){ + var vals = []; + for (var key in obj) { + if (has.call(obj, key)) { + vals.push(obj[key]); + } + } + return vals; +}; + +/** + * Merge `b` into `a`. + * + * @param {Object} a + * @param {Object} b + * @return {Object} a + * @api public + */ + +exports.merge = function(a, b){ + for (var key in b) { + if (has.call(b, key)) { + a[key] = b[key]; + } + } + return a; +}; + +/** + * Return length of `obj`. + * + * @param {Object} obj + * @return {Number} + * @api public + */ + +exports.length = function(obj){ + return exports.keys(obj).length; +}; + +/** + * Check if `obj` is empty. + * + * @param {Object} obj + * @return {Boolean} + * @api public + */ + +exports.isEmpty = function(obj){ + return 0 == exports.length(obj); +}; +}); +require.register("component-trim/index.js", function(exports, require, module){ + +exports = module.exports = trim; + +function trim(str){ + if (str.trim) return str.trim(); + return str.replace(/^\s*|\s*$/g, ''); +} + +exports.left = function(str){ + if (str.trimLeft) return str.trimLeft(); + return str.replace(/^\s*/, ''); +}; + +exports.right = function(str){ + if (str.trimRight) return str.trimRight(); + return str.replace(/\s*$/, ''); +}; + +}); +require.register("component-querystring/index.js", function(exports, require, module){ + +/** + * Module dependencies. + */ + +var encode = encodeURIComponent; +var decode = decodeURIComponent; +var trim = require('trim'); +var type = require('type'); + +/** + * Parse the given query `str`. + * + * @param {String} str + * @return {Object} + * @api public + */ + +exports.parse = function(str){ + if ('string' != typeof str) return {}; + + str = trim(str); + if ('' == str) return {}; + if ('?' == str.charAt(0)) str = str.slice(1); + + var obj = {}; + var pairs = str.split('&'); + for (var i = 0; i < pairs.length; i++) { + var parts = pairs[i].split('='); + var key = decode(parts[0]); + var m; + + if (m = /(\w+)\[(\d+)\]/.exec(key)) { + obj[m[1]] = obj[m[1]] || []; + obj[m[1]][m[2]] = decode(parts[1]); + continue; + } + + obj[parts[0]] = null == parts[1] + ? '' + : decode(parts[1]); + } + + return obj; +}; + +/** + * Stringify the given `obj`. + * + * @param {Object} obj + * @return {String} + * @api public + */ + +exports.stringify = function(obj){ + if (!obj) return ''; + var pairs = []; + + for (var key in obj) { + var value = obj[key]; + + if ('array' == type(value)) { + for (var i = 0; i < value.length; ++i) { + pairs.push(encode(key + '[' + i + ']') + '=' + encode(value[i])); + } + continue; + } + + pairs.push(encode(key) + '=' + encode(obj[key])); + } + + return pairs.join('&'); +}; + +}); +require.register("component-url/index.js", function(exports, require, module){ + +/** + * Parse the given `url`. + * + * @param {String} str + * @return {Object} + * @api public + */ + +exports.parse = function(url){ + var a = document.createElement('a'); + a.href = url; + return { + href: a.href, + host: a.host, + port: a.port, + hash: a.hash, + hostname: a.hostname, + pathname: a.pathname, + protocol: a.protocol, + search: a.search, + query: a.search.slice(1) + } +}; + +/** + * Check if `url` is absolute. + * + * @param {String} url + * @return {Boolean} + * @api public + */ + +exports.isAbsolute = function(url){ + if (0 == url.indexOf('//')) return true; + if (~url.indexOf('://')) return true; + return false; +}; + +/** + * Check if `url` is relative. + * + * @param {String} url + * @return {Boolean} + * @api public + */ + +exports.isRelative = function(url){ + return ! exports.isAbsolute(url); +}; + +/** + * Check if `url` is cross domain. + * + * @param {String} url + * @return {Boolean} + * @api public + */ + +exports.isCrossDomain = function(url){ + url = exports.parse(url); + return url.hostname != location.hostname + || url.port != location.port + || url.protocol != location.protocol; +}; +}); +require.register("component-bind/index.js", function(exports, require, module){ +/** + * Slice reference. + */ + +var slice = [].slice; + +/** + * Bind `obj` to `fn`. + * + * @param {Object} obj + * @param {Function|String} fn or string + * @return {Function} + * @api public + */ + +module.exports = function(obj, fn){ + if ('string' == typeof fn) fn = obj[fn]; + if ('function' != typeof fn) throw new Error('bind() requires a function'); + var args = slice.call(arguments, 2); + return function(){ + return fn.apply(obj, args.concat(slice.call(arguments))); + } +}; + +}); +require.register("segmentio-bind-all/index.js", function(exports, require, module){ + +try { + var bind = require('bind'); + var type = require('type'); +} catch (e) { + var bind = require('bind-component'); + var type = require('type-component'); +} + +module.exports = function (obj) { + for (var key in obj) { + var val = obj[key]; + if (type(val) === 'function') obj[key] = bind(obj, obj[key]); + } + return obj; +}; +}); +require.register("ianstormtaylor-bind/index.js", function(exports, require, module){ + +try { + var bind = require('bind'); +} catch (e) { + var bind = require('bind-component'); +} + +var bindAll = require('bind-all'); + + +/** + * Expose `bind`. + */ + +module.exports = exports = bind; + + +/** + * Expose `bindAll`. + */ + +exports.all = bindAll; + + +/** + * Expose `bindMethods`. + */ + +exports.methods = bindMethods; + + +/** + * Bind `methods` on `obj` to always be called with the `obj` as context. + * + * @param {Object} obj + * @param {String} methods... + */ + +function bindMethods (obj, methods) { + methods = [].slice.call(arguments, 1); + for (var i = 0, method; method = methods[i]; i++) { + obj[method] = bind(obj, obj[method]); + } + return obj; +} +}); +require.register("timoxley-next-tick/index.js", function(exports, require, module){ +"use strict" + +if (typeof setImmediate == 'function') { + module.exports = function(f){ setImmediate(f) } +} +// legacy node.js +else if (typeof process != 'undefined' && typeof process.nextTick == 'function') { + module.exports = process.nextTick +} +// fallback for other environments / postMessage behaves badly on IE8 +else if (typeof window == 'undefined' || window.ActiveXObject || !window.postMessage) { + module.exports = function(f){ setTimeout(f) }; +} else { + var q = []; + + window.addEventListener('message', function(){ + var i = 0; + while (i < q.length) { + try { q[i++](); } + catch (e) { + q = q.slice(i); + window.postMessage('tic!', '*'); + throw e; + } + } + q.length = 0; + }, true); + + module.exports = function(fn){ + if (!q.length) window.postMessage('tic!', '*'); + q.push(fn); + } +} + +}); +require.register("ianstormtaylor-callback/index.js", function(exports, require, module){ +var next = require('next-tick'); + + +/** + * Expose `callback`. + */ + +module.exports = callback; + + +/** + * Call an `fn` back synchronously if it exists. + * + * @param {Function} fn + */ + +function callback (fn) { + if ('function' === typeof fn) fn(); +} + + +/** + * Call an `fn` back asynchronously if it exists. If `wait` is ommitted, the + * `fn` will be called on next tick. + * + * @param {Function} fn + * @param {Number} wait (optional) + */ + +callback.async = function (fn, wait) { + if ('function' !== typeof fn) return; + if (!wait) return next(fn); + setTimeout(fn, wait); +}; + + +/** + * Symmetry. + */ + +callback.sync = callback; + +}); +require.register("ianstormtaylor-is-empty/index.js", function(exports, require, module){ + +/** + * Expose `isEmpty`. + */ + +module.exports = isEmpty; + + +/** + * Has. + */ + +var has = Object.prototype.hasOwnProperty; + + +/** + * Test whether a value is "empty". + * + * @param {Mixed} val + * @return {Boolean} + */ + +function isEmpty (val) { + if (null == val) return true; + if ('number' == typeof val) return 0 === val; + if (undefined !== val.length) return 0 === val.length; + for (var key in val) if (has.call(val, key)) return false; + return true; +} +}); +require.register("ianstormtaylor-is/index.js", function(exports, require, module){ + +var isEmpty = require('is-empty'); + +try { + var typeOf = require('type'); +} catch (e) { + var typeOf = require('component-type'); +} + + +/** + * Types. + */ + +var types = [ + 'arguments', + 'array', + 'boolean', + 'date', + 'element', + 'function', + 'null', + 'number', + 'object', + 'regexp', + 'string', + 'undefined' +]; + + +/** + * Expose type checkers. + * + * @param {Mixed} value + * @return {Boolean} + */ + +for (var i = 0, type; type = types[i]; i++) exports[type] = generate(type); + + +/** + * Add alias for `function` for old browsers. + */ + +exports.fn = exports['function']; + + +/** + * Expose `empty` check. + */ + +exports.empty = isEmpty; + + +/** + * Expose `nan` check. + */ + +exports.nan = function (val) { + return exports.number(val) && val != val; +}; + + +/** + * Generate a type checker. + * + * @param {String} type + * @return {Function} + */ + +function generate (type) { + return function (value) { + return type === typeOf(value); + }; +} +}); +require.register("segmentio-after/index.js", function(exports, require, module){ + +module.exports = function after (times, func) { + // After 0, really? + if (times <= 0) return func(); + + // That's more like it. + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; +}; +}); +require.register("component-domify/index.js", function(exports, require, module){ + +/** + * Expose `parse`. + */ + +module.exports = parse; + +/** + * Wrap map from jquery. + */ + +var map = { + legend: [1, '
'], + tr: [2, '