|
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Viewer = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ |
|
|
|
},{}],2:[function(require,module,exports){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
function EventEmitter() { |
|
this._events = this._events || {}; |
|
this._maxListeners = this._maxListeners || undefined; |
|
} |
|
module.exports = EventEmitter; |
|
|
|
// Backwards-compat with node 0.10.x |
|
EventEmitter.EventEmitter = EventEmitter; |
|
|
|
EventEmitter.prototype._events = undefined; |
|
EventEmitter.prototype._maxListeners = undefined; |
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are |
|
// added to it. This is a useful default which helps finding memory leaks. |
|
EventEmitter.defaultMaxListeners = 10; |
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows |
|
// that to be increased. Set to zero for unlimited. |
|
EventEmitter.prototype.setMaxListeners = function(n) { |
|
if (!isNumber(n) || n < 0 || isNaN(n)) |
|
throw TypeError('n must be a positive number'); |
|
this._maxListeners = n; |
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.emit = function(type) { |
|
var er, handler, len, args, i, listeners; |
|
|
|
if (!this._events) |
|
this._events = {}; |
|
|
|
// If there is no 'error' event listener then throw. |
|
if (type === 'error') { |
|
if (!this._events.error || |
|
(isObject(this._events.error) && !this._events.error.length)) { |
|
er = arguments[1]; |
|
if (er instanceof Error) { |
|
throw er; // Unhandled 'error' event |
|
} |
|
throw TypeError('Uncaught, unspecified "error" event.'); |
|
} |
|
} |
|
|
|
handler = this._events[type]; |
|
|
|
if (isUndefined(handler)) |
|
return false; |
|
|
|
if (isFunction(handler)) { |
|
switch (arguments.length) { |
|
// fast cases |
|
case 1: |
|
handler.call(this); |
|
break; |
|
case 2: |
|
handler.call(this, arguments[1]); |
|
break; |
|
case 3: |
|
handler.call(this, arguments[1], arguments[2]); |
|
break; |
|
// slower |
|
default: |
|
len = arguments.length; |
|
args = new Array(len - 1); |
|
for (i = 1; i < len; i++) |
|
args[i - 1] = arguments[i]; |
|
handler.apply(this, args); |
|
} |
|
} else if (isObject(handler)) { |
|
len = arguments.length; |
|
args = new Array(len - 1); |
|
for (i = 1; i < len; i++) |
|
args[i - 1] = arguments[i]; |
|
|
|
listeners = handler.slice(); |
|
len = listeners.length; |
|
for (i = 0; i < len; i++) |
|
listeners[i].apply(this, args); |
|
} |
|
|
|
return true; |
|
}; |
|
|
|
EventEmitter.prototype.addListener = function(type, listener) { |
|
var m; |
|
|
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
if (!this._events) |
|
this._events = {}; |
|
|
|
// To avoid recursion in the case that type === "newListener"! Before |
|
// adding it to the listeners, first emit "newListener". |
|
if (this._events.newListener) |
|
this.emit('newListener', type, |
|
isFunction(listener.listener) ? |
|
listener.listener : listener); |
|
|
|
if (!this._events[type]) |
|
// Optimize the case of one listener. Don't need the extra array object. |
|
this._events[type] = listener; |
|
else if (isObject(this._events[type])) |
|
// If we've already got an array, just append. |
|
this._events[type].push(listener); |
|
else |
|
// Adding the second element, need to change to array. |
|
this._events[type] = [this._events[type], listener]; |
|
|
|
// Check for listener leak |
|
if (isObject(this._events[type]) && !this._events[type].warned) { |
|
var m; |
|
if (!isUndefined(this._maxListeners)) { |
|
m = this._maxListeners; |
|
} else { |
|
m = EventEmitter.defaultMaxListeners; |
|
} |
|
|
|
if (m && m > 0 && this._events[type].length > m) { |
|
this._events[type].warned = true; |
|
console.error('(node) warning: possible EventEmitter memory ' + |
|
'leak detected. %d listeners added. ' + |
|
'Use emitter.setMaxListeners() to increase limit.', |
|
this._events[type].length); |
|
if (typeof console.trace === 'function') { |
|
// not supported in IE 10 |
|
console.trace(); |
|
} |
|
} |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener; |
|
|
|
EventEmitter.prototype.once = function(type, listener) { |
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
var fired = false; |
|
|
|
function g() { |
|
this.removeListener(type, g); |
|
|
|
if (!fired) { |
|
fired = true; |
|
listener.apply(this, arguments); |
|
} |
|
} |
|
|
|
g.listener = listener; |
|
this.on(type, g); |
|
|
|
return this; |
|
}; |
|
|
|
// emits a 'removeListener' event iff the listener was removed |
|
EventEmitter.prototype.removeListener = function(type, listener) { |
|
var list, position, length, i; |
|
|
|
if (!isFunction(listener)) |
|
throw TypeError('listener must be a function'); |
|
|
|
if (!this._events || !this._events[type]) |
|
return this; |
|
|
|
list = this._events[type]; |
|
length = list.length; |
|
position = -1; |
|
|
|
if (list === listener || |
|
(isFunction(list.listener) && list.listener === listener)) { |
|
delete this._events[type]; |
|
if (this._events.removeListener) |
|
this.emit('removeListener', type, listener); |
|
|
|
} else if (isObject(list)) { |
|
for (i = length; i-- > 0;) { |
|
if (list[i] === listener || |
|
(list[i].listener && list[i].listener === listener)) { |
|
position = i; |
|
break; |
|
} |
|
} |
|
|
|
if (position < 0) |
|
return this; |
|
|
|
if (list.length === 1) { |
|
list.length = 0; |
|
delete this._events[type]; |
|
} else { |
|
list.splice(position, 1); |
|
} |
|
|
|
if (this._events.removeListener) |
|
this.emit('removeListener', type, listener); |
|
} |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) { |
|
var key, listeners; |
|
|
|
if (!this._events) |
|
return this; |
|
|
|
// not listening for removeListener, no need to emit |
|
if (!this._events.removeListener) { |
|
if (arguments.length === 0) |
|
this._events = {}; |
|
else if (this._events[type]) |
|
delete this._events[type]; |
|
return this; |
|
} |
|
|
|
// emit removeListener for all listeners on all events |
|
if (arguments.length === 0) { |
|
for (key in this._events) { |
|
if (key === 'removeListener') continue; |
|
this.removeAllListeners(key); |
|
} |
|
this.removeAllListeners('removeListener'); |
|
this._events = {}; |
|
return this; |
|
} |
|
|
|
listeners = this._events[type]; |
|
|
|
if (isFunction(listeners)) { |
|
this.removeListener(type, listeners); |
|
} else { |
|
// LIFO order |
|
while (listeners.length) |
|
this.removeListener(type, listeners[listeners.length - 1]); |
|
} |
|
delete this._events[type]; |
|
|
|
return this; |
|
}; |
|
|
|
EventEmitter.prototype.listeners = function(type) { |
|
var ret; |
|
if (!this._events || !this._events[type]) |
|
ret = []; |
|
else if (isFunction(this._events[type])) |
|
ret = [this._events[type]]; |
|
else |
|
ret = this._events[type].slice(); |
|
return ret; |
|
}; |
|
|
|
EventEmitter.listenerCount = function(emitter, type) { |
|
var ret; |
|
if (!emitter._events || !emitter._events[type]) |
|
ret = 0; |
|
else if (isFunction(emitter._events[type])) |
|
ret = 1; |
|
else |
|
ret = emitter._events[type].length; |
|
return ret; |
|
}; |
|
|
|
function isFunction(arg) { |
|
return typeof arg === 'function'; |
|
} |
|
|
|
function isNumber(arg) { |
|
return typeof arg === 'number'; |
|
} |
|
|
|
function isObject(arg) { |
|
return typeof arg === 'object' && arg !== null; |
|
} |
|
|
|
function isUndefined(arg) { |
|
return arg === void 0; |
|
} |
|
|
|
},{}],3:[function(require,module,exports){ |
|
if (typeof Object.create === 'function') { |
|
// implementation from standard node.js 'util' module |
|
module.exports = function inherits(ctor, superCtor) { |
|
ctor.super_ = superCtor |
|
ctor.prototype = Object.create(superCtor.prototype, { |
|
constructor: { |
|
value: ctor, |
|
enumerable: false, |
|
writable: true, |
|
configurable: true |
|
} |
|
}); |
|
}; |
|
} else { |
|
// old school shim for old browsers |
|
module.exports = function inherits(ctor, superCtor) { |
|
ctor.super_ = superCtor |
|
var TempCtor = function () {} |
|
TempCtor.prototype = superCtor.prototype |
|
ctor.prototype = new TempCtor() |
|
ctor.prototype.constructor = ctor |
|
} |
|
} |
|
|
|
},{}],4:[function(require,module,exports){ |
|
// shim for using process in browser |
|
|
|
var process = module.exports = {}; |
|
var queue = []; |
|
var draining = false; |
|
var currentQueue; |
|
var queueIndex = -1; |
|
|
|
function cleanUpNextTick() { |
|
draining = false; |
|
if (currentQueue.length) { |
|
queue = currentQueue.concat(queue); |
|
} else { |
|
queueIndex = -1; |
|
} |
|
if (queue.length) { |
|
drainQueue(); |
|
} |
|
} |
|
|
|
function drainQueue() { |
|
if (draining) { |
|
return; |
|
} |
|
var timeout = setTimeout(cleanUpNextTick); |
|
draining = true; |
|
|
|
var len = queue.length; |
|
while(len) { |
|
currentQueue = queue; |
|
queue = []; |
|
while (++queueIndex < len) { |
|
currentQueue[queueIndex].run(); |
|
} |
|
queueIndex = -1; |
|
len = queue.length; |
|
} |
|
currentQueue = null; |
|
draining = false; |
|
clearTimeout(timeout); |
|
} |
|
|
|
process.nextTick = function (fun) { |
|
var args = new Array(arguments.length - 1); |
|
if (arguments.length > 1) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
args[i - 1] = arguments[i]; |
|
} |
|
} |
|
queue.push(new Item(fun, args)); |
|
if (queue.length === 1 && !draining) { |
|
setTimeout(drainQueue, 0); |
|
} |
|
}; |
|
|
|
// v8 likes predictible objects |
|
function Item(fun, array) { |
|
this.fun = fun; |
|
this.array = array; |
|
} |
|
Item.prototype.run = function () { |
|
this.fun.apply(null, this.array); |
|
}; |
|
process.title = 'browser'; |
|
process.browser = true; |
|
process.env = {}; |
|
process.argv = []; |
|
process.version = ''; // empty string to avoid regexp issues |
|
process.versions = {}; |
|
|
|
function noop() {} |
|
|
|
process.on = noop; |
|
process.addListener = noop; |
|
process.once = noop; |
|
process.off = noop; |
|
process.removeListener = noop; |
|
process.removeAllListeners = noop; |
|
process.emit = noop; |
|
|
|
process.binding = function (name) { |
|
throw new Error('process.binding is not supported'); |
|
}; |
|
|
|
// TODO(shtylman) |
|
process.cwd = function () { return '/' }; |
|
process.chdir = function (dir) { |
|
throw new Error('process.chdir is not supported'); |
|
}; |
|
process.umask = function() { return 0; }; |
|
|
|
},{}],5:[function(require,module,exports){ |
|
module.exports = function isBuffer(arg) { |
|
return arg && typeof arg === 'object' |
|
&& typeof arg.copy === 'function' |
|
&& typeof arg.fill === 'function' |
|
&& typeof arg.readUInt8 === 'function'; |
|
} |
|
},{}],6:[function(require,module,exports){ |
|
(function (process,global){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
var formatRegExp = /%[sdj%]/g; |
|
exports.format = function(f) { |
|
if (!isString(f)) { |
|
var objects = []; |
|
for (var i = 0; i < arguments.length; i++) { |
|
objects.push(inspect(arguments[i])); |
|
} |
|
return objects.join(' '); |
|
} |
|
|
|
var i = 1; |
|
var args = arguments; |
|
var len = args.length; |
|
var str = String(f).replace(formatRegExp, function(x) { |
|
if (x === '%%') return '%'; |
|
if (i >= len) return x; |
|
switch (x) { |
|
case '%s': return String(args[i++]); |
|
case '%d': return Number(args[i++]); |
|
case '%j': |
|
try { |
|
return JSON.stringify(args[i++]); |
|
} catch (_) { |
|
return '[Circular]'; |
|
} |
|
default: |
|
return x; |
|
} |
|
}); |
|
for (var x = args[i]; i < len; x = args[++i]) { |
|
if (isNull(x) || !isObject(x)) { |
|
str += ' ' + x; |
|
} else { |
|
str += ' ' + inspect(x); |
|
} |
|
} |
|
return str; |
|
}; |
|
|
|
|
|
// Mark that a method should not be used. |
|
// Returns a modified function which warns once by default. |
|
// If --no-deprecation is set, then it is a no-op. |
|
exports.deprecate = function(fn, msg) { |
|
// Allow for deprecating things in the process of starting up. |
|
if (isUndefined(global.process)) { |
|
return function() { |
|
return exports.deprecate(fn, msg).apply(this, arguments); |
|
}; |
|
} |
|
|
|
if (process.noDeprecation === true) { |
|
return fn; |
|
} |
|
|
|
var warned = false; |
|
function deprecated() { |
|
if (!warned) { |
|
if (process.throwDeprecation) { |
|
throw new Error(msg); |
|
} else if (process.traceDeprecation) { |
|
console.trace(msg); |
|
} else { |
|
console.error(msg); |
|
} |
|
warned = true; |
|
} |
|
return fn.apply(this, arguments); |
|
} |
|
|
|
return deprecated; |
|
}; |
|
|
|
|
|
var debugs = {}; |
|
var debugEnviron; |
|
exports.debuglog = function(set) { |
|
if (isUndefined(debugEnviron)) |
|
debugEnviron = process.env.NODE_DEBUG || ''; |
|
set = set.toUpperCase(); |
|
if (!debugs[set]) { |
|
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { |
|
var pid = process.pid; |
|
debugs[set] = function() { |
|
var msg = exports.format.apply(exports, arguments); |
|
console.error('%s %d: %s', set, pid, msg); |
|
}; |
|
} else { |
|
debugs[set] = function() {}; |
|
} |
|
} |
|
return debugs[set]; |
|
}; |
|
|
|
|
|
/** |
|
* Echos the value of a value. Trys to print the value out |
|
* in the best way possible given the different types. |
|
* |
|
* @param {Object} obj The object to print out. |
|
* @param {Object} opts Optional options object that alters the output. |
|
*/ |
|
/* legacy: obj, showHidden, depth, colors*/ |
|
function inspect(obj, opts) { |
|
// default options |
|
var ctx = { |
|
seen: [], |
|
stylize: stylizeNoColor |
|
}; |
|
// legacy... |
|
if (arguments.length >= 3) ctx.depth = arguments[2]; |
|
if (arguments.length >= 4) ctx.colors = arguments[3]; |
|
if (isBoolean(opts)) { |
|
// legacy... |
|
ctx.showHidden = opts; |
|
} else if (opts) { |
|
// got an "options" object |
|
exports._extend(ctx, opts); |
|
} |
|
// set default options |
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false; |
|
if (isUndefined(ctx.depth)) ctx.depth = 2; |
|
if (isUndefined(ctx.colors)) ctx.colors = false; |
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true; |
|
if (ctx.colors) ctx.stylize = stylizeWithColor; |
|
return formatValue(ctx, obj, ctx.depth); |
|
} |
|
exports.inspect = inspect; |
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics |
|
inspect.colors = { |
|
'bold' : [1, 22], |
|
'italic' : [3, 23], |
|
'underline' : [4, 24], |
|
'inverse' : [7, 27], |
|
'white' : [37, 39], |
|
'grey' : [90, 39], |
|
'black' : [30, 39], |
|
'blue' : [34, 39], |
|
'cyan' : [36, 39], |
|
'green' : [32, 39], |
|
'magenta' : [35, 39], |
|
'red' : [31, 39], |
|
'yellow' : [33, 39] |
|
}; |
|
|
|
// Don't use 'blue' not visible on cmd.exe |
|
inspect.styles = { |
|
'special': 'cyan', |
|
'number': 'yellow', |
|
'boolean': 'yellow', |
|
'undefined': 'grey', |
|
'null': 'bold', |
|
'string': 'green', |
|
'date': 'magenta', |
|
// "name": intentionally not styling |
|
'regexp': 'red' |
|
}; |
|
|
|
|
|
function stylizeWithColor(str, styleType) { |
|
var style = inspect.styles[styleType]; |
|
|
|
if (style) { |
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str + |
|
'\u001b[' + inspect.colors[style][1] + 'm'; |
|
} else { |
|
return str; |
|
} |
|
} |
|
|
|
|
|
function stylizeNoColor(str, styleType) { |
|
return str; |
|
} |
|
|
|
|
|
function arrayToHash(array) { |
|
var hash = {}; |
|
|
|
array.forEach(function(val, idx) { |
|
hash[val] = true; |
|
}); |
|
|
|
return hash; |
|
} |
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) { |
|
// Provide a hook for user-specified inspect functions. |
|
// Check that value is an object with an inspect function on it |
|
if (ctx.customInspect && |
|
value && |
|
isFunction(value.inspect) && |
|
// Filter out the util module, it's inspect function is special |
|
value.inspect !== exports.inspect && |
|
// Also filter out any prototype objects using the circular check. |
|
!(value.constructor && value.constructor.prototype === value)) { |
|
var ret = value.inspect(recurseTimes, ctx); |
|
if (!isString(ret)) { |
|
ret = formatValue(ctx, ret, recurseTimes); |
|
} |
|
return ret; |
|
} |
|
|
|
// Primitive types cannot have properties |
|
var primitive = formatPrimitive(ctx, value); |
|
if (primitive) { |
|
return primitive; |
|
} |
|
|
|
// Look up the keys of the object. |
|
var keys = Object.keys(value); |
|
var visibleKeys = arrayToHash(keys); |
|
|
|
if (ctx.showHidden) { |
|
keys = Object.getOwnPropertyNames(value); |
|
} |
|
|
|
// IE doesn't make error fields non-enumerable |
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx |
|
if (isError(value) |
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { |
|
return formatError(value); |
|
} |
|
|
|
// Some type of object without properties can be shortcutted. |
|
if (keys.length === 0) { |
|
if (isFunction(value)) { |
|
var name = value.name ? ': ' + value.name : ''; |
|
return ctx.stylize('[Function' + name + ']', 'special'); |
|
} |
|
if (isRegExp(value)) { |
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
|
} |
|
if (isDate(value)) { |
|
return ctx.stylize(Date.prototype.toString.call(value), 'date'); |
|
} |
|
if (isError(value)) { |
|
return formatError(value); |
|
} |
|
} |
|
|
|
var base = '', array = false, braces = ['{', '}']; |
|
|
|
// Make Array say that they are Array |
|
if (isArray(value)) { |
|
array = true; |
|
braces = ['[', ']']; |
|
} |
|
|
|
// Make functions say that they are functions |
|
if (isFunction(value)) { |
|
var n = value.name ? ': ' + value.name : ''; |
|
base = ' [Function' + n + ']'; |
|
} |
|
|
|
// Make RegExps say that they are RegExps |
|
if (isRegExp(value)) { |
|
base = ' ' + RegExp.prototype.toString.call(value); |
|
} |
|
|
|
// Make dates with properties first say the date |
|
if (isDate(value)) { |
|
base = ' ' + Date.prototype.toUTCString.call(value); |
|
} |
|
|
|
// Make error with message first say the error |
|
if (isError(value)) { |
|
base = ' ' + formatError(value); |
|
} |
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) { |
|
return braces[0] + base + braces[1]; |
|
} |
|
|
|
if (recurseTimes < 0) { |
|
if (isRegExp(value)) { |
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); |
|
} else { |
|
return ctx.stylize('[Object]', 'special'); |
|
} |
|
} |
|
|
|
ctx.seen.push(value); |
|
|
|
var output; |
|
if (array) { |
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); |
|
} else { |
|
output = keys.map(function(key) { |
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); |
|
}); |
|
} |
|
|
|
ctx.seen.pop(); |
|
|
|
return reduceToSingleString(output, base, braces); |
|
} |
|
|
|
|
|
function formatPrimitive(ctx, value) { |
|
if (isUndefined(value)) |
|
return ctx.stylize('undefined', 'undefined'); |
|
if (isString(value)) { |
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') |
|
.replace(/'/g, "\\'") |
|
.replace(/\\"/g, '"') + '\''; |
|
return ctx.stylize(simple, 'string'); |
|
} |
|
if (isNumber(value)) |
|
return ctx.stylize('' + value, 'number'); |
|
if (isBoolean(value)) |
|
return ctx.stylize('' + value, 'boolean'); |
|
// For some reason typeof null is "object", so special case here. |
|
if (isNull(value)) |
|
return ctx.stylize('null', 'null'); |
|
} |
|
|
|
|
|
function formatError(value) { |
|
return '[' + Error.prototype.toString.call(value) + ']'; |
|
} |
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { |
|
var output = []; |
|
for (var i = 0, l = value.length; i < l; ++i) { |
|
if (hasOwnProperty(value, String(i))) { |
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
|
String(i), true)); |
|
} else { |
|
output.push(''); |
|
} |
|
} |
|
keys.forEach(function(key) { |
|
if (!key.match(/^\d+$/)) { |
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, |
|
key, true)); |
|
} |
|
}); |
|
return output; |
|
} |
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { |
|
var name, str, desc; |
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; |
|
if (desc.get) { |
|
if (desc.set) { |
|
str = ctx.stylize('[Getter/Setter]', 'special'); |
|
} else { |
|
str = ctx.stylize('[Getter]', 'special'); |
|
} |
|
} else { |
|
if (desc.set) { |
|
str = ctx.stylize('[Setter]', 'special'); |
|
} |
|
} |
|
if (!hasOwnProperty(visibleKeys, key)) { |
|
name = '[' + key + ']'; |
|
} |
|
if (!str) { |
|
if (ctx.seen.indexOf(desc.value) < 0) { |
|
if (isNull(recurseTimes)) { |
|
str = formatValue(ctx, desc.value, null); |
|
} else { |
|
str = formatValue(ctx, desc.value, recurseTimes - 1); |
|
} |
|
if (str.indexOf('\n') > -1) { |
|
if (array) { |
|
str = str.split('\n').map(function(line) { |
|
return ' ' + line; |
|
}).join('\n').substr(2); |
|
} else { |
|
str = '\n' + str.split('\n').map(function(line) { |
|
return ' ' + line; |
|
}).join('\n'); |
|
} |
|
} |
|
} else { |
|
str = ctx.stylize('[Circular]', 'special'); |
|
} |
|
} |
|
if (isUndefined(name)) { |
|
if (array && key.match(/^\d+$/)) { |
|
return str; |
|
} |
|
name = JSON.stringify('' + key); |
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { |
|
name = name.substr(1, name.length - 2); |
|
name = ctx.stylize(name, 'name'); |
|
} else { |
|
name = name.replace(/'/g, "\\'") |
|
.replace(/\\"/g, '"') |
|
.replace(/(^"|"$)/g, "'"); |
|
name = ctx.stylize(name, 'string'); |
|
} |
|
} |
|
|
|
return name + ': ' + str; |
|
} |
|
|
|
|
|
function reduceToSingleString(output, base, braces) { |
|
var numLinesEst = 0; |
|
var length = output.reduce(function(prev, cur) { |
|
numLinesEst++; |
|
if (cur.indexOf('\n') >= 0) numLinesEst++; |
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; |
|
}, 0); |
|
|
|
if (length > 60) { |
|
return braces[0] + |
|
(base === '' ? '' : base + '\n ') + |
|
' ' + |
|
output.join(',\n ') + |
|
' ' + |
|
braces[1]; |
|
} |
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; |
|
} |
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof` |
|
// because it is fragile and can be easily faked with `Object.create()`. |
|
function isArray(ar) { |
|
return Array.isArray(ar); |
|
} |
|
exports.isArray = isArray; |
|
|
|
function isBoolean(arg) { |
|
return typeof arg === 'boolean'; |
|
} |
|
exports.isBoolean = isBoolean; |
|
|
|
function isNull(arg) { |
|
return arg === null; |
|
} |
|
exports.isNull = isNull; |
|
|
|
function isNullOrUndefined(arg) { |
|
return arg == null; |
|
} |
|
exports.isNullOrUndefined = isNullOrUndefined; |
|
|
|
function isNumber(arg) { |
|
return typeof arg === 'number'; |
|
} |
|
exports.isNumber = isNumber; |
|
|
|
function isString(arg) { |
|
return typeof arg === 'string'; |
|
} |
|
exports.isString = isString; |
|
|
|
function isSymbol(arg) { |
|
return typeof arg === 'symbol'; |
|
} |
|
exports.isSymbol = isSymbol; |
|
|
|
function isUndefined(arg) { |
|
return arg === void 0; |
|
} |
|
exports.isUndefined = isUndefined; |
|
|
|
function isRegExp(re) { |
|
return isObject(re) && objectToString(re) === '[object RegExp]'; |
|
} |
|
exports.isRegExp = isRegExp; |
|
|
|
function isObject(arg) { |
|
return typeof arg === 'object' && arg !== null; |
|
} |
|
exports.isObject = isObject; |
|
|
|
function isDate(d) { |
|
return isObject(d) && objectToString(d) === '[object Date]'; |
|
} |
|
exports.isDate = isDate; |
|
|
|
function isError(e) { |
|
return isObject(e) && |
|
(objectToString(e) === '[object Error]' || e instanceof Error); |
|
} |
|
exports.isError = isError; |
|
|
|
function isFunction(arg) { |
|
return typeof arg === 'function'; |
|
} |
|
exports.isFunction = isFunction; |
|
|
|
function isPrimitive(arg) { |
|
return arg === null || |
|
typeof arg === 'boolean' || |
|
typeof arg === 'number' || |
|
typeof arg === 'string' || |
|
typeof arg === 'symbol' || // ES6 symbol |
|
typeof arg === 'undefined'; |
|
} |
|
exports.isPrimitive = isPrimitive; |
|
|
|
exports.isBuffer = require('./support/isBuffer'); |
|
|
|
function objectToString(o) { |
|
return Object.prototype.toString.call(o); |
|
} |
|
|
|
|
|
function pad(n) { |
|
return n < 10 ? '0' + n.toString(10) : n.toString(10); |
|
} |
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', |
|
'Oct', 'Nov', 'Dec']; |
|
|
|
// 26 Feb 16:19:34 |
|
function timestamp() { |
|
var d = new Date(); |
|
var time = [pad(d.getHours()), |
|
pad(d.getMinutes()), |
|
pad(d.getSeconds())].join(':'); |
|
return [d.getDate(), months[d.getMonth()], time].join(' '); |
|
} |
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp |
|
exports.log = function() { |
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); |
|
}; |
|
|
|
|
|
/** |
|
* Inherit the prototype methods from one constructor into another. |
|
* |
|
* The Function.prototype.inherits from lang.js rewritten as a standalone |
|
* function (not on Function.prototype). NOTE: If this file is to be loaded |
|
* during bootstrapping this function needs to be rewritten using some native |
|
* functions as prototype setup using normal JavaScript does not work as |
|
* expected during bootstrapping (see mirror.js in r114903). |
|
* |
|
* @param {function} ctor Constructor function which needs to inherit the |
|
* prototype. |
|
* @param {function} superCtor Constructor function to inherit prototype from. |
|
*/ |
|
exports.inherits = require('inherits'); |
|
|
|
exports._extend = function(origin, add) { |
|
// Don't do anything if add isn't an object |
|
if (!add || !isObject(add)) return origin; |
|
|
|
var keys = Object.keys(add); |
|
var i = keys.length; |
|
while (i--) { |
|
origin[keys[i]] = add[keys[i]]; |
|
} |
|
return origin; |
|
}; |
|
|
|
function hasOwnProperty(obj, prop) { |
|
return Object.prototype.hasOwnProperty.call(obj, prop); |
|
} |
|
|
|
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) |
|
},{"./support/isBuffer":5,"_process":4,"inherits":3}],7:[function(require,module,exports){ |
|
var parse = require('xml-parser'); |
|
var render = require('xml-render'); |
|
var fmt = require('util').format; |
|
var h = require('hyperscript'); |
|
var inherits = require('util').inherits; |
|
var EventEmitter = require('events').EventEmitter; |
|
|
|
module.exports = Viewer; |
|
inherits(Viewer, EventEmitter); |
|
|
|
function Viewer(xml){ |
|
EventEmitter.call(this); |
|
if (typeof xml != 'string') xml = xml.toString(); |
|
var obj = parse(xml); |
|
this._el = this._renderRoot(obj); |
|
this._selection = null; |
|
} |
|
|
|
Viewer.prototype.appendTo = function(el){ |
|
var self = this; |
|
el.appendChild(this._el); |
|
el.addEventListener('click', function(ev){ |
|
if (ev.target == el) self._setSelection(null); |
|
}); |
|
}; |
|
|
|
Viewer.prototype._setSelection = function(node){ |
|
if (this._selection === node) return; |
|
|
|
if (this._selection) this._selection.el.classList.remove('selected'); |
|
if (node) node.el.classList.add('selected'); |
|
|
|
this._selection = node; |
|
this.emit('select', this._selection); |
|
}; |
|
|
|
Viewer.prototype.getSelection = function(){ |
|
return this._selection; |
|
}; |
|
|
|
Viewer.prototype._renderRoot = function(node){ |
|
var self = this; |
|
|
|
node.text = function(){ |
|
return render.node(node); |
|
}; |
|
|
|
var el = h('span', |
|
{ onclick: this._handleClick(node) }, |
|
spaces(2), |
|
render.declaration(node.declaration), |
|
this._renderNode(node.root) |
|
); |
|
node.el = el; |
|
|
|
return el; |
|
}; |
|
|
|
Viewer.prototype._renderNode = function(node, indent){ |
|
var self = this; |
|
var folded = false; |
|
indent = indent || 0; |
|
|
|
if (!node.children || !node.children.length) return this._renderLeaf(node, indent); |
|
|
|
function ontoggle(ev){ |
|
ev.stopPropagation(); |
|
if (folded) { |
|
ev.target.innerHTML = '-'; |
|
node.children.forEach(function(child){ |
|
child.el.style.display = 'inline'; |
|
}); |
|
} else { |
|
ev.target.innerHTML = '+'; |
|
node.children.forEach(function(child){ |
|
child.el.style.display = 'none'; |
|
}); |
|
} |
|
folded = !folded; |
|
} |
|
|
|
node.text = function(){ |
|
return render.node(node); |
|
}; |
|
|
|
var el = h('span', |
|
{ onclick: this._handleClick(node) }, |
|
h('br'), |
|
tabs(indent), |
|
h('span', { onclick: ontoggle }, '-'), |
|
spaces(1), |
|
render.tagOpen(node), |
|
node.children.map(function(child){ |
|
return self._renderNode(child, indent + 1); |
|
}), |
|
h('br'), |
|
tabs(indent), |
|
spaces(2), |
|
render.tagClose(node) |
|
); |
|
node.el = el; |
|
|
|
return el; |
|
} |
|
|
|
Viewer.prototype._renderLeaf = function(node, indent){ |
|
var self = this; |
|
|
|
node.text = function(){ |
|
return render.node(node); |
|
}; |
|
|
|
var el = h('span', |
|
{ onclick: this._handleClick(node) }, |
|
h('br'), |
|
tabs(indent), |
|
spaces(2), |
|
node.text() |
|
); |
|
node.el = el; |
|
|
|
return el; |
|
} |
|
|
|
Viewer.prototype._handleClick = function(node){ |
|
var self = this; |
|
return function(ev){ |
|
ev.stopPropagation(); |
|
self._setSelection(node); |
|
}; |
|
}; |
|
|
|
function tabs(n){ |
|
var out = []; |
|
for (var i = 0; i < n; i++) out.push(spaces(4)); |
|
return out; |
|
} |
|
|
|
function spaces(n){ |
|
var el = document.createElement('span'); |
|
for (var i = 0; i < n; i++) { |
|
el.innerHTML += ' '; |
|
} |
|
return el; |
|
} |
|
|
|
},{"events":2,"hyperscript":8,"util":6,"xml-parser":12,"xml-render":16}],8:[function(require,module,exports){ |
|
var split = require('browser-split') |
|
var ClassList = require('class-list') |
|
require('html-element') |
|
|
|
function context () { |
|
|
|
var cleanupFuncs = [] |
|
|
|
function h() { |
|
var args = [].slice.call(arguments), e = null |
|
function item (l) { |
|
var r |
|
function parseClass (string) { |
|
// Our minimal parser doesn’t understand escaping CSS special |
|
// characters like `#`. Don’t use them. More reading: |
|
// https://mathiasbynens.be/notes/css-escapes . |
|
|
|
var m = split(string, /([\.#]?[^\s#.]+)/) |
|
if(/^\.|#/.test(m[1])) |
|
e = document.createElement('div') |
|
forEach(m, function (v) { |
|
var s = v.substring(1,v.length) |
|
if(!v) return |
|
if(!e) |
|
e = document.createElement(v) |
|
else if (v[0] === '.') |
|
ClassList(e).add(s) |
|
else if (v[0] === '#') |
|
e.setAttribute('id', s) |
|
}) |
|
} |
|
|
|
if(l == null) |
|
; |
|
else if('string' === typeof l) { |
|
if(!e) |
|
parseClass(l) |
|
else |
|
e.appendChild(r = document.createTextNode(l)) |
|
} |
|
else if('number' === typeof l |
|
|| 'boolean' === typeof l |
|
|| l instanceof Date |
|
|| l instanceof RegExp ) { |
|
e.appendChild(r = document.createTextNode(l.toString())) |
|
} |
|
//there might be a better way to handle this... |
|
else if (isArray(l)) |
|
forEach(l, item) |
|
else if(isNode(l)) |
|
e.appendChild(r = l) |
|
else if(l instanceof Text) |
|
e.appendChild(r = l) |
|
else if ('object' === typeof l) { |
|
for (var k in l) { |
|
if('function' === typeof l[k]) { |
|
if(/^on\w+/.test(k)) { |
|
(function (k, l) { // capture k, l in the closure |
|
if (e.addEventListener){ |
|
e.addEventListener(k.substring(2), l[k], false) |
|
cleanupFuncs.push(function(){ |
|
e.removeEventListener(k.substring(2), l[k], false) |
|
}) |
|
}else{ |
|
e.attachEvent(k, l[k]) |
|
cleanupFuncs.push(function(){ |
|
e.detachEvent(k, l[k]) |
|
}) |
|
} |
|
})(k, l) |
|
} else { |
|
// observable |
|
e[k] = l[k]() |
|
cleanupFuncs.push(l[k](function (v) { |
|
e[k] = v |
|
})) |
|
} |
|
} |
|
else if(k === 'style') { |
|
if('string' === typeof l[k]) { |
|
e.style.cssText = l[k] |
|
}else{ |
|
for (var s in l[k]) (function(s, v) { |
|
if('function' === typeof v) { |
|
// observable |
|
e.style.setProperty(s, v()) |
|
cleanupFuncs.push(v(function (val) { |
|
e.style.setProperty(s, val) |
|
})) |
|
} else |
|
e.style.setProperty(s, l[k][s]) |
|
})(s, l[k][s]) |
|
} |
|
} else if (k.substr(0, 5) === "data-") { |
|
e.setAttribute(k, l[k]) |
|
} else { |
|
e[k] = l[k] |
|
} |
|
} |
|
} else if ('function' === typeof l) { |
|
//assume it's an observable! |
|
var v = l() |
|
e.appendChild(r = isNode(v) ? v : document.createTextNode(v)) |
|
|
|
cleanupFuncs.push(l(function (v) { |
|
if(isNode(v) && r.parentElement) |
|
r.parentElement.replaceChild(v, r), r = v |
|
else |
|
r.textContent = v |
|
})) |
|
} |
|
|
|
return r |
|
} |
|
while(args.length) |
|
item(args.shift()) |
|
|
|
return e |
|
} |
|
|
|
h.cleanup = function () { |
|
for (var i = 0; i < cleanupFuncs.length; i++){ |
|
cleanupFuncs[i]() |
|
} |
|
cleanupFuncs.length = 0 |
|
} |
|
|
|
return h |
|
} |
|
|
|
var h = module.exports = context() |
|
h.context = context |
|
|
|
function isNode (el) { |
|
return el && el.nodeName && el.nodeType |
|
} |
|
|
|
function isText (el) { |
|
return el && el.nodeName === '#text' && el.nodeType == 3 |
|
} |
|
|
|
function forEach (arr, fn) { |
|
if (arr.forEach) return arr.forEach(fn) |
|
for (var i = 0; i < arr.length; i++) fn(arr[i], i) |
|
} |
|
|
|
function isArray (arr) { |
|
return Object.prototype.toString.call(arr) == '[object Array]' |
|
} |
|
|
|
},{"browser-split":9,"class-list":10,"html-element":1}],9:[function(require,module,exports){ |
|
/*! |
|
* Cross-Browser Split 1.1.1 |
|
* Copyright 2007-2012 Steven Levithan <stevenlevithan.com> |
|
* Available under the MIT License |
|
* ECMAScript compliant, uniform cross-browser split method |
|
*/ |
|
|
|
/** |
|
* Splits a string into an array of strings using a regex or string separator. Matches of the |
|
* separator are not included in the result array. However, if `separator` is a regex that contains |
|
* capturing groups, backreferences are spliced into the result each time `separator` is matched. |
|
* Fixes browser bugs compared to the native `String.prototype.split` and can be used reliably |
|
* cross-browser. |
|
* @param {String} str String to split. |
|
* @param {RegExp|String} separator Regex or string to use for separating the string. |
|
* @param {Number} [limit] Maximum number of items to include in the result array. |
|
* @returns {Array} Array of substrings. |
|
* @example |
|
* |
|
* // Basic use |
|
* split('a b c d', ' '); |
|
* // -> ['a', 'b', 'c', 'd'] |
|
* |
|
* // With limit |
|
* split('a b c d', ' ', 2); |
|
* // -> ['a', 'b'] |
|
* |
|
* // Backreferences in result array |
|
* split('..word1 word2..', /([a-z]+)(\d+)/i); |
|
* // -> ['..', 'word', '1', ' ', 'word', '2', '..'] |
|
*/ |
|
module.exports = (function split(undef) { |
|
|
|
var nativeSplit = String.prototype.split, |
|
compliantExecNpcg = /()??/.exec("")[1] === undef, |
|
// NPCG: nonparticipating capturing group |
|
self; |
|
|
|
self = function(str, separator, limit) { |
|
// If `separator` is not a regex, use `nativeSplit` |
|
if (Object.prototype.toString.call(separator) !== "[object RegExp]") { |
|
return nativeSplit.call(str, separator, limit); |
|
} |
|
var output = [], |
|
flags = (separator.ignoreCase ? "i" : "") + (separator.multiline ? "m" : "") + (separator.extended ? "x" : "") + // Proposed for ES6 |
|
(separator.sticky ? "y" : ""), |
|
// Firefox 3+ |
|
lastLastIndex = 0, |
|
// Make `global` and avoid `lastIndex` issues by working with a copy |
|
separator = new RegExp(separator.source, flags + "g"), |
|
separator2, match, lastIndex, lastLength; |
|
str += ""; // Type-convert |
|
if (!compliantExecNpcg) { |
|
// Doesn't need flags gy, but they don't hurt |
|
separator2 = new RegExp("^" + separator.source + "$(?!\\s)", flags); |
|
} |
|
/* Values for `limit`, per the spec: |
|
* If undefined: 4294967295 // Math.pow(2, 32) - 1 |
|
* If 0, Infinity, or NaN: 0 |
|
* If positive number: limit = Math.floor(limit); if (limit > 4294967295) limit -= 4294967296; |
|
* If negative number: 4294967296 - Math.floor(Math.abs(limit)) |
|
* If other: Type-convert, then use the above rules |
|
*/ |
|
limit = limit === undef ? -1 >>> 0 : // Math.pow(2, 32) - 1 |
|
limit >>> 0; // ToUint32(limit) |
|
while (match = separator.exec(str)) { |
|
// `separator.lastIndex` is not reliable cross-browser |
|
lastIndex = match.index + match[0].length; |
|
if (lastIndex > lastLastIndex) { |
|
output.push(str.slice(lastLastIndex, match.index)); |
|
// Fix browsers whose `exec` methods don't consistently return `undefined` for |
|
// nonparticipating capturing groups |
|
if (!compliantExecNpcg && match.length > 1) { |
|
match[0].replace(separator2, function() { |
|
for (var i = 1; i < arguments.length - 2; i++) { |
|
if (arguments[i] === undef) { |
|
match[i] = undef; |
|
} |
|
} |
|
}); |
|
} |
|
if (match.length > 1 && match.index < str.length) { |
|
Array.prototype.push.apply(output, match.slice(1)); |
|
} |
|
lastLength = match[0].length; |
|
lastLastIndex = lastIndex; |
|
if (output.length >= limit) { |
|
break; |
|
} |
|
} |
|
if (separator.lastIndex === match.index) { |
|
separator.lastIndex++; // Avoid an infinite loop |
|
} |
|
} |
|
if (lastLastIndex === str.length) { |
|
if (lastLength || !separator.test("")) { |
|
output.push(""); |
|
} |
|
} else { |
|
output.push(str.slice(lastLastIndex)); |
|
} |
|
return output.length > limit ? output.slice(0, limit) : output; |
|
}; |
|
|
|
return self; |
|
})(); |
|
|
|
},{}],10:[function(require,module,exports){ |
|
// contains, add, remove, toggle |
|
var indexof = require('indexof') |
|
|
|
module.exports = ClassList |
|
|
|
function ClassList(elem) { |
|
var cl = elem.classList |
|
|
|
if (cl) { |
|
return cl |
|
} |
|
|
|
var classList = { |
|
add: add |
|
, remove: remove |
|
, contains: contains |
|
, toggle: toggle |
|
, toString: $toString |
|
, length: 0 |
|
, item: item |
|
} |
|
|
|
return classList |
|
|
|
function add(token) { |
|
var list = getTokens() |
|
if (indexof(list, token) > -1) { |
|
return |
|
} |
|
list.push(token) |
|
setTokens(list) |
|
} |
|
|
|
function remove(token) { |
|
var list = getTokens() |
|
, index = indexof(list, token) |
|
|
|
if (index === -1) { |
|
return |
|
} |
|
|
|
list.splice(index, 1) |
|
setTokens(list) |
|
} |
|
|
|
function contains(token) { |
|
return indexof(getTokens(), token) > -1 |
|
} |
|
|
|
function toggle(token) { |
|
if (contains(token)) { |
|
remove(token) |
|
return false |
|
} else { |
|
add(token) |
|
return true |
|
} |
|
} |
|
|
|
function $toString() { |
|
return elem.className |
|
} |
|
|
|
function item(index) { |
|
var tokens = getTokens() |
|
return tokens[index] || null |
|
} |
|
|
|
function getTokens() { |
|
var className = elem.className |
|
|
|
return filter(className.split(" "), isTruthy) |
|
} |
|
|
|
function setTokens(list) { |
|
var length = list.length |
|
|
|
elem.className = list.join(" ") |
|
classList.length = length |
|
|
|
for (var i = 0; i < list.length; i++) { |
|
classList[i] = list[i] |
|
} |
|
|
|
delete list[length] |
|
} |
|
} |
|
|
|
function filter (arr, fn) { |
|
var ret = [] |
|
for (var i = 0; i < arr.length; i++) { |
|
if (fn(arr[i])) ret.push(arr[i]) |
|
} |
|
return ret |
|
} |
|
|
|
function isTruthy(value) { |
|
return !!value |
|
} |
|
|
|
},{"indexof":11}],11:[function(require,module,exports){ |
|
|
|
var indexOf = [].indexOf; |
|
|
|
module.exports = function(arr, obj){ |
|
if (indexOf) return arr.indexOf(obj); |
|
for (var i = 0; i < arr.length; ++i) { |
|
if (arr[i] === obj) return i; |
|
} |
|
return -1; |
|
}; |
|
},{}],12:[function(require,module,exports){ |
|
|
|
/** |
|
* Module dependencies. |
|
*/ |
|
|
|
var debug = require('debug')('xml-parser'); |
|
|
|
/** |
|
* Expose `parse`. |
|
*/ |
|
|
|
module.exports = parse; |
|
|
|
/** |
|
* Parse the given string of `xml`. |
|
* |
|
* @param {String} xml |
|
* @return {Object} |
|
* @api public |
|
*/ |
|
|
|
function parse(xml) { |
|
xml = xml.trim(); |
|
|
|
// strip comments |
|
xml = xml.replace(/<!--[\s\S]*?-->/g, ''); |
|
|
|
return document(); |
|
|
|
/** |
|
* XML document. |
|
*/ |
|
|
|
function document() { |
|
return { |
|
declaration: declaration(), |
|
root: tag() |
|
} |
|
} |
|
|
|
/** |
|
* Declaration. |
|
*/ |
|
|
|
function declaration() { |
|
var m = match(/^<\?xml\s*/); |
|
if (!m) return; |
|
|
|
// tag |
|
var node = { |
|
attributes: {} |
|
}; |
|
|
|
// attributes |
|
while (!(eos() || is('?>'))) { |
|
var attr = attribute(); |
|
if (!attr) return node; |
|
node.attributes[attr.name] = attr.value; |
|
} |
|
|
|
match(/\?>\s*/); |
|
|
|
return node; |
|
} |
|
|
|
/** |
|
* Tag. |
|
*/ |
|
|
|
function tag() { |
|
debug('tag %j', xml); |
|
var m = match(/^<([\w-:.]+)\s*/); |
|
if (!m) return; |
|
|
|
// name |
|
var node = { |
|
name: m[1], |
|
attributes: {}, |
|
children: [] |
|
}; |
|
|
|
// attributes |
|
while (!(eos() || is('>') || is('?>') || is('/>'))) { |
|
var attr = attribute(); |
|
if (!attr) return node; |
|
node.attributes[attr.name] = attr.value; |
|
} |
|
|
|
// self closing tag |
|
if (match(/^\s*\/>\s*/)) { |
|
return node; |
|
} |
|
|
|
match(/\??>\s*/); |
|
|
|
// content |
|
node.content = content(); |
|
|
|
// children |
|
var child; |
|
while (child = tag()) { |
|
node.children.push(child); |
|
} |
|
|
|
// closing |
|
match(/^<\/[\w-:.]+>\s*/); |
|
|
|
return node; |
|
} |
|
|
|
/** |
|
* Text content. |
|
*/ |
|
|
|
function content() { |
|
debug('content %j', xml); |
|
var m = match(/^([^<]*)/); |
|
if (m) return m[1]; |
|
return ''; |
|
} |
|
|
|
/** |
|
* Attribute. |
|
*/ |
|
|
|
function attribute() { |
|
debug('attribute %j', xml); |
|
var m = match(/([\w:-]+)\s*=\s*("[^"]*"|'[^']*'|\w+)\s*/); |
|
if (!m) return; |
|
return { name: m[1], value: strip(m[2]) } |
|
} |
|
|
|
/** |
|
* Strip quotes from `val`. |
|
*/ |
|
|
|
function strip(val) { |
|
return val.replace(/^['"]|['"]$/g, ''); |
|
} |
|
|
|
/** |
|
* Match `re` and advance the string. |
|
*/ |
|
|
|
function match(re) { |
|
var m = xml.match(re); |
|
if (!m) return; |
|
xml = xml.slice(m[0].length); |
|
return m; |
|
} |
|
|
|
/** |
|
* End-of-source. |
|
*/ |
|
|
|
function eos() { |
|
return 0 == xml.length; |
|
} |
|
|
|
/** |
|
* Check for `prefix`. |
|
*/ |
|
|
|
function is(prefix) { |
|
return 0 == xml.indexOf(prefix); |
|
} |
|
} |
|
|
|
},{"debug":13}],13:[function(require,module,exports){ |
|
|
|
/** |
|
* This is the web browser implementation of `debug()`. |
|
* |
|
* Expose `debug()` as the module. |
|
*/ |
|
|
|
exports = module.exports = require('./debug'); |
|
exports.log = log; |
|
exports.formatArgs = formatArgs; |
|
exports.save = save; |
|
exports.load = load; |
|
exports.useColors = useColors; |
|
exports.storage = 'undefined' != typeof chrome |
|
&& 'undefined' != typeof chrome.storage |
|
? chrome.storage.local |
|
: localstorage(); |
|
|
|
/** |
|
* Colors. |
|
*/ |
|
|
|
exports.colors = [ |
|
'lightseagreen', |
|
'forestgreen', |
|
'goldenrod', |
|
'dodgerblue', |
|
'darkorchid', |
|
'crimson' |
|
]; |
|
|
|
/** |
|
* Currently only WebKit-based Web Inspectors, Firefox >= v31, |
|
* and the Firebug extension (any Firefox version) are known |
|
* to support "%c" CSS customizations. |
|
* |
|
* TODO: add a `localStorage` variable to explicitly enable/disable colors |
|
*/ |
|
|
|
function useColors() { |
|
// is webkit? http://stackoverflow.com/a/16459606/376773 |
|
return ('WebkitAppearance' in document.documentElement.style) || |
|
// is firebug? http://stackoverflow.com/a/398120/376773 |
|
(window.console && (console.firebug || (console.exception && console.table))) || |
|
// is firefox >= v31? |
|
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages |
|
(navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31); |
|
} |
|
|
|
/** |
|
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. |
|
*/ |
|
|
|
exports.formatters.j = function(v) { |
|
return JSON.stringify(v); |
|
}; |
|
|
|
|
|
/** |
|
* Colorize log arguments if enabled. |
|
* |
|
* @api public |
|
*/ |
|
|
|
function formatArgs() { |
|
var args = arguments; |
|
var useColors = this.useColors; |
|
|
|
args[0] = (useColors ? '%c' : '') |
|
+ this.namespace |
|
+ (useColors ? ' %c' : ' ') |
|
+ args[0] |
|
+ (useColors ? '%c ' : ' ') |
|
+ '+' + exports.humanize(this.diff); |
|
|
|
if (!useColors) return args; |
|
|
|
var c = 'color: ' + this.color; |
|
args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1)); |
|
|
|
// the final "%c" is somewhat tricky, because there could be other |
|
// arguments passed either before or after the %c, so we need to |
|
// figure out the correct index to insert the CSS into |
|
var index = 0; |
|
var lastC = 0; |
|
args[0].replace(/%[a-z%]/g, function(match) { |
|
if ('%%' === match) return; |
|
index++; |
|
if ('%c' === match) { |
|
// we only are interested in the *last* %c |
|
// (the user may have provided their own) |
|
lastC = index; |
|
} |
|
}); |
|
|
|
args.splice(lastC, 0, c); |
|
return args; |
|
} |
|
|
|
/** |
|
* Invokes `console.log()` when available. |
|
* No-op when `console.log` is not a "function". |
|
* |
|
* @api public |
|
*/ |
|
|
|
function log() { |
|
// this hackery is required for IE8/9, where |
|
// the `console.log` function doesn't have 'apply' |
|
return 'object' === typeof console |
|
&& console.log |
|
&& Function.prototype.apply.call(console.log, console, arguments); |
|
} |
|
|
|
/** |
|
* Save `namespaces`. |
|
* |
|
* @param {String} namespaces |
|
* @api private |
|
*/ |
|
|
|
function save(namespaces) { |
|
try { |
|
if (null == namespaces) { |
|
exports.storage.removeItem('debug'); |
|
} else { |
|
exports.storage.debug = namespaces; |
|
} |
|
} catch(e) {} |
|
} |
|
|
|
/** |
|
* Load `namespaces`. |
|
* |
|
* @return {String} returns the previously persisted debug modes |
|
* @api private |
|
*/ |
|
|
|
function load() { |
|
var r; |
|
try { |
|
r = exports.storage.debug; |
|
} catch(e) {} |
|
return r; |
|
} |
|
|
|
/** |
|
* Enable namespaces listed in `localStorage.debug` initially. |
|
*/ |
|
|
|
exports.enable(load()); |
|
|
|
/** |
|
* Localstorage attempts to return the localstorage. |
|
* |
|
* This is necessary because safari throws |
|
* when a user disables cookies/localstorage |
|
* and you attempt to access it. |
|
* |
|
* @return {LocalStorage} |
|
* @api private |
|
*/ |
|
|
|
function localstorage(){ |
|
try { |
|
return window.localStorage; |
|
} catch (e) {} |
|
} |
|
|
|
},{"./debug":14}],14:[function(require,module,exports){ |
|
|
|
/** |
|
* This is the common logic for both the Node.js and web browser |
|
* implementations of `debug()`. |
|
* |
|
* Expose `debug()` as the module. |
|
*/ |
|
|
|
exports = module.exports = debug; |
|
exports.coerce = coerce; |
|
exports.disable = disable; |
|
exports.enable = enable; |
|
exports.enabled = enabled; |
|
exports.humanize = require('ms'); |
|
|
|
/** |
|
* The currently active debug mode names, and names to skip. |
|
*/ |
|
|
|
exports.names = []; |
|
exports.skips = []; |
|
|
|
/** |
|
* Map of special "%n" handling functions, for the debug "format" argument. |
|
* |
|
* Valid key names are a single, lowercased letter, i.e. "n". |
|
*/ |
|
|
|
exports.formatters = {}; |
|
|
|
/** |
|
* Previously assigned color. |
|
*/ |
|
|
|
var prevColor = 0; |
|
|
|
/** |
|
* Previous log timestamp. |
|
*/ |
|
|
|
var prevTime; |
|
|
|
/** |
|
* Select a color. |
|
* |
|
* @return {Number} |
|
* @api private |
|
*/ |
|
|
|
function selectColor() { |
|
return exports.colors[prevColor++ % exports.colors.length]; |
|
} |
|
|
|
/** |
|
* Create a debugger with the given `namespace`. |
|
* |
|
* @param {String} namespace |
|
* @return {Function} |
|
* @api public |
|
*/ |
|
|
|
function debug(namespace) { |
|
|
|
// define the `disabled` version |
|
function disabled() { |
|
} |
|
disabled.enabled = false; |
|
|
|
// define the `enabled` version |
|
function enabled() { |
|
|
|
var self = enabled; |
|
|
|
// set `diff` timestamp |
|
var curr = +new Date(); |
|
var ms = curr - (prevTime || curr); |
|
self.diff = ms; |
|
self.prev = prevTime; |
|
self.curr = curr; |
|
prevTime = curr; |
|
|
|
// add the `color` if not set |
|
if (null == self.useColors) self.useColors = exports.useColors(); |
|
if (null == self.color && self.useColors) self.color = selectColor(); |
|
|
|
var args = Array.prototype.slice.call(arguments); |
|
|
|
args[0] = exports.coerce(args[0]); |
|
|
|
if ('string' !== typeof args[0]) { |
|
// anything else let's inspect with %o |
|
args = ['%o'].concat(args); |
|
} |
|
|
|
// apply any `formatters` transformations |
|
var index = 0; |
|
args[0] = args[0].replace(/%([a-z%])/g, function(match, format) { |
|
// if we encounter an escaped % then don't increase the array index |
|
if (match === '%%') return match; |
|
index++; |
|
var formatter = exports.formatters[format]; |
|
if ('function' === typeof formatter) { |
|
var val = args[index]; |
|
match = formatter.call(self, val); |
|
|
|
// now we need to remove `args[index]` since it's inlined in the `format` |
|
args.splice(index, 1); |
|
index--; |
|
} |
|
return match; |
|
}); |
|
|
|
if ('function' === typeof exports.formatArgs) { |
|
args = exports.formatArgs.apply(self, args); |
|
} |
|
var logFn = enabled.log || exports.log || console.log.bind(console); |
|
logFn.apply(self, args); |
|
} |
|
enabled.enabled = true; |
|
|
|
var fn = exports.enabled(namespace) ? enabled : disabled; |
|
|
|
fn.namespace = namespace; |
|
|
|
return fn; |
|
} |
|
|
|
/** |
|
* Enables a debug mode by namespaces. This can include modes |
|
* separated by a colon and wildcards. |
|
* |
|
* @param {String} namespaces |
|
* @api public |
|
*/ |
|
|
|
function enable(namespaces) { |
|
exports.save(namespaces); |
|
|
|
var split = (namespaces || '').split(/[\s,]+/); |
|
var len = split.length; |
|
|
|
for (var i = 0; i < len; i++) { |
|
if (!split[i]) continue; // ignore empty strings |
|
namespaces = split[i].replace(/\*/g, '.*?'); |
|
if (namespaces[0] === '-') { |
|
exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); |
|
} else { |
|
exports.names.push(new RegExp('^' + namespaces + '$')); |
|
} |
|
} |
|
} |
|
|
|
/** |
|
* Disable debug output. |
|
* |
|
* @api public |
|
*/ |
|
|
|
function disable() { |
|
exports.enable(''); |
|
} |
|
|
|
/** |
|
* Returns true if the given mode name is enabled, false otherwise. |
|
* |
|
* @param {String} name |
|
* @return {Boolean} |
|
* @api public |
|
*/ |
|
|
|
function enabled(name) { |
|
var i, len; |
|
for (i = 0, len = exports.skips.length; i < len; i++) { |
|
if (exports.skips[i].test(name)) { |
|
return false; |
|
} |
|
} |
|
for (i = 0, len = exports.names.length; i < len; i++) { |
|
if (exports.names[i].test(name)) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
/** |
|
* Coerce `val`. |
|
* |
|
* @param {Mixed} val |
|
* @return {Mixed} |
|
* @api private |
|
*/ |
|
|
|
function coerce(val) { |
|
if (val instanceof Error) return val.stack || val.message; |
|
return val; |
|
} |
|
|
|
},{"ms":15}],15:[function(require,module,exports){ |
|
/** |
|
* 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 |
|
? long(val) |
|
: short(val); |
|
}; |
|
|
|
/** |
|
* Parse the given `str` and return milliseconds. |
|
* |
|
* @param {String} str |
|
* @return {Number} |
|
* @api private |
|
*/ |
|
|
|
function parse(str) { |
|
str = '' + str; |
|
if (str.length > 10000) return; |
|
var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|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 'yrs': |
|
case 'yr': |
|
case 'y': |
|
return n * y; |
|
case 'days': |
|
case 'day': |
|
case 'd': |
|
return n * d; |
|
case 'hours': |
|
case 'hour': |
|
case 'hrs': |
|
case 'hr': |
|
case 'h': |
|
return n * h; |
|
case 'minutes': |
|
case 'minute': |
|
case 'mins': |
|
case 'min': |
|
case 'm': |
|
return n * m; |
|
case 'seconds': |
|
case 'second': |
|
case 'secs': |
|
case 'sec': |
|
case 's': |
|
return n * s; |
|
case 'milliseconds': |
|
case 'millisecond': |
|
case 'msecs': |
|
case 'msec': |
|
case 'ms': |
|
return n; |
|
} |
|
} |
|
|
|
/** |
|
* Short format for `ms`. |
|
* |
|
* @param {Number} ms |
|
* @return {String} |
|
* @api private |
|
*/ |
|
|
|
function short(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 long(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'; |
|
} |
|
|
|
},{}],16:[function(require,module,exports){ |
|
var fmt = require('util').format; |
|
|
|
exports.tagOpen = function(node){ |
|
return fmt('<%s%s>', node.name, renderAttributes(node)); |
|
}; |
|
|
|
exports.declaration = function(node){ |
|
return fmt('<?xml%s?>', renderAttributes(node)); |
|
}; |
|
|
|
function renderAttributes(node){ |
|
var attr = exports.attributes(node); |
|
return attr.length ? ' ' + attr : ''; |
|
}; |
|
|
|
exports.attributes = function(node){ |
|
if (!node.attributes) return ''; |
|
var keys = Object.keys(node.attributes); |
|
if (!keys.length) return ''; |
|
return keys.map(function(key){ |
|
return fmt('%s="%s"', key, node.attributes[key]); |
|
}).join(' '); |
|
}; |
|
|
|
exports.tagClose = function(node){ |
|
return fmt('</%s>', node.name); |
|
}; |
|
|
|
exports.leaf = function(node){ |
|
return exports.tagOpen(node) + node.content + exports.tagClose(node); |
|
}; |
|
|
|
exports.node = function(node){ |
|
if (node.root) return exports.document(node); |
|
if (!node.children || !node.children.length) return exports.leaf(node); |
|
|
|
return exports.tagOpen(node) + '\n' |
|
+ node.children.map(function(child){ |
|
return exports.node(child).replace(/^/gm, '\t'); |
|
}).join('\n') + '\n' |
|
+ exports.tagClose(node); |
|
}; |
|
|
|
exports.document = function(node){ |
|
return exports.declaration(node.declaration) + '\n' |
|
+ exports.node(node.root); |
|
}; |
|
|
|
|
|
},{"util":6}]},{},[7])(7) |
|
}); |