kola
8 months ago
365 changed files with 12038 additions and 2 deletions
@ -0,0 +1,244 @@
@@ -0,0 +1,244 @@
|
||||
var Class = require('./Class'); |
||||
var defaults = require('./defaults'); |
||||
var Promise = require('./Promise'); |
||||
var perfNow = require('./perfNow'); |
||||
var delay = require('./delay'); |
||||
var average = require('./average'); |
||||
var reduce = require('./reduce'); |
||||
var each = require('./each'); |
||||
var map = require('./map'); |
||||
var table = require('./table'); |
||||
var toStr = require('./toStr'); |
||||
exports = Class( |
||||
{ |
||||
initialize: function Benchmark(fn) { |
||||
var options = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: {}; |
||||
defaults(options, defOpts); |
||||
this._fn = fn; |
||||
this._isRunning = false; |
||||
this._options = options; |
||||
}, |
||||
run: function() { |
||||
var _this = this; |
||||
if (this._isRunning) { |
||||
return this._pendingPromise; |
||||
} |
||||
this._reset(); |
||||
this._isRunning = true; |
||||
var options = this._options; |
||||
var pendingPromise = new Promise(function(resolve, reject) { |
||||
var runSample = function() { |
||||
var initCount = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: 1; |
||||
delay(function() { |
||||
_this |
||||
._runSample(initCount) |
||||
.then(function(_ref) { |
||||
var period = _ref.period, |
||||
count = _ref.count; |
||||
var sample = _this._sample; |
||||
sample.push(period); |
||||
if ( |
||||
perfNow() - _this._timeStamp < |
||||
options.maxTime || |
||||
sample.length < options.minSamples |
||||
) { |
||||
runSample(count); |
||||
} else { |
||||
resolve(_this._calcResult()); |
||||
} |
||||
}) |
||||
.catch(function(err) { |
||||
reject(err); |
||||
}); |
||||
}, options.delay); |
||||
}; |
||||
runSample(); |
||||
}); |
||||
function complete() { |
||||
this._isRunning = false; |
||||
delete this._pendingPromise; |
||||
} |
||||
pendingPromise.then(complete).catch(complete); |
||||
this._pendingPromise = pendingPromise; |
||||
return pendingPromise; |
||||
}, |
||||
_reset: function() { |
||||
this._timeStamp = perfNow(); |
||||
this._sample = []; |
||||
}, |
||||
_calcResult: function() { |
||||
var sample = this._sample; |
||||
var result = { |
||||
sample: sample, |
||||
toString: function() { |
||||
var hz = this.hz, |
||||
rme = this.rme, |
||||
name = this.name; |
||||
var size = this.sample.length; |
||||
return '' |
||||
.concat(name, ' x ') |
||||
.concat( |
||||
formatNumber(hz.toFixed(hz < 100 ? 2 : 0)), |
||||
' ops/sec \xB1' |
||||
) |
||||
.concat(rme.toFixed(2), '% (') |
||||
.concat(size, ' run') |
||||
.concat(size === 1 ? '' : 's', ' sampled)'); |
||||
} |
||||
}; |
||||
var size = sample.length; |
||||
result.name = this._options.name || this._fn.name || 'anonymous'; |
||||
result.mean = average.apply(null, sample); |
||||
function varOf(sum, x) { |
||||
return sum + Math.pow(x - result.mean, 2); |
||||
} |
||||
result.variance = reduce(sample, varOf, 0) / (size - 1) || 0; |
||||
result.deviation = Math.sqrt(result.variance); |
||||
result.sem = result.deviation / Math.sqrt(size); |
||||
var critical = tTable[Math.round(size - 1) || 1] || tTable.infinity; |
||||
result.moe = result.sem * critical; |
||||
result.rme = (result.moe / result.mean) * 100 || 0; |
||||
result.hz = 1000 / result.mean; |
||||
return result; |
||||
}, |
||||
_runSample: function(count) { |
||||
var _this2 = this; |
||||
var options = this._options; |
||||
var minTime = options.minTime; |
||||
return new Promise(function(resolve, reject) { |
||||
var runCycle = function(count) { |
||||
delay(function() { |
||||
var elapsed = 0; |
||||
try { |
||||
elapsed = _this2._runCycle(count); |
||||
} catch (e) { |
||||
return reject(e); |
||||
} |
||||
var period = elapsed / count; |
||||
if (elapsed < minTime) { |
||||
if (elapsed === 0) { |
||||
count *= 100; |
||||
} else { |
||||
count += Math.ceil( |
||||
(minTime - elapsed) / period |
||||
); |
||||
} |
||||
runCycle(count); |
||||
} else { |
||||
resolve({ |
||||
count: count, |
||||
period: period |
||||
}); |
||||
} |
||||
}, options.delay); |
||||
}; |
||||
runCycle(count); |
||||
}); |
||||
}, |
||||
_runCycle: function(count) { |
||||
var fn = this._fn; |
||||
var now = perfNow(); |
||||
while (count--) { |
||||
fn(); |
||||
} |
||||
return perfNow() - now; |
||||
} |
||||
}, |
||||
{ |
||||
all: function(benches, options) { |
||||
var promises = []; |
||||
each(benches, function(bench) { |
||||
if (!(bench instanceof exports)) { |
||||
bench = new exports(bench, options); |
||||
} |
||||
promises.push(bench.run()); |
||||
}); |
||||
return Promise.all(promises).then(function(results) { |
||||
results.toString = function() { |
||||
var data = map(results, function(_ref2, idx) { |
||||
var name = _ref2.name, |
||||
sample = _ref2.sample, |
||||
hz = _ref2.hz, |
||||
rme = _ref2.rme; |
||||
var columns = []; |
||||
var size = sample.length; |
||||
columns.push( |
||||
toStr(idx + 1), |
||||
name || 'anonymous', |
||||
formatNumber(hz.toFixed(hz < 100 ? 2 : 0)), |
||||
'\xB1'.concat(rme.toFixed(2), '%'), |
||||
'' |
||||
.concat(size, ' run') |
||||
.concat(size === 1 ? '' : 's') |
||||
); |
||||
return columns; |
||||
}); |
||||
data.unshift([ |
||||
'index', |
||||
'name', |
||||
'ops/sec', |
||||
'rme', |
||||
'sampled' |
||||
]); |
||||
return table(data); |
||||
}; |
||||
return results; |
||||
}); |
||||
} |
||||
} |
||||
); |
||||
var defOpts = { |
||||
minTime: 50, |
||||
maxTime: 5000, |
||||
minSamples: 5, |
||||
delay: 5, |
||||
name: '' |
||||
}; |
||||
var tTable = { |
||||
'1': 12.706, |
||||
'2': 4.303, |
||||
'3': 3.182, |
||||
'4': 2.776, |
||||
'5': 2.571, |
||||
'6': 2.447, |
||||
'7': 2.365, |
||||
'8': 2.306, |
||||
'9': 2.262, |
||||
'10': 2.228, |
||||
'11': 2.201, |
||||
'12': 2.179, |
||||
'13': 2.16, |
||||
'14': 2.145, |
||||
'15': 2.131, |
||||
'16': 2.12, |
||||
'17': 2.11, |
||||
'18': 2.101, |
||||
'19': 2.093, |
||||
'20': 2.086, |
||||
'21': 2.08, |
||||
'22': 2.074, |
||||
'23': 2.069, |
||||
'24': 2.064, |
||||
'25': 2.06, |
||||
'26': 2.056, |
||||
'27': 2.052, |
||||
'28': 2.048, |
||||
'29': 2.045, |
||||
'30': 2.042, |
||||
infinity: 1.96 |
||||
}; |
||||
function formatNumber(number) { |
||||
number = String(number).split('.'); |
||||
return ( |
||||
number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') + |
||||
(number[1] ? '.' + number[1] : '') |
||||
); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,46 @@
@@ -0,0 +1,46 @@
|
||||
var Class = require('./Class'); |
||||
var fill = require('./fill'); |
||||
var fnv1a = require('./fnv1a'); |
||||
var strHash = require('./strHash'); |
||||
var each = require('./each'); |
||||
var some = require('./some'); |
||||
exports = Class({ |
||||
initialize: function() { |
||||
var size = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: 1024; |
||||
var k = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: 3; |
||||
this._buckets = fill(new Array(size), 0); |
||||
this._k = k; |
||||
this._size = size; |
||||
}, |
||||
add: function(val) { |
||||
var _this = this; |
||||
each(this._locations(val), function(location) { |
||||
return (_this._buckets[location] = 1); |
||||
}); |
||||
}, |
||||
test: function(val) { |
||||
var _this2 = this; |
||||
return !some(this._locations(val), function(location) { |
||||
return _this2._buckets[location] === 0; |
||||
}); |
||||
}, |
||||
_locations: function(val) { |
||||
var ret = []; |
||||
var size = this._size; |
||||
var a = fnv1a(val); |
||||
var b = strHash(val); |
||||
|
||||
for (var i = 0; i < this._k; i++) { |
||||
ret[i] = (a + b * i) % size; |
||||
} |
||||
return ret; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,35 @@
@@ -0,0 +1,35 @@
|
||||
var Class = require('./Class'); |
||||
var lowerCase = require('./lowerCase'); |
||||
var keys = require('./keys'); |
||||
exports = Class({ |
||||
initialize: function(obj) { |
||||
this._target = obj; |
||||
}, |
||||
set: function(key, val) { |
||||
var name = this.getKey(key); |
||||
if (name) key = name; |
||||
this._target[key] = val; |
||||
}, |
||||
get: function(key) { |
||||
key = this.getKey(key); |
||||
if (key) { |
||||
return this._target[key]; |
||||
} |
||||
}, |
||||
getKey: function(key) { |
||||
var name = lowerCase(key); |
||||
var _keys = keys(this._target); |
||||
for (var i = 0, len = _keys.length; i < len; i++) { |
||||
var _key = _keys[i]; |
||||
if (lowerCase(_key) === name) return _key; |
||||
} |
||||
}, |
||||
remove: function(key) { |
||||
delete this._target[this.getKey(key)]; |
||||
}, |
||||
has: function(key) { |
||||
return !!this.getKey(key); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,48 @@
@@ -0,0 +1,48 @@
|
||||
var Emitter = require('./Emitter'); |
||||
var each = require('./each'); |
||||
var remove = require('./remove'); |
||||
var some = require('./some'); |
||||
exports = Emitter.extend({ |
||||
initialize: function Channel() { |
||||
this._connections = []; |
||||
this.callSuper(Emitter, 'initialize'); |
||||
}, |
||||
send: function(msg) { |
||||
var _this = this; |
||||
each(this._connections, function(connection) { |
||||
connection.emit('message', msg, _this); |
||||
}); |
||||
}, |
||||
connect: function(connection) { |
||||
if (this.isConnected(connection)) { |
||||
return; |
||||
} |
||||
this._connections.push(connection); |
||||
connection.connect(this); |
||||
}, |
||||
disconnect: function(connection) { |
||||
if (!this.isConnected(connection)) { |
||||
return; |
||||
} |
||||
remove(this._connections, function(item) { |
||||
return item === connection; |
||||
}); |
||||
connection.disconnect(this); |
||||
}, |
||||
isConnected: function(connection) { |
||||
if (connection === this) { |
||||
throw new Error('Channel cannot be connected to itself.'); |
||||
} |
||||
return some(this._connections, function(item) { |
||||
return item === connection; |
||||
}); |
||||
}, |
||||
destroy: function() { |
||||
var _this2 = this; |
||||
each(this._connections, function(connection) { |
||||
_this2.disconnect(connection); |
||||
}); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,64 @@
@@ -0,0 +1,64 @@
|
||||
var extend = require('./extend'); |
||||
var toArr = require('./toArr'); |
||||
var inherits = require('./inherits'); |
||||
var safeGet = require('./safeGet'); |
||||
var isMiniProgram = require('./isMiniProgram'); |
||||
exports = function(methods, statics) { |
||||
return Base.extend(methods, statics); |
||||
}; |
||||
function makeClass(parent, methods, statics) { |
||||
statics = statics || {}; |
||||
var className = |
||||
methods.className || safeGet(methods, 'initialize.name') || ''; |
||||
delete methods.className; |
||||
var ctor = function() { |
||||
var args = toArr(arguments); |
||||
return this.initialize |
||||
? this.initialize.apply(this, args) || this |
||||
: this; |
||||
}; |
||||
if (!isMiniProgram) { |
||||
try { |
||||
ctor = new Function( |
||||
'toArr', |
||||
'return function ' + |
||||
className + |
||||
'()' + |
||||
'{' + |
||||
'var args = toArr(arguments);' + |
||||
'return this.initialize ? this.initialize.apply(this, args) || this : this;' + |
||||
'};' |
||||
)(toArr); |
||||
} catch (e) {} |
||||
} |
||||
inherits(ctor, parent); |
||||
ctor.prototype.constructor = ctor; |
||||
ctor.extend = function(methods, statics) { |
||||
return makeClass(ctor, methods, statics); |
||||
}; |
||||
ctor.inherits = function(Class) { |
||||
inherits(ctor, Class); |
||||
}; |
||||
ctor.methods = function(methods) { |
||||
extend(ctor.prototype, methods); |
||||
return ctor; |
||||
}; |
||||
ctor.statics = function(statics) { |
||||
extend(ctor, statics); |
||||
return ctor; |
||||
}; |
||||
ctor.methods(methods).statics(statics); |
||||
return ctor; |
||||
} |
||||
var Base = (exports.Base = makeClass(Object, { |
||||
className: 'Base', |
||||
callSuper: function(parent, name, args) { |
||||
var superMethod = parent.prototype[name]; |
||||
return superMethod.apply(this, args); |
||||
}, |
||||
toString: function() { |
||||
return this.constructor.name; |
||||
} |
||||
})); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,95 @@
@@ -0,0 +1,95 @@
|
||||
var Class = require('./Class'); |
||||
var isStr = require('./isStr'); |
||||
var clamp = require('./clamp'); |
||||
var rgbToHsl = require('./rgbToHsl'); |
||||
var hslToRgb = require('./hslToRgb'); |
||||
var hex = require('./hex'); |
||||
exports = Class( |
||||
{ |
||||
initialize: function Color(color) { |
||||
if (isStr(color)) color = exports.parse(color); |
||||
this.model = color.model; |
||||
this.val = color.val; |
||||
}, |
||||
toRgb: function() { |
||||
var val = this.val; |
||||
if (this.model === 'hsl') val = hslToRgb(val); |
||||
var prefix = 'rgba'; |
||||
if (val[3] === 1) { |
||||
prefix = 'rgb'; |
||||
val = val.slice(0, 3); |
||||
} |
||||
return prefix + '(' + val.join(', ') + ')'; |
||||
}, |
||||
toHex: function() { |
||||
var val = this.val; |
||||
if (this.model === 'hsl') val = hslToRgb(val); |
||||
var ret = hex.encode(val.slice(0, 3)); |
||||
if (ret[0] === ret[1] && ret[2] === ret[3] && ret[4] === ret[5]) { |
||||
ret = ret[0] + ret[2] + ret[5]; |
||||
} |
||||
return '#' + ret; |
||||
}, |
||||
toHsl: function() { |
||||
var val = this.val; |
||||
if (this.model === 'rgb') val = rgbToHsl(val); |
||||
var prefix = 'hsla'; |
||||
if (val[3] === 1) { |
||||
prefix = 'hsl'; |
||||
val = val.slice(0, 3); |
||||
} |
||||
val[1] = val[1] + '%'; |
||||
val[2] = val[2] + '%'; |
||||
return prefix + '(' + val.join(', ') + ')'; |
||||
} |
||||
}, |
||||
{ |
||||
parse: function(colorStr) { |
||||
var i, match; |
||||
var val = [0, 0, 0, 1], |
||||
model = 'rgb'; |
||||
|
||||
if ((match = colorStr.match(regHexAbbr))) { |
||||
match = match[1]; |
||||
for (i = 0; i < 3; i++) { |
||||
val[i] = parseInt(match[i] + match[i], 16); |
||||
} |
||||
} else if ((match = colorStr.match(regHex))) { |
||||
match = match[1]; |
||||
for (i = 0; i < 3; i++) { |
||||
var i2 = i * 2; |
||||
val[i] = parseInt(match.slice(i2, i2 + 2), 16); |
||||
} |
||||
} else if ((match = colorStr.match(regRgba))) { |
||||
for (i = 0; i < 3; i++) { |
||||
val[i] = parseInt(match[i + 1], 0); |
||||
} |
||||
if (match[4]) val[3] = parseFloat(match[4]); |
||||
} else if ((match = colorStr.match(regRgbaPer))) { |
||||
for (i = 0; i < 3; i++) { |
||||
val[i] = Math.round(parseFloat(match[i + 1]) * 2.55); |
||||
} |
||||
if (match[4]) val[3] = parseFloat(match[4]); |
||||
} else if ((match = colorStr.match(regHsla))) { |
||||
model = 'hsl'; |
||||
val = [ |
||||
((parseFloat(match[1]) % 360) + 360) % 360, |
||||
clamp(parseFloat(match[2]), 0, 100), |
||||
clamp(parseFloat(match[3]), 0, 100), |
||||
clamp(parseFloat(match[4]), 0, 1) |
||||
]; |
||||
} |
||||
return { |
||||
val: val, |
||||
model: model |
||||
}; |
||||
} |
||||
} |
||||
); |
||||
var regHexAbbr = /^#([a-fA-F0-9]{3})$/; |
||||
var regHex = /^#([a-fA-F0-9]{6})$/; |
||||
var regRgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; |
||||
var regRgbaPer = /^rgba?\(\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; |
||||
var regHsla = /^hsla?\(\s*([+-]?\d*[.]?\d+)(?:deg)?\s*,\s*([+-]?[\d.]+)%\s*,\s*([+-]?[\d.]+)%\s*(?:,\s*([+-]?[\d.]+)\s*)?\)$/; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,48 @@
@@ -0,0 +1,48 @@
|
||||
var Class = require('./Class'); |
||||
var safeGet = require('./safeGet'); |
||||
var defineProp = require('./defineProp'); |
||||
var isStr = require('./isStr'); |
||||
exports = Class({ |
||||
initialize: function Delegator(host, target) { |
||||
this._host = host; |
||||
if (isStr(target)) { |
||||
target = safeGet(host, target); |
||||
} |
||||
this._target = target; |
||||
}, |
||||
method: function(name, targetName) { |
||||
var target = this._target; |
||||
var fn = target[targetName || name]; |
||||
this._host[name] = function() { |
||||
return fn.apply(target, arguments); |
||||
}; |
||||
return this; |
||||
}, |
||||
getter: function(name, targetName) { |
||||
var target = this._target; |
||||
targetName = targetName || name; |
||||
defineProp(this._host, name, { |
||||
get: function() { |
||||
return target[targetName]; |
||||
}, |
||||
configurable: true |
||||
}); |
||||
return this; |
||||
}, |
||||
setter: function(name, targetName) { |
||||
var target = this._target; |
||||
targetName = targetName || name; |
||||
defineProp(this._host, name, { |
||||
set: function(val) { |
||||
return (target[targetName] = val); |
||||
}, |
||||
configurable: true |
||||
}); |
||||
return this; |
||||
}, |
||||
access: function(name, targetName) { |
||||
return this.getter(name, targetName).setter(name, targetName); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,55 @@
@@ -0,0 +1,55 @@
|
||||
var Class = require('./Class'); |
||||
var uniqId = require('./uniqId'); |
||||
exports = Class({ |
||||
initialize: function Dispatcher() { |
||||
this._callbacks = {}; |
||||
this._isDispatching = false; |
||||
this._isHandled = {}; |
||||
this._isPending = {}; |
||||
}, |
||||
dispatch: function(payload) { |
||||
this._startDispatching(payload); |
||||
for (var id in this._callbacks) { |
||||
if (this._isPending[id]) continue; |
||||
this._invokeCb(id); |
||||
} |
||||
this._stopDispatching(); |
||||
}, |
||||
register: function(cb) { |
||||
var id = uniqId('ID_'); |
||||
this._callbacks[id] = cb; |
||||
return id; |
||||
}, |
||||
waitFor: function(ids) { |
||||
for (var i = 0, len = ids.length; i < len; i++) { |
||||
var id = ids[i]; |
||||
if (this._isPending[id]) continue; |
||||
this._invokeCb(id); |
||||
} |
||||
}, |
||||
unregister: function(id) { |
||||
delete this._callbacks[id]; |
||||
}, |
||||
isDispatching: function() { |
||||
return this._isDispatching; |
||||
}, |
||||
_startDispatching: function(payload) { |
||||
for (var id in this._callbacks) { |
||||
this._isPending[id] = false; |
||||
this._isHandled[id] = false; |
||||
} |
||||
this._pendingPayload = payload; |
||||
this._isDispatching = true; |
||||
}, |
||||
_stopDispatching: function() { |
||||
delete this._pendingPayload; |
||||
this._isDispatching = false; |
||||
}, |
||||
_invokeCb: function(id) { |
||||
this._isPending[id] = true; |
||||
this._callbacks[id](this._pendingPayload); |
||||
this._isHandled[id] = true; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,65 @@
@@ -0,0 +1,65 @@
|
||||
var Class = require('./Class'); |
||||
var has = require('./has'); |
||||
var each = require('./each'); |
||||
var slice = require('./slice'); |
||||
var once = require('./once'); |
||||
var clone = require('./clone'); |
||||
exports = Class( |
||||
{ |
||||
initialize: function Emitter() { |
||||
this._events = this._events || {}; |
||||
}, |
||||
on: function(event, listener) { |
||||
this._events[event] = this._events[event] || []; |
||||
this._events[event].push(listener); |
||||
return this; |
||||
}, |
||||
off: function(event, listener) { |
||||
var events = this._events; |
||||
if (!has(events, event)) return; |
||||
var idx = events[event].indexOf(listener); |
||||
if (idx > -1) { |
||||
events[event].splice(idx, 1); |
||||
} |
||||
return this; |
||||
}, |
||||
once: function(event, listener) { |
||||
this.on(event, once(listener)); |
||||
return this; |
||||
}, |
||||
emit: function(event) { |
||||
var _this = this; |
||||
if (!has(this._events, event)) return; |
||||
var args = slice(arguments, 1); |
||||
var events = clone(this._events[event]); |
||||
each( |
||||
events, |
||||
function(val) { |
||||
return val.apply(_this, args); |
||||
}, |
||||
this |
||||
); |
||||
return this; |
||||
}, |
||||
removeAllListeners: function(event) { |
||||
if (!event) { |
||||
this._events = {}; |
||||
} else { |
||||
delete this._events[event]; |
||||
} |
||||
return this; |
||||
} |
||||
}, |
||||
{ |
||||
mixin: function(obj) { |
||||
each(['on', 'off', 'once', 'emit', 'removeAllListeners'], function( |
||||
val |
||||
) { |
||||
obj[val] = exports.prototype[val]; |
||||
}); |
||||
obj._events = obj._events || {}; |
||||
} |
||||
} |
||||
); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,31 @@
@@ -0,0 +1,31 @@
|
||||
var Class = require('./Class'); |
||||
var freeze = require('./freeze'); |
||||
var isArr = require('./isArr'); |
||||
var each = require('./each'); |
||||
var keys = require('./keys'); |
||||
exports = Class({ |
||||
initialize: function Enum(map) { |
||||
if (isArr(map)) { |
||||
this.size = map.length; |
||||
each( |
||||
map, |
||||
function(member, val) { |
||||
this[member] = val; |
||||
}, |
||||
this |
||||
); |
||||
} else { |
||||
this.size = keys(map).length; |
||||
each( |
||||
map, |
||||
function(val, member) { |
||||
this[member] = val; |
||||
}, |
||||
this |
||||
); |
||||
} |
||||
freeze(this); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,61 @@
@@ -0,0 +1,61 @@
|
||||
var Class = require('./Class'); |
||||
var LinkedList = require('./LinkedList'); |
||||
var map = require('./map'); |
||||
var strHash = require('./strHash'); |
||||
var has = require('./has'); |
||||
exports = Class({ |
||||
initialize: function HashTable() { |
||||
var size = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: 32; |
||||
this._buckets = map(Array(size), function() { |
||||
return new LinkedList(); |
||||
}); |
||||
this._keys = {}; |
||||
}, |
||||
set: function(key, val) { |
||||
var keyHash = this._hash(key); |
||||
this._keys[key] = keyHash; |
||||
var linkedList = this._buckets[keyHash]; |
||||
var node = linkedList.find(function(val) { |
||||
return val.key === key; |
||||
}); |
||||
if (!node) { |
||||
linkedList.push({ |
||||
key: key, |
||||
value: val |
||||
}); |
||||
} else { |
||||
node.value.value = val; |
||||
} |
||||
}, |
||||
get: function(key) { |
||||
var linkedList = this._buckets[this._hash(key)]; |
||||
var node = linkedList.find(function(val) { |
||||
return val.key === key; |
||||
}); |
||||
if (node) { |
||||
return node.value.value; |
||||
} |
||||
}, |
||||
has: function(key) { |
||||
return has(this._keys, key); |
||||
}, |
||||
delete: function(key) { |
||||
var keyHash = this._hash(key); |
||||
delete this._keys[key]; |
||||
var linkedList = this._buckets[keyHash]; |
||||
var node = linkedList.find(function(val) { |
||||
return val.key === key; |
||||
}); |
||||
if (node) { |
||||
linkedList.rmNode(node); |
||||
} |
||||
}, |
||||
_hash: function(key) { |
||||
return strHash(key) % this._buckets.length; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,79 @@
@@ -0,0 +1,79 @@
|
||||
var Class = require('./Class'); |
||||
var swap = require('./swap'); |
||||
var isSorted = require('./isSorted'); |
||||
exports = Class({ |
||||
initialize: function Heap() { |
||||
var cmp = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: isSorted.defComparator; |
||||
this._cmp = cmp; |
||||
this.clear(); |
||||
}, |
||||
clear: function() { |
||||
this._data = []; |
||||
this.size = 0; |
||||
}, |
||||
add: function(item) { |
||||
this._data.push(item); |
||||
this.size++; |
||||
this._heapifyUp(this.size - 1); |
||||
return this.size; |
||||
}, |
||||
poll: function() { |
||||
var data = this._data; |
||||
if (this.size > 0) { |
||||
var item = data[0]; |
||||
data[0] = data[this.size - 1]; |
||||
this.size--; |
||||
this._heapifyDown(0); |
||||
return item; |
||||
} |
||||
}, |
||||
peek: function() { |
||||
if (this.size > 0) { |
||||
return this._data[0]; |
||||
} |
||||
}, |
||||
_heapifyUp: function(idx) { |
||||
var data = this._data; |
||||
var parent = parentIdx(idx); |
||||
while (idx > 0 && this._cmp(data[parent], data[idx]) > 0) { |
||||
swap(data, parent, idx); |
||||
idx = parent; |
||||
parent = parentIdx(idx); |
||||
} |
||||
}, |
||||
_heapifyDown: function(idx) { |
||||
var size = this.size; |
||||
var cmp = this._cmp; |
||||
var data = this._data; |
||||
while (leftChildIdx(idx) < size) { |
||||
var smallerIdx = leftChildIdx(idx); |
||||
var rightChild = rightChildIdx(idx); |
||||
if ( |
||||
rightChild < size && |
||||
cmp(data[rightChildIdx], data[smallerIdx]) < 0 |
||||
) { |
||||
smallerIdx = rightChild; |
||||
} |
||||
if (cmp(data[idx], data[smallerIdx]) < 0) { |
||||
break; |
||||
} else { |
||||
swap(data, idx, smallerIdx); |
||||
} |
||||
idx = smallerIdx; |
||||
} |
||||
} |
||||
}); |
||||
function parentIdx(idx) { |
||||
return Math.floor((idx - 1) / 2); |
||||
} |
||||
function leftChildIdx(idx) { |
||||
return 2 * idx + 1; |
||||
} |
||||
function rightChildIdx(idx) { |
||||
return 2 * idx + 2; |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,111 @@
@@ -0,0 +1,111 @@
|
||||
var Class = require('./Class'); |
||||
var toBool = require('./toBool'); |
||||
var camelCase = require('./camelCase'); |
||||
var LinkedList = require('./LinkedList'); |
||||
var isStr = require('./isStr'); |
||||
var each = require('./each'); |
||||
var map = require('./map'); |
||||
exports = Class({ |
||||
initialize: function HeapSnapshot(profile) { |
||||
if (isStr(profile)) { |
||||
profile = JSON.parse(profile); |
||||
} |
||||
this.nodes = new LinkedList(); |
||||
this.edges = new LinkedList(); |
||||
var snapshot = profile.snapshot; |
||||
var meta = snapshot.meta; |
||||
this.nodeFields = map(meta.node_fields, camelCase); |
||||
this.nodeTypes = meta.node_types[this.nodeFields.indexOf('type')]; |
||||
this.edgeFields = map(meta.edge_fields, camelCase); |
||||
this.edgeTypes = meta.edge_types[this.edgeFields.indexOf('type')]; |
||||
this._init(profile); |
||||
}, |
||||
_init: function(profile) { |
||||
var _this = this; |
||||
var nodes = profile.nodes, |
||||
edges = profile.edges, |
||||
strings = profile.strings; |
||||
var nodeFields = this.nodeFields, |
||||
edgeFields = this.edgeFields; |
||||
var curEdgeIdx = 0; |
||||
var nodeFieldCount = nodeFields.length; |
||||
var edgeFieldCount = edgeFields.length; |
||||
var nodeMap = {}; |
||||
for (var i = 0, len = nodes.length; i < len; i += nodeFieldCount) { |
||||
var node = new Node(this); |
||||
node.init(nodes.slice(i, i + nodeFieldCount), strings); |
||||
this.nodes.push(node); |
||||
nodeMap[i] = node; |
||||
} |
||||
this.nodes.forEach(function(node) { |
||||
var edgeCount = node.edgeCount; |
||||
delete node.edgeCount; |
||||
var maxEdgeIdx = curEdgeIdx + edgeCount * edgeFieldCount; |
||||
for (var _i = curEdgeIdx; _i < maxEdgeIdx; _i += edgeFieldCount) { |
||||
var edge = new Edge(_this, node); |
||||
edge.init( |
||||
edges.slice(_i, _i + edgeFieldCount), |
||||
strings, |
||||
nodeMap |
||||
); |
||||
_this.edges.push(edge); |
||||
} |
||||
curEdgeIdx = maxEdgeIdx; |
||||
}); |
||||
} |
||||
}); |
||||
var Node = Class({ |
||||
initialize: function Node(heapSnapshot) { |
||||
this._heapSnapshot = heapSnapshot; |
||||
}, |
||||
init: function(fields, strings) { |
||||
var _this2 = this; |
||||
var heapSnapshot = this._heapSnapshot; |
||||
var nodeFields = heapSnapshot.nodeFields, |
||||
nodeTypes = heapSnapshot.nodeTypes; |
||||
each(nodeFields, function(field, idx) { |
||||
var val = fields[idx]; |
||||
switch (field) { |
||||
case 'name': |
||||
val = strings[val]; |
||||
break; |
||||
case 'detachedness': |
||||
val = toBool(val); |
||||
break; |
||||
case 'type': |
||||
val = nodeTypes[val]; |
||||
break; |
||||
} |
||||
_this2[field] = val; |
||||
}); |
||||
} |
||||
}); |
||||
var Edge = Class({ |
||||
initialize: function Edge(heapSnapshot, fromNode) { |
||||
this._heapSnapshot = heapSnapshot; |
||||
this.fromNode = fromNode; |
||||
}, |
||||
init: function(fields, strings, nodeMap) { |
||||
var _this3 = this; |
||||
var heapSnapshot = this._heapSnapshot; |
||||
var edgeFields = heapSnapshot.edgeFields, |
||||
edgeTypes = heapSnapshot.edgeTypes; |
||||
each(edgeFields, function(field, idx) { |
||||
var val = fields[idx]; |
||||
switch (field) { |
||||
case 'nameOrIndex': |
||||
val = strings[val]; |
||||
break; |
||||
case 'type': |
||||
val = edgeTypes[val]; |
||||
break; |
||||
case 'toNode': |
||||
val = nodeMap[val]; |
||||
break; |
||||
} |
||||
_this3[field] = val; |
||||
}); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,38 @@
@@ -0,0 +1,38 @@
|
||||
var Class = require('./Class'); |
||||
var safeGet = require('./safeGet'); |
||||
var extend = require('./extend'); |
||||
var strTpl = require('./strTpl'); |
||||
var isStr = require('./isStr'); |
||||
var isFn = require('./isFn'); |
||||
exports = Class({ |
||||
initialize: function I18n(locale, langs) { |
||||
this._locale = locale; |
||||
this._langs = langs; |
||||
}, |
||||
set: function(locale, lang) { |
||||
if (this._langs[locale]) { |
||||
extend(this._langs[locale], lang); |
||||
} else { |
||||
this._langs[locale] = lang; |
||||
} |
||||
}, |
||||
t: function(path, data) { |
||||
var val = ''; |
||||
var lang = this._langs[this._locale]; |
||||
if (!lang) return ''; |
||||
val = safeGet(lang, path); |
||||
if (data) { |
||||
if (isStr(val)) { |
||||
val = strTpl(val, data); |
||||
} else if (isFn(val)) { |
||||
val = val(data); |
||||
} |
||||
} |
||||
return val || ''; |
||||
}, |
||||
locale: function(locale) { |
||||
this._locale = locale; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,68 @@
@@ -0,0 +1,68 @@
|
||||
var Class = require('./Class'); |
||||
var safeSet = require('./safeSet'); |
||||
var safeGet = require('./safeGet'); |
||||
var map = require('./map'); |
||||
var filter = require('./filter'); |
||||
var isFn = require('./isFn'); |
||||
var safeDel = require('./safeDel'); |
||||
var toArr = require('./toArr'); |
||||
var each = require('./each'); |
||||
exports = Class({ |
||||
className: 'JsonTransformer', |
||||
initialize: function(data) { |
||||
this._data = data || {}; |
||||
}, |
||||
set: function(key, val) { |
||||
if (arguments.length === 1) { |
||||
this._data = key; |
||||
return this; |
||||
} |
||||
safeSet(this._data, key, val); |
||||
return this; |
||||
}, |
||||
get: function(key) { |
||||
if (key == null) return this._data; |
||||
return safeGet(this._data, key); |
||||
}, |
||||
map: function(from, to, fn) { |
||||
if (isFn(from)) return this.set(map(this._data, from, this)); |
||||
if (isFn(to)) { |
||||
fn = to; |
||||
to = from; |
||||
} |
||||
return this.set(to, map(this.get(from), fn, this)); |
||||
}, |
||||
filter: function(from, to, fn) { |
||||
if (isFn(from)) return this.set(filter(this._data, from, this)); |
||||
if (isFn(to)) { |
||||
fn = to; |
||||
to = from; |
||||
} |
||||
return this.set(to, filter(this.get(from), fn, this)); |
||||
}, |
||||
remove: function(keys) { |
||||
keys = toArr(keys); |
||||
var data = this._data; |
||||
each(keys, function(key) { |
||||
safeDel(data, key); |
||||
}); |
||||
return this; |
||||
}, |
||||
compute: function(from, to, fn) { |
||||
if (isFn(from)) return this.set(from.call(this, this._data)); |
||||
if (isFn(to)) return this.set(from, to.call(this, this.get(from))); |
||||
from = map( |
||||
toArr(from), |
||||
function(key) { |
||||
return safeGet(this._data, key); |
||||
}, |
||||
this |
||||
); |
||||
return this.set(to, fn.apply(this, from)); |
||||
}, |
||||
toString: function() { |
||||
return JSON.stringify(this._data); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,112 @@
@@ -0,0 +1,112 @@
|
||||
var Class = require('./Class'); |
||||
exports = Class({ |
||||
initialize: function LinkedList() { |
||||
this.tail = null; |
||||
this.head = null; |
||||
this.size = 0; |
||||
}, |
||||
push: function(val) { |
||||
var node = new Node(val, this.tail, null, this); |
||||
this.tail = node; |
||||
this.head = this.head || node; |
||||
this.size++; |
||||
return this.size; |
||||
}, |
||||
pop: function() { |
||||
if (!this.tail) return; |
||||
var node = this.tail; |
||||
this.tail = node.prev; |
||||
if (this.tail) { |
||||
this.tail.next = null; |
||||
} else { |
||||
this.head = null; |
||||
} |
||||
this.size--; |
||||
return node.value; |
||||
}, |
||||
unshift: function(val) { |
||||
var node = new Node(val, null, this.head, this); |
||||
this.head = node; |
||||
this.tail = this.tail || node; |
||||
this.size++; |
||||
return this.size; |
||||
}, |
||||
shift: function() { |
||||
if (!this.head) return; |
||||
var node = this.head; |
||||
this.head = node.next; |
||||
if (this.head) { |
||||
this.head.prev = null; |
||||
} else { |
||||
this.tail = null; |
||||
} |
||||
this.size--; |
||||
return node.value; |
||||
}, |
||||
rmNode: function(node) { |
||||
if (node.list !== this) { |
||||
throw Error('Node does not belong to this list'); |
||||
} |
||||
var next = node.next, |
||||
prev = node.prev; |
||||
if (next) { |
||||
next.prev = prev; |
||||
} |
||||
if (prev) { |
||||
prev.next = next; |
||||
} |
||||
if (node === this.head) { |
||||
this.head = next; |
||||
} |
||||
if (node === this.tail) { |
||||
this.tail = prev; |
||||
} |
||||
node.list = null; |
||||
node.prev = null; |
||||
node.next = null; |
||||
this.size--; |
||||
}, |
||||
find: function(fn) { |
||||
for (var i = 0, current = this.head; current !== null; i++) { |
||||
if (fn(current.value)) { |
||||
return current; |
||||
} |
||||
current = current.next; |
||||
} |
||||
}, |
||||
forEach: function(iterator, ctx) { |
||||
ctx = arguments.length > 1 ? ctx : this; |
||||
for (var i = 0, current = this.head; current !== null; i++) { |
||||
iterator.call(ctx, current.value, i, this); |
||||
current = current.next; |
||||
} |
||||
}, |
||||
toArr: function() { |
||||
var arr = new Array(this.size); |
||||
for (var i = 0, current = this.head; current !== null; i++) { |
||||
arr[i] = current.value; |
||||
current = current.next; |
||||
} |
||||
return arr; |
||||
} |
||||
}); |
||||
var Node = (exports.Node = Class({ |
||||
initialize: function Node(val, prev, next, list) { |
||||
this.value = val; |
||||
this.list = list; |
||||
if (prev) { |
||||
prev.next = this; |
||||
this.prev = prev; |
||||
} else { |
||||
this.prev = null; |
||||
} |
||||
if (next) { |
||||
next.prev = this; |
||||
this.next = next; |
||||
} else { |
||||
this.next = null; |
||||
} |
||||
} |
||||
})); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,69 @@
@@ -0,0 +1,69 @@
|
||||
var Emitter = require('./Emitter'); |
||||
var Enum = require('./Enum'); |
||||
var toArr = require('./toArr'); |
||||
var isUndef = require('./isUndef'); |
||||
var clone = require('./clone'); |
||||
var isStr = require('./isStr'); |
||||
var isNum = require('./isNum'); |
||||
exports = Emitter.extend( |
||||
{ |
||||
initialize: function Logger(name, level) { |
||||
this.name = name; |
||||
this.setLevel(isUndef(level) ? exports.level.DEBUG : level); |
||||
this.callSuper(Emitter, 'initialize', arguments); |
||||
}, |
||||
setLevel: function(level) { |
||||
if (isStr(level)) { |
||||
level = exports.level[level.toUpperCase()]; |
||||
if (level) this._level = level; |
||||
return this; |
||||
} |
||||
if (isNum(level)) this._level = level; |
||||
return this; |
||||
}, |
||||
getLevel: function() { |
||||
return this._level; |
||||
}, |
||||
formatter: function(type, argList) { |
||||
return argList; |
||||
}, |
||||
trace: function() { |
||||
return this._log('trace', arguments); |
||||
}, |
||||
debug: function() { |
||||
return this._log('debug', arguments); |
||||
}, |
||||
info: function() { |
||||
return this._log('info', arguments); |
||||
}, |
||||
warn: function() { |
||||
return this._log('warn', arguments); |
||||
}, |
||||
error: function() { |
||||
return this._log('error', arguments); |
||||
}, |
||||
_log: function(type, argList) { |
||||
argList = toArr(argList); |
||||
if (argList.length === 0) return this; |
||||
this.emit('all', type, clone(argList)); |
||||
if (exports.level[type.toUpperCase()] < this._level) return this; |
||||
this.emit(type, clone(argList)); |
||||
|
||||
var consoleMethod = type === 'debug' ? console.log : console[type]; |
||||
consoleMethod.apply(console, this.formatter(type, argList)); |
||||
return this; |
||||
} |
||||
}, |
||||
{ |
||||
level: new Enum({ |
||||
TRACE: 0, |
||||
DEBUG: 1, |
||||
INFO: 2, |
||||
WARN: 3, |
||||
ERROR: 4, |
||||
SILENT: 5 |
||||
}) |
||||
} |
||||
); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,63 @@
@@ -0,0 +1,63 @@
|
||||
var LinkedList = require('./LinkedList'); |
||||
var PseudoMap = require('./PseudoMap'); |
||||
var Class = require('./Class'); |
||||
exports = Class({ |
||||
initialize: function Lru(max) { |
||||
this._max = max; |
||||
this._list = new LinkedList(); |
||||
this._map = new PseudoMap(); |
||||
}, |
||||
has: function(key) { |
||||
return this._map.has(key); |
||||
}, |
||||
remove: function(key) { |
||||
var map = this._map; |
||||
if (this.has(key)) { |
||||
var node = map.get(key); |
||||
this._list.rmNode(node); |
||||
map.delete(key); |
||||
} |
||||
}, |
||||
get: function(key) { |
||||
var list = this._list; |
||||
var map = this._map; |
||||
var ret; |
||||
if (this.has(key)) { |
||||
var node = map.get(key); |
||||
ret = node.value.val; |
||||
list.rmNode(node); |
||||
list.unshift(node.value); |
||||
map.set(key, list.head); |
||||
} |
||||
return ret; |
||||
}, |
||||
set: function(key, val) { |
||||
var list = this._list; |
||||
var map = this._map; |
||||
if (this.has(key)) { |
||||
var node = map.get(key); |
||||
list.rmNode(node); |
||||
list.unshift({ |
||||
key: key, |
||||
val: val |
||||
}); |
||||
map.set(key, list.head); |
||||
} else { |
||||
list.unshift({ |
||||
key: key, |
||||
val: val |
||||
}); |
||||
map.set(key, list.head); |
||||
if (list.size > this._max) { |
||||
var item = list.pop(); |
||||
map.delete(item.key); |
||||
} |
||||
} |
||||
}, |
||||
clear: function() { |
||||
this._map = new PseudoMap(); |
||||
this._list = new LinkedList(); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,39 @@
@@ -0,0 +1,39 @@
|
||||
var Class = require('./Class'); |
||||
var Heap = require('./Heap'); |
||||
var isSorted = require('./isSorted'); |
||||
var wrap = require('./wrap'); |
||||
exports = Class({ |
||||
initialize: function PriorityQueue() { |
||||
var cmp = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: isSorted.defComparator; |
||||
this._heap = new Heap( |
||||
wrap(cmp, function(fn, a, b) { |
||||
return fn(a, b) * -1; |
||||
}) |
||||
); |
||||
this.size = 0; |
||||
}, |
||||
clear: function() { |
||||
this._heap.clear(); |
||||
this.size = 0; |
||||
}, |
||||
enqueue: function(item) { |
||||
this._heap.add(item); |
||||
this.size++; |
||||
return this.size; |
||||
}, |
||||
dequeue: function() { |
||||
var item = this._heap.poll(); |
||||
if (item) { |
||||
this.size--; |
||||
return item; |
||||
} |
||||
}, |
||||
peek: function() { |
||||
return this._heap.peek(); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,178 @@
@@ -0,0 +1,178 @@
|
||||
var Class = require('./Class'); |
||||
var isObj = require('./isObj'); |
||||
var isFn = require('./isFn'); |
||||
var State = require('./State'); |
||||
var bind = require('./bind'); |
||||
var nextTick = require('./nextTick'); |
||||
var noop = require('./noop'); |
||||
var toArr = require('./toArr'); |
||||
var Promise = (exports = Class( |
||||
{ |
||||
initialize: function Promise(fn) { |
||||
if (!isObj(this)) |
||||
throw new TypeError('Promises must be constructed via new'); |
||||
if (!isFn(fn)) throw new TypeError(fn + ' is not a function'); |
||||
var self = this; |
||||
this._state = new State('pending', { |
||||
fulfill: { |
||||
from: 'pending', |
||||
to: 'fulfilled' |
||||
}, |
||||
reject: { |
||||
from: 'pending', |
||||
to: 'rejected' |
||||
}, |
||||
adopt: { |
||||
from: 'pending', |
||||
to: 'adopted' |
||||
} |
||||
}) |
||||
.on('fulfill', assignVal) |
||||
.on('reject', assignVal) |
||||
.on('adopt', assignVal); |
||||
function assignVal(val) { |
||||
self._value = val; |
||||
} |
||||
this._handled = false; |
||||
this._value = undefined; |
||||
this._deferreds = []; |
||||
doResolve(fn, this); |
||||
}, |
||||
catch: function(onRejected) { |
||||
return this.then(null, onRejected); |
||||
}, |
||||
then: function(onFulfilled, onRejected) { |
||||
var promise = new Promise(noop); |
||||
handle(this, new Handler(onFulfilled, onRejected, promise)); |
||||
return promise; |
||||
} |
||||
}, |
||||
{ |
||||
all: function(arr) { |
||||
var args = toArr(arr); |
||||
return new Promise(function(resolve, reject) { |
||||
if (args.length === 0) return resolve([]); |
||||
var remaining = args.length; |
||||
function res(i, val) { |
||||
try { |
||||
if (val && (isObj(val) || isFn(val))) { |
||||
var then = val.then; |
||||
if (isFn(then)) { |
||||
then.call( |
||||
val, |
||||
function(val) { |
||||
res(i, val); |
||||
}, |
||||
reject |
||||
); |
||||
return; |
||||
} |
||||
} |
||||
args[i] = val; |
||||
if (--remaining === 0) resolve(args); |
||||
} catch (e) { |
||||
reject(e); |
||||
} |
||||
} |
||||
for (var i = 0; i < args.length; i++) res(i, args[i]); |
||||
}); |
||||
}, |
||||
resolve: function(val) { |
||||
if (val && isObj(val) && val.constructor === Promise) return val; |
||||
return new Promise(function(resolve) { |
||||
resolve(val); |
||||
}); |
||||
}, |
||||
reject: function(val) { |
||||
return new Promise(function(resolve, reject) { |
||||
reject(val); |
||||
}); |
||||
}, |
||||
race: function(values) { |
||||
return new Promise(function(resolve, reject) { |
||||
for (var i = 0, len = values.length; i < len; i++) { |
||||
values[i].then(resolve, reject); |
||||
} |
||||
}); |
||||
} |
||||
} |
||||
)); |
||||
var Handler = Class({ |
||||
initialize: function Handler(onFulfilled, onRejected, promise) { |
||||
this.onFulfilled = isFn(onFulfilled) ? onFulfilled : null; |
||||
this.onRejected = isFn(onRejected) ? onRejected : null; |
||||
this.promise = promise; |
||||
} |
||||
}); |
||||
function reject(self, err) { |
||||
self._state.reject(err); |
||||
finale(self); |
||||
} |
||||
function resolve(self, val) { |
||||
try { |
||||
if (val === self) |
||||
throw new TypeError('A promise cannot be resolved with itself'); |
||||
if (val && (isObj(val) || isFn(val))) { |
||||
var then = val.then; |
||||
if (val instanceof Promise) { |
||||
self._state.adopt(val); |
||||
return finale(self); |
||||
} |
||||
if (isFn(then)) return doResolve(bind(then, val), self); |
||||
} |
||||
self._state.fulfill(val); |
||||
finale(self); |
||||
} catch (e) { |
||||
reject(self, e); |
||||
} |
||||
} |
||||
function finale(self) { |
||||
for (var i = 0, len = self._deferreds.length; i < len; i++) { |
||||
handle(self, self._deferreds[i]); |
||||
} |
||||
self._deferreds = null; |
||||
} |
||||
function handle(self, deferred) { |
||||
while (self._state.is('adopted')) self = self._value; |
||||
if (self._state.is('pending')) return self._deferreds.push(deferred); |
||||
self._handled = true; |
||||
nextTick(function() { |
||||
var isFulfilled = self._state.is('fulfilled'); |
||||
var cb = isFulfilled ? deferred.onFulfilled : deferred.onRejected; |
||||
if (cb === null) |
||||
return (isFulfilled ? resolve : reject)( |
||||
deferred.promise, |
||||
self._value |
||||
); |
||||
var ret; |
||||
try { |
||||
ret = cb(self._value); |
||||
} catch (e) { |
||||
return reject(deferred.promise, e); |
||||
} |
||||
resolve(deferred.promise, ret); |
||||
}); |
||||
} |
||||
function doResolve(fn, self) { |
||||
var done = false; |
||||
try { |
||||
fn( |
||||
function(val) { |
||||
if (done) return; |
||||
done = true; |
||||
resolve(self, val); |
||||
}, |
||||
function(reason) { |
||||
if (done) return; |
||||
done = true; |
||||
reject(self, reason); |
||||
} |
||||
); |
||||
} catch (e) { |
||||
if (done) return; |
||||
done = true; |
||||
reject(self, e); |
||||
} |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,64 @@
@@ -0,0 +1,64 @@
|
||||
var Class = require('./Class'); |
||||
var root = require('./root'); |
||||
var defineProp = require('./defineProp'); |
||||
var keys = require('./keys'); |
||||
var each = require('./each'); |
||||
var isArr = require('./isArr'); |
||||
var isUndef = require('./isUndef'); |
||||
if (root.Map && !false) { |
||||
exports = root.Map; |
||||
} else { |
||||
exports = Class({ |
||||
initialize: function PseudoMap(data) { |
||||
this.clear(); |
||||
var self = this; |
||||
defineProp(this, 'size', { |
||||
get: function() { |
||||
return keys(self._data).length; |
||||
}, |
||||
set: function() {}, |
||||
enumerable: true, |
||||
configurable: true |
||||
}); |
||||
if (data instanceof exports) { |
||||
data.forEach(function(val, key) { |
||||
this.set(key, val); |
||||
}, this); |
||||
} else if (isArr(data)) { |
||||
each( |
||||
data, |
||||
function(val) { |
||||
this.set(val[0], val[1]); |
||||
}, |
||||
this |
||||
); |
||||
} |
||||
}, |
||||
forEach: function(fn, ctx) { |
||||
each( |
||||
this._data, |
||||
function(val, key) { |
||||
fn.call(this, val, key); |
||||
}, |
||||
ctx |
||||
); |
||||
}, |
||||
has: function(key) { |
||||
return !isUndef(this._data[key]); |
||||
}, |
||||
get: function(key) { |
||||
return this._data[key]; |
||||
}, |
||||
set: function(key, val) { |
||||
this._data[key] = val; |
||||
}, |
||||
delete: function(key) { |
||||
delete this._data[key]; |
||||
}, |
||||
clear: function() { |
||||
this._data = {}; |
||||
} |
||||
}); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,35 @@
@@ -0,0 +1,35 @@
|
||||
var Class = require('./Class'); |
||||
exports = Class({ |
||||
initialize: function Queue() { |
||||
this.clear(); |
||||
}, |
||||
clear: function() { |
||||
this._items = []; |
||||
this.size = 0; |
||||
}, |
||||
enqueue: function(item) { |
||||
this._items.push(item); |
||||
return ++this.size; |
||||
}, |
||||
dequeue: function() { |
||||
if (!this.size) return; |
||||
this.size--; |
||||
return this._items.shift(); |
||||
}, |
||||
peek: function() { |
||||
if (!this.size) return; |
||||
return this._items[0]; |
||||
}, |
||||
forEach: function(iterator, ctx) { |
||||
ctx = arguments.length > 1 ? ctx : this; |
||||
var items = this._items; |
||||
for (var i = 0, size = this.size; i < size; i++) { |
||||
iterator.call(ctx, items[i], i, this); |
||||
} |
||||
}, |
||||
toArr: function() { |
||||
return this._items.slice(0); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,49 @@
@@ -0,0 +1,49 @@
|
||||
var isUndef = require('./isUndef'); |
||||
var Class = require('./Class'); |
||||
exports = Class({ |
||||
initialize: function QuickLru(max) { |
||||
this._max = max; |
||||
this._cache = {}; |
||||
this._oldCache = {}; |
||||
this._size = 0; |
||||
}, |
||||
has: function(key) { |
||||
return !isUndef(this._cache[key]) || !isUndef(this._oldCache[key]); |
||||
}, |
||||
remove: function(key) { |
||||
if (!isUndef(this._cache[key])) this._cache[key] = undefined; |
||||
if (!isUndef(this._oldCache[key])) this._oldCache[key] = undefined; |
||||
}, |
||||
get: function(key) { |
||||
if (!isUndef(this._cache[key])) { |
||||
return this._cache[key]; |
||||
} |
||||
var val = this._oldCache[key]; |
||||
if (!isUndef(val)) { |
||||
this._update(key, val); |
||||
return val; |
||||
} |
||||
}, |
||||
set: function(key, val) { |
||||
if (!isUndef(this._cache[key])) { |
||||
this._cache[key] = val; |
||||
} else { |
||||
this._update(key, val); |
||||
} |
||||
}, |
||||
clear: function() { |
||||
this._cache = {}; |
||||
this._oldCache = {}; |
||||
}, |
||||
_update: function(key, val) { |
||||
this._cache[key] = val; |
||||
this._size++; |
||||
if (this._size > this._max) { |
||||
this._size = 0; |
||||
this._oldCache = this._cache; |
||||
this._cache = {}; |
||||
} |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,59 @@
@@ -0,0 +1,59 @@
|
||||
var Class = require('./Class'); |
||||
var toArr = require('./toArr'); |
||||
var each = require('./each'); |
||||
var map = require('./map'); |
||||
var noop = require('./noop'); |
||||
var some = require('./some'); |
||||
exports = Class({ |
||||
initialize: function Readiness() { |
||||
this._promises = {}; |
||||
this._resolves = {}; |
||||
this._states = {}; |
||||
}, |
||||
signal: function(tasks) { |
||||
var states = this._states; |
||||
each(this._getPromises(toArr(tasks)), function(val) { |
||||
if (!val.state) { |
||||
states[val.task] = true; |
||||
val.resolve(); |
||||
} |
||||
}); |
||||
}, |
||||
isReady: function(tasks) { |
||||
return !some(this._getPromises(toArr(tasks)), function(val) { |
||||
return !val.state; |
||||
}); |
||||
}, |
||||
ready: function(tasks) { |
||||
var fn = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: noop; |
||||
return Promise.all( |
||||
map(this._getPromises(toArr(tasks)), function(val) { |
||||
return val.promise; |
||||
}) |
||||
).then(fn); |
||||
}, |
||||
_getPromises: function(tasks) { |
||||
var promises = this._promises; |
||||
var resolves = this._resolves; |
||||
var states = this._states; |
||||
return map(tasks, function(task) { |
||||
if (!promises[task]) { |
||||
promises[task] = new Promise(function(resolve) { |
||||
resolves[task] = resolve; |
||||
states[task] = false; |
||||
}); |
||||
} |
||||
return { |
||||
task: task, |
||||
promise: promises[task], |
||||
resolve: resolves[task], |
||||
state: states[task] |
||||
}; |
||||
}); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,41 @@
@@ -0,0 +1,41 @@
|
||||
var Class = require('./Class'); |
||||
var clone = require('./clone'); |
||||
var remove = require('./remove'); |
||||
exports = Class({ |
||||
initialize: function ReduceStore(reducer, initialState) { |
||||
this._reducer = reducer; |
||||
this._state = initialState; |
||||
this._curListeners = []; |
||||
this._nextListeners = this._curListeners; |
||||
}, |
||||
subscribe: function(listener) { |
||||
var isSubscribed = true; |
||||
this._ensureCanMutateNextListeners(); |
||||
this._nextListeners.push(listener); |
||||
var self = this; |
||||
return function() { |
||||
if (!isSubscribed) return; |
||||
isSubscribed = false; |
||||
self._ensureCanMutateNextListeners(); |
||||
remove(self._nextListeners, function(val) { |
||||
return val === listener; |
||||
}); |
||||
}; |
||||
}, |
||||
dispatch: function(action) { |
||||
this._state = this._reducer(this._state, action); |
||||
var listeners = (this._curListeners = this._nextListeners); |
||||
for (var i = 0, len = listeners.length; i < len; i++) listeners[i](); |
||||
return action; |
||||
}, |
||||
getState: function() { |
||||
return this._state; |
||||
}, |
||||
_ensureCanMutateNextListeners: function() { |
||||
if (this._nextListeners === this._curListeners) { |
||||
this._nextListeners = clone(this._curListeners); |
||||
} |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,28 @@
@@ -0,0 +1,28 @@
|
||||
var Class = require('./Class'); |
||||
var Queue = require('./Queue'); |
||||
exports = Class({ |
||||
initialize: function Semaphore() { |
||||
var counter = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: 1; |
||||
this._counter = counter; |
||||
this._tasks = new Queue(); |
||||
}, |
||||
wait: function(fn) { |
||||
if (this._counter > 0) { |
||||
this._counter--; |
||||
return fn(); |
||||
} |
||||
this._tasks.enqueue(fn); |
||||
}, |
||||
signal: function() { |
||||
var task = this._tasks.dequeue(); |
||||
if (task) { |
||||
return task(); |
||||
} |
||||
this._counter++; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,48 @@
@@ -0,0 +1,48 @@
|
||||
var Class = require('./Class'); |
||||
var clone = require('./clone'); |
||||
var each = require('./each'); |
||||
var toArr = require('./toArr'); |
||||
exports = Class( |
||||
{ |
||||
initialize: function SingleEmitter() { |
||||
this._listeners = []; |
||||
}, |
||||
addListener: function(listener) { |
||||
this._listeners.push(listener); |
||||
}, |
||||
rmListener: function(listener) { |
||||
var idx = this._listeners.indexOf(listener); |
||||
if (idx > -1) { |
||||
this._listeners.splice(idx, 1); |
||||
} |
||||
}, |
||||
rmAllListeners: function() { |
||||
this._listeners = []; |
||||
}, |
||||
emit: function() { |
||||
var _this = this; |
||||
var args = toArr(arguments); |
||||
var listeners = clone(this._listeners); |
||||
each( |
||||
listeners, |
||||
function(listener) { |
||||
return listener.apply(_this, args); |
||||
}, |
||||
this |
||||
); |
||||
} |
||||
}, |
||||
{ |
||||
mixin: function(obj) { |
||||
each( |
||||
['addListener', 'rmListener', 'emit', 'rmAllListeners'], |
||||
function(val) { |
||||
obj[val] = exports.prototype[val]; |
||||
} |
||||
); |
||||
obj._listeners = obj._listeners || []; |
||||
} |
||||
} |
||||
); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,35 @@
@@ -0,0 +1,35 @@
|
||||
var Class = require('./Class'); |
||||
var reverse = require('./reverse'); |
||||
exports = Class({ |
||||
initialize: function Stack() { |
||||
this.clear(); |
||||
}, |
||||
clear: function() { |
||||
this._items = []; |
||||
this.size = 0; |
||||
}, |
||||
push: function(item) { |
||||
this._items.push(item); |
||||
return ++this.size; |
||||
}, |
||||
pop: function() { |
||||
if (!this.size) return; |
||||
this.size--; |
||||
return this._items.pop(); |
||||
}, |
||||
peek: function() { |
||||
return this._items[this.size - 1]; |
||||
}, |
||||
forEach: function(iterator, ctx) { |
||||
ctx = arguments.length > 1 ? ctx : this; |
||||
var items = this._items; |
||||
for (var i = this.size - 1, j = 0; i >= 0; i--, j++) { |
||||
iterator.call(ctx, items[i], j, this); |
||||
} |
||||
}, |
||||
toArr: function() { |
||||
return reverse(this._items); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,45 @@
@@ -0,0 +1,45 @@
|
||||
var Emitter = require('./Emitter'); |
||||
var each = require('./each'); |
||||
var some = require('./some'); |
||||
var toArr = require('./toArr'); |
||||
exports = Emitter.extend({ |
||||
className: 'State', |
||||
initialize: function(initial, events) { |
||||
this.callSuper(Emitter, 'initialize'); |
||||
this.current = initial; |
||||
var self = this; |
||||
each(events, function(event, key) { |
||||
self[key] = buildEvent(key, event); |
||||
}); |
||||
}, |
||||
is: function(state) { |
||||
return this.current === state; |
||||
} |
||||
}); |
||||
function buildEvent(name, event) { |
||||
var from = toArr(event.from); |
||||
var to = event.to; |
||||
return function() { |
||||
var args = toArr(arguments); |
||||
args.unshift(name); |
||||
var hasEvent = some( |
||||
from, |
||||
function(val) { |
||||
return this.current === val; |
||||
}, |
||||
this |
||||
); |
||||
if (hasEvent) { |
||||
this.current = to; |
||||
this.emit.apply(this, args); |
||||
} else { |
||||
this.emit( |
||||
'error', |
||||
new Error(this.current + ' => ' + to + ' error'), |
||||
name |
||||
); |
||||
} |
||||
}; |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,58 @@
@@ -0,0 +1,58 @@
|
||||
var Emitter = require('./Emitter'); |
||||
var isStr = require('./isStr'); |
||||
var isObj = require('./isObj'); |
||||
var each = require('./each'); |
||||
var toArr = require('./toArr'); |
||||
exports = Emitter.extend({ |
||||
initialize: function Store(data) { |
||||
this.callSuper(Emitter, 'initialize', arguments); |
||||
this._data = data || {}; |
||||
this.save(this._data); |
||||
}, |
||||
set: function(key, val) { |
||||
var data; |
||||
if (isStr(key)) { |
||||
data = {}; |
||||
data[key] = val; |
||||
} else if (isObj(key)) { |
||||
data = key; |
||||
} |
||||
var self = this; |
||||
each(data, function(val, key) { |
||||
var oldVal = self._data[key]; |
||||
self._data[key] = val; |
||||
self.emit('change', key, val, oldVal); |
||||
}); |
||||
this.save(this._data); |
||||
}, |
||||
get: function(key) { |
||||
var data = this._data; |
||||
if (isStr(key)) return data[key]; |
||||
var ret = {}; |
||||
each(key, function(val) { |
||||
ret[val] = data[val]; |
||||
}); |
||||
return ret; |
||||
}, |
||||
remove: function(key) { |
||||
key = toArr(key); |
||||
var data = this._data; |
||||
each(key, function(val) { |
||||
delete data[val]; |
||||
}); |
||||
this.save(data); |
||||
}, |
||||
clear: function() { |
||||
this._data = {}; |
||||
this.save(this._data); |
||||
}, |
||||
each: function(fn) { |
||||
each(this._data, fn); |
||||
}, |
||||
|
||||
save: function(data) { |
||||
this._data = data; |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,157 @@
@@ -0,0 +1,157 @@
|
||||
var Class = require('./Class'); |
||||
var each = require('./each'); |
||||
var map = require('./map'); |
||||
exports = Class({ |
||||
initialize: function Trace() { |
||||
var _this = this; |
||||
var events = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: []; |
||||
this._processes = {}; |
||||
each(events, function(event) { |
||||
return _this.addEvent(event); |
||||
}); |
||||
}, |
||||
addEvent: function(event) { |
||||
var process = this.getProcess(event.pid); |
||||
process.addEvent(event); |
||||
}, |
||||
rmEvent: function(event) { |
||||
var process = this.getProcess(event.pid); |
||||
process.rmEvent(event); |
||||
}, |
||||
getProcess: function(id) { |
||||
var process = this._processes[id]; |
||||
if (!process) { |
||||
process = new Process(id); |
||||
this._processes[id] = process; |
||||
} |
||||
return process; |
||||
}, |
||||
rmProcess: function(id) { |
||||
delete this._processes[id]; |
||||
}, |
||||
processes: function() { |
||||
return map(this._processes); |
||||
}, |
||||
toJSON: function() { |
||||
var events = []; |
||||
each(this.processes(), function(process) { |
||||
events.push.apply(events, process.toJSON()); |
||||
}); |
||||
return events; |
||||
} |
||||
}); |
||||
var Process = Class({ |
||||
initialize: function Process(id) { |
||||
this._id = id; |
||||
this._name = ''; |
||||
this._threads = {}; |
||||
this._metadata = {}; |
||||
}, |
||||
id: function() { |
||||
return this._id; |
||||
}, |
||||
name: function() { |
||||
return this._name; |
||||
}, |
||||
addEvent: function(event) { |
||||
if (event.cat === '__metadata') { |
||||
if (event.name === 'process_name') { |
||||
this._name = event.args.name; |
||||
} |
||||
if (event.tid === 0) { |
||||
this._metadata[event.name] = event.args; |
||||
return; |
||||
} |
||||
} |
||||
var thread = this.getThread(event.tid); |
||||
thread.addEvent(event); |
||||
}, |
||||
rmEvent: function(event) { |
||||
var thread = this.getThread(event.tid); |
||||
thread.rmEvent(event); |
||||
}, |
||||
getThread: function(id) { |
||||
var thread = this._threads[id]; |
||||
if (!thread) { |
||||
thread = new Thread(id, this.id()); |
||||
this._threads[id] = thread; |
||||
} |
||||
return thread; |
||||
}, |
||||
rmThread: function(id) { |
||||
delete this._threads[id]; |
||||
}, |
||||
threads: function() { |
||||
return map(this._threads); |
||||
}, |
||||
toJSON: function() { |
||||
var _this2 = this; |
||||
var events = []; |
||||
each(this._metadata, function(args, name) { |
||||
events.push(createMetaEvent(_this2._id, 0, name, args)); |
||||
}); |
||||
each(this.threads(), function(thread) { |
||||
events.push.apply(events, thread.toJSON()); |
||||
}); |
||||
return events; |
||||
} |
||||
}); |
||||
var Thread = Class({ |
||||
initialize: function Thread(id, pid) { |
||||
this._id = id; |
||||
this._pid = pid; |
||||
this._name = ''; |
||||
this._events = []; |
||||
this._metadata = {}; |
||||
}, |
||||
id: function() { |
||||
return this._id; |
||||
}, |
||||
name: function() { |
||||
return this._name; |
||||
}, |
||||
addEvent: function(event) { |
||||
if (event.cat === '__metadata') { |
||||
if (event.name === 'thread_name') { |
||||
this._name = event.args.name; |
||||
} |
||||
this._metadata[event.name] = event.args; |
||||
return; |
||||
} |
||||
this._events.push(event); |
||||
}, |
||||
rmEvent: function(event) { |
||||
var events = this._events; |
||||
events.splice(events.indexOf(event), 1); |
||||
}, |
||||
events: function() { |
||||
return map(this._events); |
||||
}, |
||||
toJSON: function() { |
||||
var _this3 = this; |
||||
var events = []; |
||||
each(this._metadata, function(args, name) { |
||||
events.push(createMetaEvent(_this3._pid, _this3._id, name, args)); |
||||
}); |
||||
each(this.events(), function(event) { |
||||
events.push(event); |
||||
}); |
||||
return events; |
||||
} |
||||
}); |
||||
function createMetaEvent(pid, tid, name, args) { |
||||
return { |
||||
args: args, |
||||
cat: '__metadata', |
||||
name: name, |
||||
ph: 'M', |
||||
pid: pid, |
||||
tid: tid, |
||||
ts: 0 |
||||
}; |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,227 @@
@@ -0,0 +1,227 @@
|
||||
var Class = require('./Class'); |
||||
var Trace = require('./Trace'); |
||||
var perfNow = require('./perfNow'); |
||||
var extend = require('./extend'); |
||||
var isNode = require('./isNode'); |
||||
var Stack = require('./Stack'); |
||||
var map = require('./map'); |
||||
var trim = require('./trim'); |
||||
var isEmpty = require('./isEmpty'); |
||||
var intersect = require('./intersect'); |
||||
var convertBase = require('./convertBase'); |
||||
var defPid = 0; |
||||
var defTid = 0; |
||||
var id = 0; |
||||
if (isNode) { |
||||
defPid = process.pid; |
||||
try { |
||||
defTid = eval('require')('worker_threads').threadId; |
||||
} catch (e) {} |
||||
} |
||||
exports = Class({ |
||||
initialize: function Tracing() { |
||||
var _ref = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: {}, |
||||
_ref$pid = _ref.pid, |
||||
pid = _ref$pid === void 0 ? defPid : _ref$pid, |
||||
_ref$tid = _ref.tid, |
||||
tid = _ref$tid === void 0 ? defTid : _ref$tid, |
||||
_ref$processName = _ref.processName, |
||||
processName = |
||||
_ref$processName === void 0 ? 'Process' : _ref$processName, |
||||
_ref$threadName = _ref.threadName, |
||||
threadName = |
||||
_ref$threadName === void 0 ? 'Thread' : _ref$threadName; |
||||
this._pid = pid; |
||||
this._tid = tid; |
||||
this._processName = processName; |
||||
this._threadName = threadName; |
||||
}, |
||||
start: function() { |
||||
var cat = |
||||
arguments.length > 0 && arguments[0] !== undefined |
||||
? arguments[0] |
||||
: ''; |
||||
this._targetCat = processCat(cat); |
||||
if (!isEmpty(this._targetCat)) { |
||||
this._targetCat.push('__metadata'); |
||||
} |
||||
this._traceEventStack = new Stack(); |
||||
this._asyncEventMap = {}; |
||||
this._trace = new Trace(); |
||||
this.metadata( |
||||
'process_name', |
||||
{ |
||||
name: this._processName |
||||
}, |
||||
{ |
||||
tid: 0, |
||||
ts: 0 |
||||
} |
||||
); |
||||
this.metadata( |
||||
'thread_name', |
||||
{ |
||||
name: this._threadName |
||||
}, |
||||
{ |
||||
ts: 0 |
||||
} |
||||
); |
||||
}, |
||||
stop: function() { |
||||
var trace = this._trace; |
||||
if (!trace) { |
||||
throw Error('Need to call start first'); |
||||
} |
||||
delete this._targetCat; |
||||
delete this._traceEventStack; |
||||
delete this._asyncEventMap; |
||||
delete this._trace; |
||||
return trace.toJSON(); |
||||
}, |
||||
metadata: function(name, args, extra) { |
||||
this._addEvent('__metadata', name, Phase.Metadata, args, extra); |
||||
}, |
||||
begin: function(cat, name) { |
||||
var args = |
||||
arguments.length > 2 && arguments[2] !== undefined |
||||
? arguments[2] |
||||
: {}; |
||||
if (!this._traceEventStack) { |
||||
return; |
||||
} |
||||
this._traceEventStack.push({ |
||||
cat: cat, |
||||
name: name, |
||||
args: args, |
||||
ts: this._getCurTs() |
||||
}); |
||||
}, |
||||
end: function(args) { |
||||
if (!this._traceEventStack) { |
||||
return; |
||||
} |
||||
var beginEvent = this._traceEventStack.pop(); |
||||
if (!beginEvent) { |
||||
throw Error('Need to call begin first'); |
||||
} |
||||
var cat = beginEvent.cat, |
||||
name = beginEvent.name, |
||||
ts = beginEvent.ts; |
||||
args = extend(beginEvent.args, args); |
||||
this._addEvent(cat, name, Phase.Complete, args, { |
||||
dur: this._getCurTs() - ts, |
||||
ts: ts |
||||
}); |
||||
}, |
||||
asyncBegin: function(cat, name) { |
||||
var id = |
||||
arguments.length > 2 && arguments[2] !== undefined |
||||
? arguments[2] |
||||
: this.id(); |
||||
var args = |
||||
arguments.length > 3 && arguments[3] !== undefined |
||||
? arguments[3] |
||||
: {}; |
||||
if (!this._asyncEventMap) { |
||||
return id; |
||||
} |
||||
this._asyncEventMap[id] = { |
||||
cat: cat, |
||||
name: name |
||||
}; |
||||
this._addEvent(cat, name, Phase.NestableAsyncBegin, args, { |
||||
id: id |
||||
}); |
||||
return id; |
||||
}, |
||||
asyncEnd: function(id) { |
||||
var args = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: {}; |
||||
if (!this._asyncEventMap) { |
||||
return; |
||||
} |
||||
var asyncBeginEvent = this._asyncEventMap[id]; |
||||
if (!asyncBeginEvent) { |
||||
throw Error('Need to call async begin first'); |
||||
} |
||||
var cat = asyncBeginEvent.cat, |
||||
name = asyncBeginEvent.name; |
||||
delete this._asyncEventMap[id]; |
||||
this._addEvent(cat, name, Phase.NestableAsyncEnd, args, { |
||||
id: id |
||||
}); |
||||
}, |
||||
instant: function(cat, name) { |
||||
var scope = |
||||
arguments.length > 2 && arguments[2] !== undefined |
||||
? arguments[2] |
||||
: 't'; |
||||
var args = arguments.length > 3 ? arguments[3] : undefined; |
||||
this._addEvent(cat, name, Phase.Instant, args, { |
||||
s: scope |
||||
}); |
||||
}, |
||||
id: function() { |
||||
return '0x' + convertBase(id++, 10, 16); |
||||
}, |
||||
_addEvent: function(cat, name, ph) { |
||||
var args = |
||||
arguments.length > 3 && arguments[3] !== undefined |
||||
? arguments[3] |
||||
: {}; |
||||
var extra = |
||||
arguments.length > 4 && arguments[4] !== undefined |
||||
? arguments[4] |
||||
: {}; |
||||
if (!this._trace) { |
||||
return; |
||||
} |
||||
var targetCat = this._targetCat; |
||||
if (!isEmpty(targetCat)) { |
||||
var catArr = processCat(cat); |
||||
if (isEmpty(intersect(catArr, targetCat))) { |
||||
return; |
||||
} |
||||
} |
||||
var event = extend( |
||||
{ |
||||
name: name, |
||||
cat: cat, |
||||
ph: ph, |
||||
ts: this._getCurTs(), |
||||
pid: this._pid, |
||||
tid: this._tid, |
||||
args: args |
||||
}, |
||||
extra |
||||
); |
||||
this._trace.addEvent(event); |
||||
}, |
||||
_getCurTs: function() { |
||||
return Math.round(perfNow() * 1000); |
||||
} |
||||
}); |
||||
var Phase = { |
||||
Begin: 'B', |
||||
End: 'E', |
||||
Complete: 'X', |
||||
Instant: 'I', |
||||
NestableAsyncBegin: 'b', |
||||
NestableAsyncEnd: 'e', |
||||
Metadata: 'M' |
||||
}; |
||||
function processCat(cat) { |
||||
cat = trim(cat); |
||||
if (cat === '') { |
||||
return []; |
||||
} |
||||
return map(cat.split(','), trim); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,90 @@
@@ -0,0 +1,90 @@
|
||||
var Class = require('./Class'); |
||||
var each = require('./each'); |
||||
|
||||
exports = Class({ |
||||
initialize: function Trie() { |
||||
this.clear(); |
||||
}, |
||||
add: function(word) { |
||||
var edges = this._edges; |
||||
var node = this._root; |
||||
this._wordsInSubtree[node]++; |
||||
for (var i = 0, len = word.length; i < len; i++) { |
||||
var edge = word[i]; |
||||
var next = edges[node][edge]; |
||||
if (!next) { |
||||
if (this._freeNodes.length) { |
||||
next = this._freeNodes.pop(); |
||||
} else { |
||||
next = this._idx++; |
||||
this._isWord.push(false); |
||||
this._wordsInSubtree.push(0); |
||||
edges.push({}); |
||||
} |
||||
edges[node][edge] = next; |
||||
} |
||||
this._wordsInSubtree[next]++; |
||||
node = next; |
||||
} |
||||
this._isWord[node] = true; |
||||
}, |
||||
remove: function(word) { |
||||
if (!this.has(word)) { |
||||
return; |
||||
} |
||||
var node = this._root; |
||||
this._wordsInSubtree[node]--; |
||||
for (var i = 0, len = word.length; i < len; i++) { |
||||
var edge = word[i]; |
||||
var next = this._edges[node][edge]; |
||||
if (!--this._wordsInSubtree[next]) { |
||||
delete this._edges[node][edge]; |
||||
this._freeNodes.push(next); |
||||
} |
||||
node = next; |
||||
} |
||||
this._isWord[node] = false; |
||||
}, |
||||
has: function(word) { |
||||
var node = this._root; |
||||
for (var i = 0, len = word.length; i < len; i++) { |
||||
node = this._edges[node][word[i]]; |
||||
if (!node) { |
||||
return false; |
||||
} |
||||
} |
||||
return this._isWord[node]; |
||||
}, |
||||
words: function(prefix) { |
||||
var node = this._root; |
||||
for (var i = 0, len = prefix.length; i < len; i++) { |
||||
node = this._edges[node][prefix[i]]; |
||||
if (!node) { |
||||
return []; |
||||
} |
||||
} |
||||
var result = []; |
||||
this._dfs(node, prefix, result); |
||||
return result; |
||||
}, |
||||
clear: function() { |
||||
this._idx = 1; |
||||
this._root = 0; |
||||
this._edges = [{}]; |
||||
this._isWord = [false]; |
||||
this._wordsInSubtree = [0]; |
||||
this._freeNodes = []; |
||||
}, |
||||
_dfs: function(node, prefix, result) { |
||||
var _this = this; |
||||
if (this._isWord[node]) { |
||||
result.push(prefix); |
||||
} |
||||
var edges = this._edges[node]; |
||||
each(edges, function(node, edge) { |
||||
return _this._dfs(node, prefix + edge, result); |
||||
}); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,98 @@
@@ -0,0 +1,98 @@
|
||||
var Emitter = require('./Emitter'); |
||||
var State = require('./State'); |
||||
var easing = require('./easing'); |
||||
var now = require('./now'); |
||||
var each = require('./each'); |
||||
var raf = require('./raf'); |
||||
var isFn = require('./isFn'); |
||||
exports = Emitter.extend({ |
||||
className: 'Tween', |
||||
initialize: function(target) { |
||||
this.callSuper(Emitter, 'initialize', arguments); |
||||
this._target = target; |
||||
this._dest = {}; |
||||
this._duration = 0; |
||||
this._progress = 0; |
||||
this._origin = {}; |
||||
this._diff = {}; |
||||
this._ease = easing['linear']; |
||||
this._state = new State('pause', { |
||||
play: { |
||||
from: 'pause', |
||||
to: 'play' |
||||
}, |
||||
pause: { |
||||
from: 'play', |
||||
to: 'pause' |
||||
} |
||||
}); |
||||
}, |
||||
to: function(props, duration, ease) { |
||||
var origin = {}; |
||||
var target = this._target; |
||||
var diff = {}; |
||||
ease = ease || this._ease; |
||||
this._dest = props; |
||||
this._duration = duration || this._duration; |
||||
this._ease = isFn(ease) ? ease : easing[ease]; |
||||
each(props, function(val, key) { |
||||
origin[key] = target[key]; |
||||
diff[key] = val - origin[key]; |
||||
}); |
||||
this._origin = origin; |
||||
this._diff = diff; |
||||
return this; |
||||
}, |
||||
progress: function(progress) { |
||||
var ease = this._ease; |
||||
var target = this._target; |
||||
var origin = this._origin; |
||||
var diff = this._diff; |
||||
var dest = this._dest; |
||||
var self = this; |
||||
if (progress != null) { |
||||
progress = progress < 1 ? progress : 1; |
||||
this._progress = progress; |
||||
each(dest, function(val, key) { |
||||
target[key] = origin[key] + diff[key] * ease(progress); |
||||
}); |
||||
self.emit('update', target); |
||||
return this; |
||||
} |
||||
return this._progress; |
||||
}, |
||||
play: function() { |
||||
var state = this._state; |
||||
if (state.is('play')) return; |
||||
state.play(); |
||||
var startTime = now(); |
||||
var progress = this._progress; |
||||
var duration = this._duration * (1 - progress); |
||||
var target = this._target; |
||||
var self = this; |
||||
function render() { |
||||
if (state.is('pause')) return; |
||||
var time = now(); |
||||
self.progress(progress + (time - startTime) / duration); |
||||
if (self._progress === 1) { |
||||
state.pause(); |
||||
self.emit('end', target); |
||||
return; |
||||
} |
||||
raf(render); |
||||
} |
||||
raf(render); |
||||
return this; |
||||
}, |
||||
pause: function() { |
||||
var state = this._state; |
||||
if (state.is('pause')) return; |
||||
state.pause(); |
||||
return this; |
||||
}, |
||||
paused: function() { |
||||
return this._state.is('pause'); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,125 @@
@@ -0,0 +1,125 @@
|
||||
var Class = require('./Class'); |
||||
var extend = require('./extend'); |
||||
var trim = require('./trim'); |
||||
var query = require('./query'); |
||||
var isEmpty = require('./isEmpty'); |
||||
var each = require('./each'); |
||||
var isArr = require('./isArr'); |
||||
var toArr = require('./toArr'); |
||||
var isBrowser = require('./isBrowser'); |
||||
var isObj = require('./isObj'); |
||||
var toStr = require('./toStr'); |
||||
exports = Class( |
||||
{ |
||||
className: 'Url', |
||||
initialize: function(url) { |
||||
if (!url && isBrowser) url = window.location.href; |
||||
extend(this, exports.parse(url || '')); |
||||
}, |
||||
setQuery: function(name, val) { |
||||
var query = this.query; |
||||
if (isObj(name)) { |
||||
each(name, function(val, key) { |
||||
query[key] = toStr(val); |
||||
}); |
||||
} else { |
||||
query[name] = toStr(val); |
||||
} |
||||
return this; |
||||
}, |
||||
rmQuery: function(name) { |
||||
var query = this.query; |
||||
if (!isArr(name)) name = toArr(name); |
||||
each(name, function(key) { |
||||
delete query[key]; |
||||
}); |
||||
return this; |
||||
}, |
||||
toString: function() { |
||||
return exports.stringify(this); |
||||
} |
||||
}, |
||||
{ |
||||
parse: function(url) { |
||||
var ret = { |
||||
protocol: '', |
||||
auth: '', |
||||
hostname: '', |
||||
hash: '', |
||||
query: {}, |
||||
port: '', |
||||
pathname: '', |
||||
slashes: false |
||||
}; |
||||
var rest = trim(url); |
||||
var slashes = false; |
||||
var proto = rest.match(regProto); |
||||
if (proto) { |
||||
proto = proto[0]; |
||||
ret.protocol = proto.toLowerCase(); |
||||
rest = rest.substr(proto.length); |
||||
} |
||||
if (proto) { |
||||
slashes = rest.substr(0, 2) === '//'; |
||||
if (slashes) { |
||||
rest = rest.slice(2); |
||||
ret.slashes = true; |
||||
} |
||||
} |
||||
if (slashes) { |
||||
var host = rest; |
||||
var hostEnd = -1; |
||||
for (var i = 0, len = hostEndingChars.length; i < len; i++) { |
||||
var pos = rest.indexOf(hostEndingChars[i]); |
||||
if (pos !== -1 && (hostEnd === -1 || pos < hostEnd)) |
||||
hostEnd = pos; |
||||
} |
||||
if (hostEnd > -1) { |
||||
host = rest.slice(0, hostEnd); |
||||
rest = rest.slice(hostEnd); |
||||
} |
||||
var atSign = host.lastIndexOf('@'); |
||||
if (atSign !== -1) { |
||||
ret.auth = decodeURIComponent(host.slice(0, atSign)); |
||||
host = host.slice(atSign + 1); |
||||
} |
||||
ret.hostname = host; |
||||
var port = host.match(regPort); |
||||
if (port) { |
||||
port = port[0]; |
||||
if (port !== ':') ret.port = port.substr(1); |
||||
ret.hostname = host.substr(0, host.length - port.length); |
||||
} |
||||
} |
||||
var hash = rest.indexOf('#'); |
||||
if (hash !== -1) { |
||||
ret.hash = rest.substr(hash); |
||||
rest = rest.slice(0, hash); |
||||
} |
||||
var queryMark = rest.indexOf('?'); |
||||
if (queryMark !== -1) { |
||||
ret.query = query.parse(rest.substr(queryMark + 1)); |
||||
rest = rest.slice(0, queryMark); |
||||
} |
||||
ret.pathname = rest || '/'; |
||||
return ret; |
||||
}, |
||||
stringify: function(obj) { |
||||
var ret = |
||||
obj.protocol + |
||||
(obj.slashes ? '//' : '') + |
||||
(obj.auth ? encodeURIComponent(obj.auth) + '@' : '') + |
||||
obj.hostname + |
||||
(obj.port ? ':' + obj.port : '') + |
||||
obj.pathname; |
||||
if (!isEmpty(obj.query)) ret += '?' + query.stringify(obj.query); |
||||
if (obj.hash) ret += obj.hash; |
||||
return ret; |
||||
} |
||||
} |
||||
); |
||||
var regProto = /^([a-z0-9.+-]+:)/i; |
||||
var regPort = /:[0-9]*$/; |
||||
var hostEndingChars = ['/', '?', '#']; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,82 @@
@@ -0,0 +1,82 @@
|
||||
var Class = require('./Class'); |
||||
var keys = require('./keys'); |
||||
var safeGet = require('./safeGet'); |
||||
var isFn = require('./isFn'); |
||||
var isUndef = require('./isUndef'); |
||||
var isNum = require('./isNum'); |
||||
var isStr = require('./isStr'); |
||||
var isBool = require('./isBool'); |
||||
exports = Class( |
||||
{ |
||||
className: 'Validator', |
||||
initialize: function(options) { |
||||
this._options = options; |
||||
this._optKeys = keys(options); |
||||
}, |
||||
validate: function(obj) { |
||||
obj = obj || {}; |
||||
var options = this._options; |
||||
var objKeys = this._optKeys; |
||||
for (var i = 0, len = objKeys.length; i < len; i++) { |
||||
var key = objKeys[i]; |
||||
var result = this._validateVal( |
||||
safeGet(obj, key), |
||||
options[key], |
||||
key |
||||
); |
||||
if (result !== true) return result; |
||||
} |
||||
return true; |
||||
}, |
||||
_validateVal: function(val, rules, objKey) { |
||||
var plugins = exports.plugins; |
||||
if (isFn(rules)) return rules(val); |
||||
var ruleKeys = keys(rules); |
||||
for (var i = 0, len = ruleKeys.length; i < len; i++) { |
||||
var key = ruleKeys[i]; |
||||
var config = rules[key]; |
||||
var result = true; |
||||
if (isFn(config)) result = config(val, objKey); |
||||
var plugin = plugins[key]; |
||||
if (plugin) result = plugin(val, objKey, config); |
||||
if (result !== true) return result; |
||||
} |
||||
return true; |
||||
} |
||||
}, |
||||
{ |
||||
plugins: { |
||||
required: function(val, key, config) { |
||||
if (config && isUndef(val)) return key + ' is required'; |
||||
return true; |
||||
}, |
||||
number: function(val, key, config) { |
||||
if (config && !isUndef(val) && !isNum(val)) |
||||
return key + ' should be a number'; |
||||
return true; |
||||
}, |
||||
boolean: function(val, key, config) { |
||||
if (config && !isUndef(val) && !isBool(val)) |
||||
return key + ' should be a boolean'; |
||||
return true; |
||||
}, |
||||
string: function(val, key, config) { |
||||
if (config && !isUndef(val) && !isStr(val)) |
||||
return key + ' should be a string'; |
||||
return true; |
||||
}, |
||||
regexp: function(val, key, config) { |
||||
if (isStr(val) && !config.test(val)) |
||||
return ( |
||||
key + ' should match given regexp ' + config.toString() |
||||
); |
||||
return true; |
||||
} |
||||
}, |
||||
addPlugin: function(name, plugin) { |
||||
exports.plugins[name] = plugin; |
||||
} |
||||
} |
||||
); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,86 @@
@@ -0,0 +1,86 @@
|
||||
var Class = require('./Class'); |
||||
var max = require('./max'); |
||||
var map = require('./map'); |
||||
var reduce = require('./reduce'); |
||||
var gcd = require('./gcd'); |
||||
var filter = require('./filter'); |
||||
exports = Class({ |
||||
initialize: function Wrr() { |
||||
this._peers = []; |
||||
}, |
||||
set: function(val, weight) { |
||||
var peers = this._peers; |
||||
var size = this.size; |
||||
for (var i = 0; i < size; i++) { |
||||
var peer = peers[i]; |
||||
if (peer.val === val) { |
||||
peer.weight = weight; |
||||
this._reset(); |
||||
return; |
||||
} |
||||
} |
||||
peers.push({ |
||||
val: val, |
||||
weight: weight |
||||
}); |
||||
this._reset(); |
||||
}, |
||||
get: function(val) { |
||||
var peers = this._peers; |
||||
var size = this.size; |
||||
for (var i = 0; i < size; i++) { |
||||
var peer = peers[i]; |
||||
if (peer.val === val) { |
||||
return peer.weight; |
||||
} |
||||
} |
||||
}, |
||||
remove: function(val) { |
||||
this._peers = filter(this._peers, function(peer) { |
||||
return peer.val !== val; |
||||
}); |
||||
this._reset(); |
||||
}, |
||||
next: function() { |
||||
var peers = this._peers; |
||||
var size = this.size; |
||||
if (size === 0) return; |
||||
|
||||
while (true) { |
||||
this._i = (this._i + 1) % size; |
||||
if (this._i === 0) { |
||||
this._cw = this._cw - this._gcdS; |
||||
if (this._cw <= 0) { |
||||
this._cw = this._maxS; |
||||
} |
||||
} |
||||
if (this._cw === 0) return; |
||||
if (peers[this._i].weight >= this._cw) { |
||||
return peers[this._i].val; |
||||
} |
||||
} |
||||
}, |
||||
clear: function() { |
||||
this._peers = []; |
||||
this._reset(); |
||||
}, |
||||
_reset: function() { |
||||
var peers = this._peers; |
||||
this.size = peers.length; |
||||
var weights = map(peers, function(peer) { |
||||
return peer.weight; |
||||
}); |
||||
this._i = -1; |
||||
this._cw = 0; |
||||
this._maxS = max.apply(null, weights); |
||||
this._gcdS = reduce( |
||||
weights, |
||||
function(prev, weight) { |
||||
return gcd(prev, weight); |
||||
}, |
||||
0 |
||||
); |
||||
} |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,28 @@
@@ -0,0 +1,28 @@
|
||||
var restArgs = require('./restArgs'); |
||||
var isSorted = require('./isSorted'); |
||||
exports = restArgs(function(names) { |
||||
names = names.sort(isSorted.defComparator); |
||||
var ret = {}; |
||||
var idleMap = {}; |
||||
for (var i = 0, len = names.length; i < len; i++) { |
||||
var str = names[i]; |
||||
var nextStr = names[i + 1] || ''; |
||||
if (str === nextStr) continue; |
||||
var start = false; |
||||
var abbrev = ''; |
||||
for (var j = 0, strLen = str.length; j < strLen; j++) { |
||||
abbrev += str[j]; |
||||
if (!start && (str[j] !== nextStr[j] || j === strLen - 1)) { |
||||
start = true; |
||||
} |
||||
if (!start) { |
||||
idleMap[abbrev] = str; |
||||
} else if (!ret[abbrev] && !idleMap[abbrev]) { |
||||
ret[abbrev] = str; |
||||
} |
||||
} |
||||
} |
||||
return ret; |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,7 @@
@@ -0,0 +1,7 @@
|
||||
exports = function(n, fn) { |
||||
return function() { |
||||
if (--n < 1) return fn.apply(this, arguments); |
||||
}; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,42 @@
@@ -0,0 +1,42 @@
|
||||
var keys = require('./keys'); |
||||
var getProto = require('./getProto'); |
||||
var unique = require('./unique'); |
||||
var getOwnPropertyNames = Object.getOwnPropertyNames; |
||||
var getOwnPropertySymbols = Object.getOwnPropertySymbols; |
||||
exports = function(obj) { |
||||
var _ref = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: {}, |
||||
_ref$prototype = _ref.prototype, |
||||
prototype = _ref$prototype === void 0 ? true : _ref$prototype, |
||||
_ref$unenumerable = _ref.unenumerable, |
||||
unenumerable = _ref$unenumerable === void 0 ? false : _ref$unenumerable, |
||||
_ref$symbol = _ref.symbol, |
||||
symbol = _ref$symbol === void 0 ? false : _ref$symbol; |
||||
var ret = []; |
||||
if ((unenumerable || symbol) && getOwnPropertyNames) { |
||||
var getKeys = keys; |
||||
if (unenumerable && getOwnPropertyNames) getKeys = getOwnPropertyNames; |
||||
do { |
||||
ret = ret.concat(getKeys(obj)); |
||||
if (symbol && getOwnPropertySymbols) { |
||||
ret = ret.concat(getOwnPropertySymbols(obj)); |
||||
} |
||||
} while ( |
||||
prototype && |
||||
(obj = getProto(obj)) && |
||||
obj !== Object.prototype |
||||
); |
||||
ret = unique(ret); |
||||
} else { |
||||
if (prototype) { |
||||
for (var key in obj) ret.push(key); |
||||
} else { |
||||
ret = keys(obj); |
||||
} |
||||
} |
||||
return ret; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,14 @@
@@ -0,0 +1,14 @@
|
||||
var each = require('./each'); |
||||
var isUndef = require('./isUndef'); |
||||
var isFn = require('./isFn'); |
||||
exports = function(arr, val) { |
||||
if (isUndef(val)) val = true; |
||||
var _isFn = isFn(val); |
||||
var ret = {}; |
||||
each(arr, function(key) { |
||||
ret[key] = _isFn ? val(key) : val; |
||||
}); |
||||
return ret; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,21 @@
@@ -0,0 +1,21 @@
|
||||
var root = require('./root'); |
||||
var isNode = require('./isNode'); |
||||
var base64 = require('./base64'); |
||||
var map = require('./map'); |
||||
if (isNode) { |
||||
exports = function(str) { |
||||
return new Buffer(str, 'base64').toString('binary'); |
||||
}; |
||||
} else { |
||||
if (root.atob && !false) { |
||||
exports = root.atob; |
||||
} else { |
||||
exports = function(str) { |
||||
return map(base64.decode(str), function(c) { |
||||
return String.fromCharCode(c); |
||||
}).join(''); |
||||
}; |
||||
} |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,9 @@
@@ -0,0 +1,9 @@
|
||||
exports = function() { |
||||
var arr = arguments; |
||||
var sum = 0; |
||||
var len = arr.length; |
||||
for (var i = 0; i < len; i++) sum += arr[i]; |
||||
return sum / len; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,83 @@
@@ -0,0 +1,83 @@
|
||||
exports = { |
||||
encode: function(bytes) { |
||||
var ret = []; |
||||
var len = bytes.length; |
||||
var remain = len % 3; |
||||
len = len - remain; |
||||
for (var i = 0; i < len; i += 3) { |
||||
ret.push( |
||||
numToBase64( |
||||
(bytes[i] << 16) + (bytes[i + 1] << 8) + bytes[i + 2] |
||||
) |
||||
); |
||||
} |
||||
len = bytes.length; |
||||
var tmp; |
||||
if (remain === 1) { |
||||
tmp = bytes[len - 1]; |
||||
ret.push(code[tmp >> 2]); |
||||
ret.push(code[(tmp << 4) & 0x3f]); |
||||
ret.push('=='); |
||||
} else if (remain === 2) { |
||||
tmp = (bytes[len - 2] << 8) + bytes[len - 1]; |
||||
ret.push(code[tmp >> 10]); |
||||
ret.push(code[(tmp >> 4) & 0x3f]); |
||||
ret.push(code[(tmp << 2) & 0x3f]); |
||||
ret.push('='); |
||||
} |
||||
return ret.join(''); |
||||
}, |
||||
decode: function(str) { |
||||
var len = str.length, |
||||
remain = 0; |
||||
if (str[len - 2] === '=') remain = 2; |
||||
else if (str[len - 1] === '=') remain = 1; |
||||
var ret = new Array((len * 3) / 4 - remain); |
||||
len = remain > 0 ? len - 4 : len; |
||||
var i, j; |
||||
for (i = 0, j = 0; i < len; i += 4) { |
||||
var num = base64ToNum(str[i], str[i + 1], str[i + 2], str[i + 3]); |
||||
ret[j++] = (num >> 16) & 0xff; |
||||
ret[j++] = (num >> 8) & 0xff; |
||||
ret[j++] = num & 0xff; |
||||
} |
||||
var tmp; |
||||
if (remain === 2) { |
||||
tmp = |
||||
(codeMap[str.charCodeAt(i)] << 2) | |
||||
(codeMap[str.charCodeAt(i + 1)] >> 4); |
||||
ret[j++] = tmp & 0xff; |
||||
} else if (remain === 1) { |
||||
tmp = |
||||
(codeMap[str.charCodeAt(i)] << 10) | |
||||
(codeMap[str.charCodeAt(i + 1)] << 4) | |
||||
(codeMap[str.charCodeAt(i + 2)] >> 2); |
||||
ret[j++] = (tmp >> 8) & 0xff; |
||||
ret[j++] = tmp & 0xff; |
||||
} |
||||
return ret; |
||||
} |
||||
}; |
||||
var codeMap = []; |
||||
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; |
||||
for (var i = 0, len = code.length; i < len; i++) { |
||||
codeMap[code.charCodeAt(i)] = i; |
||||
} |
||||
function numToBase64(num) { |
||||
return ( |
||||
code[(num >> 18) & 0x3f] + |
||||
code[(num >> 12) & 0x3f] + |
||||
code[(num >> 6) & 0x3f] + |
||||
code[num & 0x3f] |
||||
); |
||||
} |
||||
function base64ToNum(str1, str2, str3, str4) { |
||||
return ( |
||||
(codeMap[str1.charCodeAt(0)] << 18) | |
||||
(codeMap[str2.charCodeAt(0)] << 12) | |
||||
(codeMap[str3.charCodeAt(0)] << 6) | |
||||
codeMap[str4.charCodeAt(0)] |
||||
); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,10 @@
@@ -0,0 +1,10 @@
|
||||
exports = function(n, fn) { |
||||
var memo; |
||||
return function() { |
||||
if (--n > 0) memo = fn.apply(this, arguments); |
||||
if (n <= 1) fn = null; |
||||
return memo; |
||||
}; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,24 @@
@@ -0,0 +1,24 @@
|
||||
var isSorted = require('./isSorted'); |
||||
exports = function(arr, val) { |
||||
var cmp = |
||||
arguments.length > 2 && arguments[2] !== undefined |
||||
? arguments[2] |
||||
: isSorted.defComparator; |
||||
var startIdx = 0; |
||||
var endIdx = arr.length - 1; |
||||
while (startIdx <= endIdx) { |
||||
var middleIdx = startIdx + Math.floor((endIdx - startIdx) / 2); |
||||
var middleVal = arr[middleIdx]; |
||||
if (cmp(middleVal, val) === 0) { |
||||
return middleIdx; |
||||
} |
||||
if (cmp(middleVal, val) < 0) { |
||||
startIdx = middleIdx + 1; |
||||
} else { |
||||
endIdx = middleIdx - 1; |
||||
} |
||||
} |
||||
return -1; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,8 @@
@@ -0,0 +1,8 @@
|
||||
var restArgs = require('./restArgs'); |
||||
exports = restArgs(function(fn, ctx, args) { |
||||
return restArgs(function(callArgs) { |
||||
return fn.apply(ctx, args.concat(callArgs)); |
||||
}); |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,23 @@
@@ -0,0 +1,23 @@
|
||||
var root = require('./root'); |
||||
var isNode = require('./isNode'); |
||||
var base64 = require('./base64'); |
||||
var map = require('./map'); |
||||
if (isNode) { |
||||
exports = function(str) { |
||||
return new Buffer(str, 'binary').toString('base64'); |
||||
}; |
||||
} else { |
||||
if (root.btoa && !false) { |
||||
exports = root.btoa; |
||||
} else { |
||||
exports = function(str) { |
||||
return base64.encode( |
||||
map(str, function(c) { |
||||
return c.charCodeAt(0); |
||||
}) |
||||
); |
||||
}; |
||||
} |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
var swap = require('./swap'); |
||||
var isSorted = require('./isSorted'); |
||||
exports = function(arr) { |
||||
var cmp = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: isSorted.defComparator; |
||||
for (var i = 0, len = arr.length; i < len; i++) { |
||||
for (var j = i; j > 0; j--) { |
||||
if (cmp(arr[j], arr[j - 1]) < 0) { |
||||
swap(arr, j, j - 1); |
||||
} |
||||
} |
||||
} |
||||
return arr; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,22 @@
@@ -0,0 +1,22 @@
|
||||
var utf8 = require('./utf8'); |
||||
var hex = require('./hex'); |
||||
var base64 = require('./base64'); |
||||
exports = function(bytes) { |
||||
var encoding = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: 'utf8'; |
||||
if (encoding === 'hex') return hex.encode(bytes); |
||||
if (encoding === 'base64') return base64.encode(bytes); |
||||
var str = []; |
||||
for (var i = 0, len = bytes.length; i < len; i++) { |
||||
str.push(String.fromCharCode(bytes[i])); |
||||
} |
||||
str = str.join(''); |
||||
if (encoding === 'utf8') { |
||||
str = utf8.decode(str); |
||||
} |
||||
return str; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,9 @@
@@ -0,0 +1,9 @@
|
||||
exports = function(bytes) { |
||||
var words = []; |
||||
for (var i = 0, len = bytes.length; i < len; i++) { |
||||
words[i >>> 2] |= bytes[i] << (24 - (i % 4) * 8); |
||||
} |
||||
return words; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,17 @@
@@ -0,0 +1,17 @@
|
||||
var restArgs = require('./restArgs'); |
||||
exports = function(fn) { |
||||
return restArgs(function(args) { |
||||
var cb = args.pop(); |
||||
fn.apply(this, args).then( |
||||
function(value) { |
||||
cb(null, value); |
||||
}, |
||||
function(err) { |
||||
if (err === null) err = new Error(); |
||||
cb(err); |
||||
} |
||||
); |
||||
}); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,16 @@
@@ -0,0 +1,16 @@
|
||||
var splitCase = require('./splitCase'); |
||||
exports = function(str) { |
||||
var arr = splitCase(str); |
||||
var ret = arr[0]; |
||||
arr.shift(); |
||||
arr.forEach(capitalize, arr); |
||||
ret += arr.join(''); |
||||
return ret; |
||||
}; |
||||
function capitalize(val, idx) { |
||||
this[idx] = val.replace(/\w/, function(match) { |
||||
return match.toUpperCase(); |
||||
}); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,5 @@
@@ -0,0 +1,5 @@
|
||||
exports = function(str) { |
||||
return str.charAt(0).toUpperCase() + str.substring(1).toLowerCase(); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,16 @@
@@ -0,0 +1,16 @@
|
||||
var has = require('./has'); |
||||
var isArr = require('./isArr'); |
||||
exports = function(str, obj) { |
||||
if (isArr(str)) return str; |
||||
if (obj && has(obj, str)) return [str]; |
||||
var ret = []; |
||||
str.replace(regPropName, function(match, number, quote, str) { |
||||
ret.push(quote ? str.replace(regEscapeChar, '$1') : number || match); |
||||
}); |
||||
return ret; |
||||
}; |
||||
|
||||
var regPropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; |
||||
var regEscapeChar = /\\(\\)?/g; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,21 @@
@@ -0,0 +1,21 @@
|
||||
var longest = require('./longest'); |
||||
var isArr = require('./isArr'); |
||||
var isUndef = require('./isUndef'); |
||||
var map = require('./map'); |
||||
var lpad = require('./lpad'); |
||||
exports = function(str, width) { |
||||
var ret = str; |
||||
if (!isArr(ret)) { |
||||
ret = ret.split(regLineBreak); |
||||
} |
||||
if (isUndef(width)) width = longest(str); |
||||
ret = map(ret, function(str) { |
||||
var len = str.length; |
||||
return lpad(str, floor((width - len) / 2) + len); |
||||
}); |
||||
return ret.join('\n'); |
||||
}; |
||||
var regLineBreak = /\n/g; |
||||
var floor = Math.floor; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,5 @@
@@ -0,0 +1,5 @@
|
||||
exports = function(num) { |
||||
return String.fromCodePoint(num); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,12 @@
@@ -0,0 +1,12 @@
|
||||
exports = function(arr, size) { |
||||
var ret = []; |
||||
size = size || 1; |
||||
for (var i = 0, len = Math.ceil(arr.length / size); i < len; i++) { |
||||
var start = i * size; |
||||
var end = start + size; |
||||
ret.push(arr.slice(start, end)); |
||||
} |
||||
return ret; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,12 @@
@@ -0,0 +1,12 @@
|
||||
var isUndef = require('./isUndef'); |
||||
exports = function(n, lower, upper) { |
||||
if (isUndef(upper)) { |
||||
upper = lower; |
||||
lower = undefined; |
||||
} |
||||
if (!isUndef(lower) && n < lower) return lower; |
||||
if (n > upper) return upper; |
||||
return n; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,20 @@
@@ -0,0 +1,20 @@
|
||||
var each = require('./each'); |
||||
var isStr = require('./isStr'); |
||||
var isNum = require('./isNum'); |
||||
var isArr = require('./isArr'); |
||||
var isObj = require('./isObj'); |
||||
exports = function() { |
||||
var ret = []; |
||||
each(arguments, function(arg) { |
||||
if (!arg) return; |
||||
if (isStr(arg) || isNum(arg)) return ret.push(arg); |
||||
if (isArr(arg)) return ret.push(exports.apply(null, arg)); |
||||
if (!isObj(arg)) return; |
||||
each(arg, function(val, key) { |
||||
if (val) ret.push(key); |
||||
}); |
||||
}); |
||||
return ret.join(' '); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,9 @@
@@ -0,0 +1,9 @@
|
||||
var isObj = require('./isObj'); |
||||
var isArr = require('./isArr'); |
||||
var extend = require('./extend'); |
||||
exports = function(obj) { |
||||
if (!isObj(obj)) return obj; |
||||
return isArr(obj) ? obj.slice() : extend({}, obj); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
var isObj = require('./isObj'); |
||||
var isFn = require('./isFn'); |
||||
var isArr = require('./isArr'); |
||||
var mapObj = require('./mapObj'); |
||||
exports = function(obj) { |
||||
if (isArr(obj)) { |
||||
return obj.map(function(val) { |
||||
return exports(val); |
||||
}); |
||||
} |
||||
if (isObj(obj) && !isFn(obj)) { |
||||
return mapObj(obj, function(val) { |
||||
return exports(val); |
||||
}); |
||||
} |
||||
return obj; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,16 @@
@@ -0,0 +1,16 @@
|
||||
var toInt = require('./toInt'); |
||||
var max = require('./max'); |
||||
exports = function(v1, v2) { |
||||
v1 = v1.split('.'); |
||||
v2 = v2.split('.'); |
||||
var len = max(v1.length, v2.length); |
||||
for (var i = 0; i < len; i++) { |
||||
var num1 = toInt(v1[i]); |
||||
var num2 = toInt(v2[i]); |
||||
if (num1 > num2) return 1; |
||||
if (num1 < num2) return -1; |
||||
} |
||||
return 0; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,9 @@
@@ -0,0 +1,9 @@
|
||||
exports = function(keys, values) { |
||||
var ret = {}; |
||||
for (var i = 0, len = keys.length; i < len; i++) { |
||||
ret[keys[i]] = values[i]; |
||||
} |
||||
return ret; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,8 @@
@@ -0,0 +1,8 @@
|
||||
var filter = require('./filter'); |
||||
exports = function(arr) { |
||||
return filter(arr, function(val) { |
||||
return !!val; |
||||
}); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,11 @@
@@ -0,0 +1,11 @@
|
||||
var restArgs = require('./restArgs'); |
||||
exports = restArgs(function(fnList) { |
||||
return function() { |
||||
var i = fnList.length - 1; |
||||
var result = fnList[i].apply(this, arguments); |
||||
while (i--) result = fnList[i].call(this, result); |
||||
return result; |
||||
}; |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,11 @@
@@ -0,0 +1,11 @@
|
||||
var toArr = require('./toArr'); |
||||
exports = function() { |
||||
var args = toArr(arguments); |
||||
var ret = []; |
||||
for (var i = 0, len = args.length; i < len; i++) { |
||||
ret = ret.concat(toArr(args[i])); |
||||
} |
||||
return ret; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,11 @@
@@ -0,0 +1,11 @@
|
||||
var idxOf = require('./idxOf'); |
||||
var isStr = require('./isStr'); |
||||
var isArrLike = require('./isArrLike'); |
||||
var values = require('./values'); |
||||
exports = function(arr, val) { |
||||
if (isStr(arr)) return arr.indexOf(val) > -1; |
||||
if (!isArrLike(arr)) arr = values(arr); |
||||
return idxOf(arr, val) >= 0; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,5 @@
@@ -0,0 +1,5 @@
|
||||
exports = function(num, from, to) { |
||||
return parseInt(num, from).toString(to); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,60 @@
@@ -0,0 +1,60 @@
|
||||
var isStr = require('./isStr'); |
||||
var base64 = require('./base64'); |
||||
var isArrBuffer = require('./isArrBuffer'); |
||||
var isArr = require('./isArr'); |
||||
var isBuffer = require('./isBuffer'); |
||||
var type = require('./type'); |
||||
var lowerCase = require('./lowerCase'); |
||||
exports = function(bin, t) { |
||||
var result; |
||||
t = lowerCase(t); |
||||
if (isStr(bin)) { |
||||
result = new Uint8Array(base64.decode(bin)); |
||||
} else if (isArrBuffer(bin)) { |
||||
bin = bin.slice(0); |
||||
result = new Uint8Array(bin); |
||||
} else if (isArr(bin)) { |
||||
result = new Uint8Array(bin); |
||||
} else if (type(bin) === 'uint8array') { |
||||
result = bin.slice(0); |
||||
} else if (isBuffer(bin)) { |
||||
result = new Uint8Array(bin.length); |
||||
for (var i = 0; i < bin.length; i++) { |
||||
result[i] = bin[i]; |
||||
} |
||||
} |
||||
if (result) { |
||||
switch (t) { |
||||
case 'base64': |
||||
result = base64.encode(result); |
||||
break; |
||||
case 'arraybuffer': |
||||
result = result.buffer; |
||||
break; |
||||
case 'array': |
||||
result = [].slice.call(result); |
||||
break; |
||||
case 'buffer': |
||||
result = Buffer.from(result); |
||||
break; |
||||
case 'blob': |
||||
result = new Blob([result.buffer]); |
||||
break; |
||||
} |
||||
} |
||||
return result; |
||||
}; |
||||
exports.blobToArrBuffer = function(blob) { |
||||
return new Promise(function(resolve, reject) { |
||||
var fileReader = new FileReader(); |
||||
fileReader.onload = function(e) { |
||||
resolve(e.target.result); |
||||
}; |
||||
fileReader.onerror = function(err) { |
||||
reject(err); |
||||
}; |
||||
fileReader.readAsArrayBuffer(blob); |
||||
}); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,19 @@
@@ -0,0 +1,19 @@
|
||||
var isStr = require('./isStr'); |
||||
var strToBytes = require('./strToBytes'); |
||||
|
||||
exports = function(input, previous) { |
||||
return exports.signed(input, previous) >>> 0; |
||||
}; |
||||
exports.signed = function(input, previous) { |
||||
if (isStr(input)) input = strToBytes(input); |
||||
var crc = ~~previous; |
||||
var accum = 0; |
||||
for (var i = 0, len = input.length; i < len; i++) { |
||||
var byte = input[i]; |
||||
accum += byte; |
||||
} |
||||
crc += accum % 256; |
||||
return crc % 256; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,276 @@
@@ -0,0 +1,276 @@
|
||||
var isStr = require('./isStr'); |
||||
var strToBytes = require('./strToBytes'); |
||||
|
||||
var TABLE = [ |
||||
0x0000, |
||||
0xc0c1, |
||||
0xc181, |
||||
0x0140, |
||||
0xc301, |
||||
0x03c0, |
||||
0x0280, |
||||
0xc241, |
||||
0xc601, |
||||
0x06c0, |
||||
0x0780, |
||||
0xc741, |
||||
0x0500, |
||||
0xc5c1, |
||||
0xc481, |
||||
0x0440, |
||||
0xcc01, |
||||
0x0cc0, |
||||
0x0d80, |
||||
0xcd41, |
||||
0x0f00, |
||||
0xcfc1, |
||||
0xce81, |
||||
0x0e40, |
||||
0x0a00, |
||||
0xcac1, |
||||
0xcb81, |
||||
0x0b40, |
||||
0xc901, |
||||
0x09c0, |
||||
0x0880, |
||||
0xc841, |
||||
0xd801, |
||||
0x18c0, |
||||
0x1980, |
||||
0xd941, |
||||
0x1b00, |
||||
0xdbc1, |
||||
0xda81, |
||||
0x1a40, |
||||
0x1e00, |
||||
0xdec1, |
||||
0xdf81, |
||||
0x1f40, |
||||
0xdd01, |
||||
0x1dc0, |
||||
0x1c80, |
||||
0xdc41, |
||||
0x1400, |
||||
0xd4c1, |
||||
0xd581, |
||||
0x1540, |
||||
0xd701, |
||||
0x17c0, |
||||
0x1680, |
||||
0xd641, |
||||
0xd201, |
||||
0x12c0, |
||||
0x1380, |
||||
0xd341, |
||||
0x1100, |
||||
0xd1c1, |
||||
0xd081, |
||||
0x1040, |
||||
0xf001, |
||||
0x30c0, |
||||
0x3180, |
||||
0xf141, |
||||
0x3300, |
||||
0xf3c1, |
||||
0xf281, |
||||
0x3240, |
||||
0x3600, |
||||
0xf6c1, |
||||
0xf781, |
||||
0x3740, |
||||
0xf501, |
||||
0x35c0, |
||||
0x3480, |
||||
0xf441, |
||||
0x3c00, |
||||
0xfcc1, |
||||
0xfd81, |
||||
0x3d40, |
||||
0xff01, |
||||
0x3fc0, |
||||
0x3e80, |
||||
0xfe41, |
||||
0xfa01, |
||||
0x3ac0, |
||||
0x3b80, |
||||
0xfb41, |
||||
0x3900, |
||||
0xf9c1, |
||||
0xf881, |
||||
0x3840, |
||||
0x2800, |
||||
0xe8c1, |
||||
0xe981, |
||||
0x2940, |
||||
0xeb01, |
||||
0x2bc0, |
||||
0x2a80, |
||||
0xea41, |
||||
0xee01, |
||||
0x2ec0, |
||||
0x2f80, |
||||
0xef41, |
||||
0x2d00, |
||||
0xedc1, |
||||
0xec81, |
||||
0x2c40, |
||||
0xe401, |
||||
0x24c0, |
||||
0x2580, |
||||
0xe541, |
||||
0x2700, |
||||
0xe7c1, |
||||
0xe681, |
||||
0x2640, |
||||
0x2200, |
||||
0xe2c1, |
||||
0xe381, |
||||
0x2340, |
||||
0xe101, |
||||
0x21c0, |
||||
0x2080, |
||||
0xe041, |
||||
0xa001, |
||||
0x60c0, |
||||
0x6180, |
||||
0xa141, |
||||
0x6300, |
||||
0xa3c1, |
||||
0xa281, |
||||
0x6240, |
||||
0x6600, |
||||
0xa6c1, |
||||
0xa781, |
||||
0x6740, |
||||
0xa501, |
||||
0x65c0, |
||||
0x6480, |
||||
0xa441, |
||||
0x6c00, |
||||
0xacc1, |
||||
0xad81, |
||||
0x6d40, |
||||
0xaf01, |
||||
0x6fc0, |
||||
0x6e80, |
||||
0xae41, |
||||
0xaa01, |
||||
0x6ac0, |
||||
0x6b80, |
||||
0xab41, |
||||
0x6900, |
||||
0xa9c1, |
||||
0xa881, |
||||
0x6840, |
||||
0x7800, |
||||
0xb8c1, |
||||
0xb981, |
||||
0x7940, |
||||
0xbb01, |
||||
0x7bc0, |
||||
0x7a80, |
||||
0xba41, |
||||
0xbe01, |
||||
0x7ec0, |
||||
0x7f80, |
||||
0xbf41, |
||||
0x7d00, |
||||
0xbdc1, |
||||
0xbc81, |
||||
0x7c40, |
||||
0xb401, |
||||
0x74c0, |
||||
0x7580, |
||||
0xb541, |
||||
0x7700, |
||||
0xb7c1, |
||||
0xb681, |
||||
0x7640, |
||||
0x7200, |
||||
0xb2c1, |
||||
0xb381, |
||||
0x7340, |
||||
0xb101, |
||||
0x71c0, |
||||
0x7080, |
||||
0xb041, |
||||
0x5000, |
||||
0x90c1, |
||||
0x9181, |
||||
0x5140, |
||||
0x9301, |
||||
0x53c0, |
||||
0x5280, |
||||
0x9241, |
||||
0x9601, |
||||
0x56c0, |
||||
0x5780, |
||||
0x9741, |
||||
0x5500, |
||||
0x95c1, |
||||
0x9481, |
||||
0x5440, |
||||
0x9c01, |
||||
0x5cc0, |
||||
0x5d80, |
||||
0x9d41, |
||||
0x5f00, |
||||
0x9fc1, |
||||
0x9e81, |
||||
0x5e40, |
||||
0x5a00, |
||||
0x9ac1, |
||||
0x9b81, |
||||
0x5b40, |
||||
0x9901, |
||||
0x59c0, |
||||
0x5880, |
||||
0x9841, |
||||
0x8801, |
||||
0x48c0, |
||||
0x4980, |
||||
0x8941, |
||||
0x4b00, |
||||
0x8bc1, |
||||
0x8a81, |
||||
0x4a40, |
||||
0x4e00, |
||||
0x8ec1, |
||||
0x8f81, |
||||
0x4f40, |
||||
0x8d01, |
||||
0x4dc0, |
||||
0x4c80, |
||||
0x8c41, |
||||
0x4400, |
||||
0x84c1, |
||||
0x8581, |
||||
0x4540, |
||||
0x8701, |
||||
0x47c0, |
||||
0x4680, |
||||
0x8641, |
||||
0x8201, |
||||
0x42c0, |
||||
0x4380, |
||||
0x8341, |
||||
0x4100, |
||||
0x81c1, |
||||
0x8081, |
||||
0x4040 |
||||
]; |
||||
if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); |
||||
exports = function(input, previous) { |
||||
return exports.signed(input, previous) >>> 0; |
||||
}; |
||||
exports.signed = function(input, previous) { |
||||
if (isStr(input)) input = strToBytes(input); |
||||
var crc = ~~previous; |
||||
for (var i = 0, len = input.length; i < len; i++) { |
||||
var byte = input[i]; |
||||
crc = (TABLE[(crc ^ byte) & 0xff] ^ (crc >> 8)) & 0xffff; |
||||
} |
||||
return crc; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,29 @@
@@ -0,0 +1,29 @@
|
||||
var isStr = require('./isStr'); |
||||
var strToBytes = require('./strToBytes'); |
||||
var TABLE = []; |
||||
for (var n = 0; n < 256; n++) { |
||||
var c = n; |
||||
for (var k = 0; k < 8; k++) { |
||||
if (c & 1) { |
||||
c = 0xedb88320 ^ (c >>> 1); |
||||
} else { |
||||
c = c >>> 1; |
||||
} |
||||
} |
||||
TABLE[n] = c >>> 0; |
||||
} |
||||
if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); |
||||
exports = function(input, previous) { |
||||
return exports.signed(input, previous) >>> 0; |
||||
}; |
||||
exports.signed = function(input, previous) { |
||||
if (isStr(input)) input = strToBytes(input); |
||||
var crc = previous === 0 ? 0 : ~~previous ^ -1; |
||||
for (var i = 0, len = input.length; i < len; i++) { |
||||
var byte = input[i]; |
||||
crc = TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8); |
||||
} |
||||
return crc ^ -1; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,276 @@
@@ -0,0 +1,276 @@
|
||||
var isStr = require('./isStr'); |
||||
var strToBytes = require('./strToBytes'); |
||||
|
||||
var TABLE = [ |
||||
0x00, |
||||
0x07, |
||||
0x0e, |
||||
0x09, |
||||
0x1c, |
||||
0x1b, |
||||
0x12, |
||||
0x15, |
||||
0x38, |
||||
0x3f, |
||||
0x36, |
||||
0x31, |
||||
0x24, |
||||
0x23, |
||||
0x2a, |
||||
0x2d, |
||||
0x70, |
||||
0x77, |
||||
0x7e, |
||||
0x79, |
||||
0x6c, |
||||
0x6b, |
||||
0x62, |
||||
0x65, |
||||
0x48, |
||||
0x4f, |
||||
0x46, |
||||
0x41, |
||||
0x54, |
||||
0x53, |
||||
0x5a, |
||||
0x5d, |
||||
0xe0, |
||||
0xe7, |
||||
0xee, |
||||
0xe9, |
||||
0xfc, |
||||
0xfb, |
||||
0xf2, |
||||
0xf5, |
||||
0xd8, |
||||
0xdf, |
||||
0xd6, |
||||
0xd1, |
||||
0xc4, |
||||
0xc3, |
||||
0xca, |
||||
0xcd, |
||||
0x90, |
||||
0x97, |
||||
0x9e, |
||||
0x99, |
||||
0x8c, |
||||
0x8b, |
||||
0x82, |
||||
0x85, |
||||
0xa8, |
||||
0xaf, |
||||
0xa6, |
||||
0xa1, |
||||
0xb4, |
||||
0xb3, |
||||
0xba, |
||||
0xbd, |
||||
0xc7, |
||||
0xc0, |
||||
0xc9, |
||||
0xce, |
||||
0xdb, |
||||
0xdc, |
||||
0xd5, |
||||
0xd2, |
||||
0xff, |
||||
0xf8, |
||||
0xf1, |
||||
0xf6, |
||||
0xe3, |
||||
0xe4, |
||||
0xed, |
||||
0xea, |
||||
0xb7, |
||||
0xb0, |
||||
0xb9, |
||||
0xbe, |
||||
0xab, |
||||
0xac, |
||||
0xa5, |
||||
0xa2, |
||||
0x8f, |
||||
0x88, |
||||
0x81, |
||||
0x86, |
||||
0x93, |
||||
0x94, |
||||
0x9d, |
||||
0x9a, |
||||
0x27, |
||||
0x20, |
||||
0x29, |
||||
0x2e, |
||||
0x3b, |
||||
0x3c, |
||||
0x35, |
||||
0x32, |
||||
0x1f, |
||||
0x18, |
||||
0x11, |
||||
0x16, |
||||
0x03, |
||||
0x04, |
||||
0x0d, |
||||
0x0a, |
||||
0x57, |
||||
0x50, |
||||
0x59, |
||||
0x5e, |
||||
0x4b, |
||||
0x4c, |
||||
0x45, |
||||
0x42, |
||||
0x6f, |
||||
0x68, |
||||
0x61, |
||||
0x66, |
||||
0x73, |
||||
0x74, |
||||
0x7d, |
||||
0x7a, |
||||
0x89, |
||||
0x8e, |
||||
0x87, |
||||
0x80, |
||||
0x95, |
||||
0x92, |
||||
0x9b, |
||||
0x9c, |
||||
0xb1, |
||||
0xb6, |
||||
0xbf, |
||||
0xb8, |
||||
0xad, |
||||
0xaa, |
||||
0xa3, |
||||
0xa4, |
||||
0xf9, |
||||
0xfe, |
||||
0xf7, |
||||
0xf0, |
||||
0xe5, |
||||
0xe2, |
||||
0xeb, |
||||
0xec, |
||||
0xc1, |
||||
0xc6, |
||||
0xcf, |
||||
0xc8, |
||||
0xdd, |
||||
0xda, |
||||
0xd3, |
||||
0xd4, |
||||
0x69, |
||||
0x6e, |
||||
0x67, |
||||
0x60, |
||||
0x75, |
||||
0x72, |
||||
0x7b, |
||||
0x7c, |
||||
0x51, |
||||
0x56, |
||||
0x5f, |
||||
0x58, |
||||
0x4d, |
||||
0x4a, |
||||
0x43, |
||||
0x44, |
||||
0x19, |
||||
0x1e, |
||||
0x17, |
||||
0x10, |
||||
0x05, |
||||
0x02, |
||||
0x0b, |
||||
0x0c, |
||||
0x21, |
||||
0x26, |
||||
0x2f, |
||||
0x28, |
||||
0x3d, |
||||
0x3a, |
||||
0x33, |
||||
0x34, |
||||
0x4e, |
||||
0x49, |
||||
0x40, |
||||
0x47, |
||||
0x52, |
||||
0x55, |
||||
0x5c, |
||||
0x5b, |
||||
0x76, |
||||
0x71, |
||||
0x78, |
||||
0x7f, |
||||
0x6a, |
||||
0x6d, |
||||
0x64, |
||||
0x63, |
||||
0x3e, |
||||
0x39, |
||||
0x30, |
||||
0x37, |
||||
0x22, |
||||
0x25, |
||||
0x2c, |
||||
0x2b, |
||||
0x06, |
||||
0x01, |
||||
0x08, |
||||
0x0f, |
||||
0x1a, |
||||
0x1d, |
||||
0x14, |
||||
0x13, |
||||
0xae, |
||||
0xa9, |
||||
0xa0, |
||||
0xa7, |
||||
0xb2, |
||||
0xb5, |
||||
0xbc, |
||||
0xbb, |
||||
0x96, |
||||
0x91, |
||||
0x98, |
||||
0x9f, |
||||
0x8a, |
||||
0x8d, |
||||
0x84, |
||||
0x83, |
||||
0xde, |
||||
0xd9, |
||||
0xd0, |
||||
0xd7, |
||||
0xc2, |
||||
0xc5, |
||||
0xcc, |
||||
0xcb, |
||||
0xe6, |
||||
0xe1, |
||||
0xe8, |
||||
0xef, |
||||
0xfa, |
||||
0xfd, |
||||
0xf4, |
||||
0xf3 |
||||
]; |
||||
if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE); |
||||
exports = function(input, previous) { |
||||
return exports.signed(input, previous) >>> 0; |
||||
}; |
||||
exports.signed = function(input, previous) { |
||||
if (isStr(input)) input = strToBytes(input); |
||||
var crc = ~~previous; |
||||
for (var i = 0, len = input.length; i < len; i++) { |
||||
var byte = input[i]; |
||||
crc = TABLE[(crc ^ byte) & 0xff] & 0xff; |
||||
} |
||||
return crc; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,11 @@
@@ -0,0 +1,11 @@
|
||||
var isObj = require('./isObj'); |
||||
exports = function(proto) { |
||||
if (!isObj(proto)) return {}; |
||||
if (objCreate && !false) return objCreate(proto); |
||||
function noop() {} |
||||
noop.prototype = proto; |
||||
return new noop(); |
||||
}; |
||||
var objCreate = Object.create; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,16 @@
@@ -0,0 +1,16 @@
|
||||
var isUndef = require('./isUndef'); |
||||
var each = require('./each'); |
||||
exports = function(keysFn, defaults) { |
||||
return function(obj) { |
||||
each(arguments, function(src, idx) { |
||||
if (idx === 0) return; |
||||
var keys = keysFn(src); |
||||
each(keys, function(key) { |
||||
if (!defaults || isUndef(obj[key])) obj[key] = src[key]; |
||||
}); |
||||
}); |
||||
return obj; |
||||
}; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,329 @@
@@ -0,0 +1,329 @@
|
||||
var Class = require('./Class'); |
||||
var trim = require('./trim'); |
||||
var repeat = require('./repeat'); |
||||
var defaults = require('./defaults'); |
||||
var camelCase = require('./camelCase'); |
||||
|
||||
exports = { |
||||
parse: function(css) { |
||||
return new Parser(css).parse(); |
||||
}, |
||||
stringify: function(stylesheet, options) { |
||||
return new Compiler(stylesheet, options).compile(); |
||||
} |
||||
}; |
||||
var regComments = /(\/\*[\s\S]*?\*\/)/gi; |
||||
var regOpen = /^{\s*/; |
||||
var regClose = /^}/; |
||||
var regWhitespace = /^\s*/; |
||||
var regProperty = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/; |
||||
var regValue = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/; |
||||
var regSelector = /^([^{]+)/; |
||||
var regSemicolon = /^[;\s]*/; |
||||
var regColon = /^:\s*/; |
||||
var regMedia = /^@media *([^{]+)/; |
||||
var regKeyframes = /^@([-\w]+)?keyframes\s*/; |
||||
var regFontFace = /^@font-face\s*/; |
||||
var regSupports = /^@supports *([^{]+)/; |
||||
var regIdentifier = /^([-\w]+)\s*/; |
||||
var regKeyframeSelector = /^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/; |
||||
var regComma = /^,\s*/; |
||||
var Parser = Class({ |
||||
initialize: function Parser(css) { |
||||
this.input = stripCmt(css); |
||||
this.open = this._createMatcher(regOpen); |
||||
this.close = this._createMatcher(regClose); |
||||
this.whitespace = this._createMatcher(regWhitespace); |
||||
this.atImport = this._createAtRule('import'); |
||||
this.atCharset = this._createAtRule('charset'); |
||||
this.atNamespace = this._createAtRule('namespace'); |
||||
}, |
||||
parse: function() { |
||||
return this.stylesheet(); |
||||
}, |
||||
stylesheet: function() { |
||||
return { |
||||
type: 'stylesheet', |
||||
rules: this.rules() |
||||
}; |
||||
}, |
||||
rules: function() { |
||||
var rule; |
||||
var rules = []; |
||||
this.whitespace(); |
||||
while ( |
||||
this.input.length && |
||||
this.input[0] !== '}' && |
||||
(rule = this.atRule() || this.rule()) |
||||
) { |
||||
rules.push(rule); |
||||
this.whitespace(); |
||||
} |
||||
return rules; |
||||
}, |
||||
atRule: function() { |
||||
if (this.input[0] !== '@') return; |
||||
return ( |
||||
this.atKeyframes() || |
||||
this.atMedia() || |
||||
this.atSupports() || |
||||
this.atImport() || |
||||
this.atCharset() || |
||||
this.atNamespace() || |
||||
this.atFontFace() |
||||
); |
||||
}, |
||||
atKeyframes: function() { |
||||
var matched = this.match(regKeyframes); |
||||
if (!matched) return; |
||||
var vendor = matched[1] || ''; |
||||
matched = this.match(regIdentifier); |
||||
if (!matched) throw Error('@keyframes missing name'); |
||||
var name = matched[1]; |
||||
if (!this.open()) throw Error("@keyframes missing '{'"); |
||||
var keyframes = []; |
||||
var keyframe; |
||||
while ((keyframe = this.keyframe())) { |
||||
keyframes.push(keyframe); |
||||
} |
||||
if (!this.close()) throw Error("@keyframes missing '}'"); |
||||
return { |
||||
type: 'keyframes', |
||||
name: name, |
||||
vendor: vendor, |
||||
keyframes: keyframes |
||||
}; |
||||
}, |
||||
keyframe: function() { |
||||
var selector = []; |
||||
var matched; |
||||
while ((matched = this.match(regKeyframeSelector))) { |
||||
selector.push(matched[1]); |
||||
this.match(regComma); |
||||
} |
||||
if (!selector.length) return; |
||||
this.whitespace(); |
||||
return { |
||||
type: 'keyframe', |
||||
selector: selector.join(', '), |
||||
declarations: this.declarations() |
||||
}; |
||||
}, |
||||
atSupports: function() { |
||||
var matched = this.match(regSupports); |
||||
if (!matched) return; |
||||
var supports = trim(matched[1]); |
||||
if (!this.open()) throw Error("@supports missing '{'"); |
||||
var rules = this.rules(); |
||||
if (!this.close()) throw Error("@supports missing '}'"); |
||||
return { |
||||
type: 'supports', |
||||
supports: supports, |
||||
rules: rules |
||||
}; |
||||
}, |
||||
atFontFace: function() { |
||||
var matched = this.match(regFontFace); |
||||
if (!matched) return; |
||||
if (!this.open()) throw Error("@font-face missing '{'"); |
||||
var declaration; |
||||
var declarations = []; |
||||
while ((declaration = this.declaration())) { |
||||
declarations.push(declaration); |
||||
} |
||||
if (!this.close()) throw Error("@font-face missing '}'"); |
||||
return { |
||||
type: 'font-face', |
||||
declarations: declarations |
||||
}; |
||||
}, |
||||
atMedia: function() { |
||||
var matched = this.match(regMedia); |
||||
if (!matched) return; |
||||
var media = trim(matched[1]); |
||||
if (!this.open()) throw Error("@media missing '{'"); |
||||
this.whitespace(); |
||||
var rules = this.rules(); |
||||
if (!this.close()) throw Error("@media missing '}'"); |
||||
return { |
||||
type: 'media', |
||||
media: media, |
||||
rules: rules |
||||
}; |
||||
}, |
||||
rule: function() { |
||||
var selector = this.selector(); |
||||
if (!selector) throw Error('missing selector'); |
||||
return { |
||||
type: 'rule', |
||||
selector: selector, |
||||
declarations: this.declarations() |
||||
}; |
||||
}, |
||||
declarations: function() { |
||||
var declarations = []; |
||||
if (!this.open()) throw Error("missing '{'"); |
||||
this.whitespace(); |
||||
var declaration; |
||||
while ((declaration = this.declaration())) { |
||||
declarations.push(declaration); |
||||
} |
||||
if (!this.close()) throw Error("missing '}'"); |
||||
this.whitespace(); |
||||
return declarations; |
||||
}, |
||||
declaration: function() { |
||||
var property = this.match(regProperty); |
||||
if (!property) return; |
||||
property = trim(property[0]); |
||||
if (!this.match(regColon)) throw Error("property missing ':'"); |
||||
var value = this.match(regValue); |
||||
this.match(regSemicolon); |
||||
this.whitespace(); |
||||
return { |
||||
type: 'declaration', |
||||
property: property, |
||||
value: value ? trim(value[0]) : '' |
||||
}; |
||||
}, |
||||
selector: function() { |
||||
var matched = this.match(regSelector); |
||||
if (!matched) return; |
||||
return trim(matched[0]); |
||||
}, |
||||
match: function(reg) { |
||||
var matched = reg.exec(this.input); |
||||
if (!matched) return; |
||||
this.input = this.input.slice(matched[0].length); |
||||
return matched; |
||||
}, |
||||
_createMatcher: function(reg) { |
||||
var _this = this; |
||||
return function() { |
||||
return _this.match(reg); |
||||
}; |
||||
}, |
||||
_createAtRule: function(name) { |
||||
var reg = new RegExp('^@' + name + '\\s*([^;]+);'); |
||||
return function() { |
||||
var matched = this.match(reg); |
||||
if (!matched) return; |
||||
var ret = { |
||||
type: name |
||||
}; |
||||
ret[name] = trim(matched[1]); |
||||
return ret; |
||||
}; |
||||
} |
||||
}); |
||||
var Compiler = Class({ |
||||
initialize: function Compiler(input) { |
||||
var options = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: {}; |
||||
defaults(options, { |
||||
indent: ' ' |
||||
}); |
||||
this.input = input; |
||||
this.indentLevel = 0; |
||||
this.indentation = options.indent; |
||||
}, |
||||
compile: function() { |
||||
return this.stylesheet(this.input); |
||||
}, |
||||
stylesheet: function(node) { |
||||
return this.mapVisit(node.rules, '\n\n'); |
||||
}, |
||||
media: function(node) { |
||||
return ( |
||||
'@media ' + |
||||
node.media + |
||||
' {\n' + |
||||
this.indent(1) + |
||||
this.mapVisit(node.rules, '\n\n') + |
||||
this.indent(-1) + |
||||
'\n}' |
||||
); |
||||
}, |
||||
keyframes: function(node) { |
||||
return ( |
||||
'@'.concat(node.vendor, 'keyframes ') + |
||||
node.name + |
||||
' {\n' + |
||||
this.indent(1) + |
||||
this.mapVisit(node.keyframes, '\n') + |
||||
this.indent(-1) + |
||||
'\n}' |
||||
); |
||||
}, |
||||
supports: function(node) { |
||||
return ( |
||||
'@supports ' + |
||||
node.supports + |
||||
' {\n' + |
||||
this.indent(1) + |
||||
this.mapVisit(node.rules, '\n\n') + |
||||
this.indent(-1) + |
||||
'\n}' |
||||
); |
||||
}, |
||||
keyframe: function(node) { |
||||
return this.rule(node); |
||||
}, |
||||
mapVisit: function(nodes, delimiter) { |
||||
var str = ''; |
||||
for (var i = 0, len = nodes.length; i < len; i++) { |
||||
var node = nodes[i]; |
||||
str += this[camelCase(node.type)](node); |
||||
if (delimiter && i < len - 1) str += delimiter; |
||||
} |
||||
return str; |
||||
}, |
||||
fontFace: function(node) { |
||||
return ( |
||||
'@font-face {\n' + |
||||
this.indent(1) + |
||||
this.mapVisit(node.declarations, '\n') + |
||||
this.indent(-1) + |
||||
'\n}' |
||||
); |
||||
}, |
||||
rule: function(node) { |
||||
return ( |
||||
this.indent() + |
||||
node.selector + |
||||
' {\n' + |
||||
this.indent(1) + |
||||
this.mapVisit(node.declarations, '\n') + |
||||
this.indent(-1) + |
||||
'\n' + |
||||
this.indent() + |
||||
'}' |
||||
); |
||||
}, |
||||
declaration: function(node) { |
||||
return this.indent() + node.property + ': ' + node.value + ';'; |
||||
}, |
||||
import: function(node) { |
||||
return '@import '.concat(node.import, ';'); |
||||
}, |
||||
charset: function(node) { |
||||
return '@charset '.concat(node.charset, ';'); |
||||
}, |
||||
namespace: function(node) { |
||||
return '@namespace '.concat(node.namespace, ';'); |
||||
}, |
||||
indent: function(level) { |
||||
if (level) { |
||||
this.indentLevel += level; |
||||
return ''; |
||||
} |
||||
return repeat(this.indentation, this.indentLevel); |
||||
} |
||||
}); |
||||
var stripCmt = function(str) { |
||||
return str.replace(regComments, ''); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,63 @@
@@ -0,0 +1,63 @@
|
||||
var selector = require('./selector'); |
||||
var each = require('./each'); |
||||
var startWith = require('./startWith'); |
||||
var contain = require('./contain'); |
||||
var cmpVersion = require('./cmpVersion'); |
||||
|
||||
exports = function(sel) { |
||||
var _ref = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: {}, |
||||
_ref$important = _ref.important, |
||||
important = _ref$important === void 0 ? false : _ref$important, |
||||
_ref$inlineStyle = _ref.inlineStyle, |
||||
inlineStyle = _ref$inlineStyle === void 0 ? false : _ref$inlineStyle, |
||||
_ref$position = _ref.position, |
||||
position = _ref$position === void 0 ? 0 : _ref$position; |
||||
var ret = [0, 0, 0, 0, 0, position]; |
||||
if (important) ret[0] = 1; |
||||
if (inlineStyle) ret[1] = 1; |
||||
var group = selector.parse(sel)[0]; |
||||
each(group, function(_ref2) { |
||||
var type = _ref2.type, |
||||
value = _ref2.value; |
||||
switch (type) { |
||||
case 'id': |
||||
ret[2]++; |
||||
break; |
||||
case 'class': |
||||
case 'attribute': |
||||
ret[3]++; |
||||
break; |
||||
case 'pseudo': |
||||
if (contain(PSEUDO_ELEMS, value.replace(/:/g, ''))) { |
||||
ret[4]++; |
||||
} else if (!startWith(value, '::')) { |
||||
ret[3]++; |
||||
} |
||||
break; |
||||
case 'tag': |
||||
if (value !== '*') { |
||||
ret[4]++; |
||||
} |
||||
break; |
||||
} |
||||
}); |
||||
return ret; |
||||
}; |
||||
var PSEUDO_ELEMS = [ |
||||
'first-letter', |
||||
'last-letter', |
||||
'first-line', |
||||
'last-line', |
||||
'first-child', |
||||
'last-child', |
||||
'before', |
||||
'after' |
||||
]; |
||||
exports.compare = function(p1, p2) { |
||||
return cmpVersion(p1.join('.'), p2.join('.')); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,15 @@
@@ -0,0 +1,15 @@
|
||||
var toArr = require('./toArr'); |
||||
exports = function(fn) { |
||||
var len = fn.length; |
||||
return function curriedFn() { |
||||
var args = toArr(arguments); |
||||
if (args.length < len) { |
||||
return function() { |
||||
return curriedFn.apply(null, args.concat(toArr(arguments))); |
||||
}; |
||||
} |
||||
return fn.apply(null, args); |
||||
}; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,68 @@
@@ -0,0 +1,68 @@
|
||||
var isDataUrl = require('./isDataUrl'); |
||||
var trim = require('./trim'); |
||||
var endWith = require('./endWith'); |
||||
var startWith = require('./startWith'); |
||||
var contain = require('./contain'); |
||||
var decodeUriComponent = require('./decodeUriComponent'); |
||||
var defaults = require('./defaults'); |
||||
var isStr = require('./isStr'); |
||||
var convertBin = require('./convertBin'); |
||||
exports = { |
||||
parse: function(dataUrl) { |
||||
if (!isDataUrl(dataUrl)) { |
||||
return null; |
||||
} |
||||
dataUrl = dataUrl.slice('data:'.length); |
||||
var commaIdx = dataUrl.indexOf(','); |
||||
var mime = trim(dataUrl.slice(0, commaIdx)); |
||||
var data = trim(dataUrl.slice(commaIdx + 1)); |
||||
var base64 = false; |
||||
if (endWith(mime, ';base64')) { |
||||
base64 = true; |
||||
mime = mime.slice(0, -';base64'.length); |
||||
} |
||||
var charset = ''; |
||||
if (contain(mime, 'charset=')) { |
||||
charset = mime.split('charset=')[1]; |
||||
mime = mime.split(';')[0]; |
||||
} |
||||
if (!mime) { |
||||
mime = 'text/plain'; |
||||
} |
||||
if (!base64 && startWith(mime, 'text/') && contain(data, '%')) { |
||||
data = decodeUriComponent(data); |
||||
} |
||||
return { |
||||
data: data, |
||||
mime: mime, |
||||
charset: charset, |
||||
base64: base64 |
||||
}; |
||||
}, |
||||
stringify: function(data, mime) { |
||||
var options = |
||||
arguments.length > 2 && arguments[2] !== undefined |
||||
? arguments[2] |
||||
: {}; |
||||
defaults(options, { |
||||
base64: true, |
||||
charset: '' |
||||
}); |
||||
var result = 'data:' + mime; |
||||
if (options.charset && startWith(mime, 'text/')) { |
||||
result += ';charset=' + options.charset; |
||||
} |
||||
if (!isStr(data)) { |
||||
data = convertBin(data, 'base64'); |
||||
options.base64 = true; |
||||
} |
||||
if (options.base64) { |
||||
result += ';base64'; |
||||
} else if (startWith(mime, 'text/') || !mime) { |
||||
data = encodeURIComponent(data); |
||||
} |
||||
return result + ',' + data; |
||||
} |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,142 @@
@@ -0,0 +1,142 @@
|
||||
var isStr = require('./isStr'); |
||||
var isDate = require('./isDate'); |
||||
var toStr = require('./toStr'); |
||||
var lpad = require('./lpad'); |
||||
exports = function(date, mask, utc, gmt) { |
||||
if (arguments.length === 1 && isStr(date) && !regNum.test(date)) { |
||||
mask = date; |
||||
date = undefined; |
||||
} |
||||
date = date || new Date(); |
||||
if (!isDate(date)) date = new Date(date); |
||||
mask = toStr(exports.masks[mask] || mask || exports.masks['default']); |
||||
var maskSlice = mask.slice(0, 4); |
||||
if (maskSlice === 'UTC:' || maskSlice === 'GMT:') { |
||||
mask = mask.slice(4); |
||||
utc = true; |
||||
if (maskSlice === 'GMT:') gmt = true; |
||||
} |
||||
var prefix = utc ? 'getUTC' : 'get'; |
||||
var d = date[prefix + 'Date'](); |
||||
var D = date[prefix + 'Day'](); |
||||
var m = date[prefix + 'Month'](); |
||||
var y = date[prefix + 'FullYear'](); |
||||
var H = date[prefix + 'Hours'](); |
||||
var M = date[prefix + 'Minutes'](); |
||||
var s = date[prefix + 'Seconds'](); |
||||
var L = date[prefix + 'Milliseconds'](); |
||||
var o = utc ? 0 : date.getTimezoneOffset(); |
||||
var flags = { |
||||
d: d, |
||||
dd: padZero(d), |
||||
ddd: exports.i18n.dayNames[D], |
||||
dddd: exports.i18n.dayNames[D + 7], |
||||
m: m + 1, |
||||
mm: padZero(m + 1), |
||||
mmm: exports.i18n.monthNames[m], |
||||
mmmm: exports.i18n.monthNames[m + 12], |
||||
yy: toStr(y).slice(2), |
||||
yyyy: y, |
||||
h: H % 12 || 12, |
||||
hh: padZero(H % 12 || 12), |
||||
H: H, |
||||
HH: padZero(H), |
||||
M: M, |
||||
MM: padZero(M), |
||||
s: s, |
||||
ss: padZero(s), |
||||
l: padZero(L, 3), |
||||
L: padZero(Math.round(L / 10)), |
||||
t: H < 12 ? 'a' : 'p', |
||||
tt: H < 12 ? 'am' : 'pm', |
||||
T: H < 12 ? 'A' : 'P', |
||||
TT: H < 12 ? 'AM' : 'PM', |
||||
Z: gmt |
||||
? 'GMT' |
||||
: utc |
||||
? 'UTC' |
||||
: (toStr(date).match(regTimezone) || ['']) |
||||
.pop() |
||||
.replace(regTimezoneClip, ''), |
||||
o: |
||||
(o > 0 ? '-' : '+') + |
||||
padZero(Math.floor(Math.abs(o) / 60) * 100 + (Math.abs(o) % 60), 4), |
||||
S: ['th', 'st', 'nd', 'rd'][ |
||||
d % 10 > 3 ? 0 : (((d % 100) - (d % 10) != 10) * d) % 10 |
||||
] |
||||
}; |
||||
return mask.replace(regToken, function(match) { |
||||
if (match in flags) return flags[match]; |
||||
return match.slice(1, match.length - 1); |
||||
}); |
||||
}; |
||||
var padZero = function(str) { |
||||
var len = |
||||
arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2; |
||||
return lpad(toStr(str), len, '0'); |
||||
}; |
||||
var regToken = /d{1,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|[LloSZWN]|"[^"]*"|'[^']*'/g; |
||||
var regTimezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g; |
||||
var regNum = /\d/; |
||||
var regTimezoneClip = /[^-+\dA-Z]/g; |
||||
exports.masks = { |
||||
default: 'ddd mmm dd yyyy HH:MM:ss', |
||||
shortDate: 'm/d/yy', |
||||
mediumDate: 'mmm d, yyyy', |
||||
longDate: 'mmmm d, yyyy', |
||||
fullDate: 'dddd, mmmm d, yyyy', |
||||
shortTime: 'h:MM TT', |
||||
mediumTime: 'h:MM:ss TT', |
||||
longTime: 'h:MM:ss TT Z', |
||||
isoDate: 'yyyy-mm-dd', |
||||
isoTime: 'HH:MM:ss', |
||||
isoDateTime: "yyyy-mm-dd'T'HH:MM:sso", |
||||
isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'", |
||||
expiresHeaderFormat: 'ddd, dd mmm yyyy HH:MM:ss Z' |
||||
}; |
||||
exports.i18n = { |
||||
dayNames: [ |
||||
'Sun', |
||||
'Mon', |
||||
'Tue', |
||||
'Wed', |
||||
'Thu', |
||||
'Fri', |
||||
'Sat', |
||||
'Sunday', |
||||
'Monday', |
||||
'Tuesday', |
||||
'Wednesday', |
||||
'Thursday', |
||||
'Friday', |
||||
'Saturday' |
||||
], |
||||
monthNames: [ |
||||
'Jan', |
||||
'Feb', |
||||
'Mar', |
||||
'Apr', |
||||
'May', |
||||
'Jun', |
||||
'Jul', |
||||
'Aug', |
||||
'Sep', |
||||
'Oct', |
||||
'Nov', |
||||
'Dec', |
||||
'January', |
||||
'February', |
||||
'March', |
||||
'April', |
||||
'May', |
||||
'June', |
||||
'July', |
||||
'August', |
||||
'September', |
||||
'October', |
||||
'November', |
||||
'December' |
||||
] |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,15 @@
@@ -0,0 +1,15 @@
|
||||
exports = function(fn, wait, immediate) { |
||||
var timeout; |
||||
return function() { |
||||
var ctx = this; |
||||
var args = arguments; |
||||
var throttler = function() { |
||||
timeout = null; |
||||
fn.apply(ctx, args); |
||||
}; |
||||
if (!immediate) clearTimeout(timeout); |
||||
if (!immediate || !timeout) timeout = setTimeout(throttler, wait); |
||||
}; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,206 @@
@@ -0,0 +1,206 @@
|
||||
exports = function(str) { |
||||
return str |
||||
.replace(regLatin, function(key) { |
||||
return deburredLetters[key]; |
||||
}) |
||||
.replace(regComboMark, ''); |
||||
}; |
||||
|
||||
var regComboMark = /[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]/g; |
||||
var regLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; |
||||
|
||||
var deburredLetters = { |
||||
À: 'A', |
||||
Á: 'A', |
||||
Â: 'A', |
||||
Ã: 'A', |
||||
Ä: 'A', |
||||
Å: 'A', |
||||
à: 'a', |
||||
á: 'a', |
||||
â: 'a', |
||||
ã: 'a', |
||||
ä: 'a', |
||||
å: 'a', |
||||
Ç: 'C', |
||||
ç: 'c', |
||||
Ð: 'D', |
||||
ð: 'd', |
||||
È: 'E', |
||||
É: 'E', |
||||
Ê: 'E', |
||||
Ë: 'E', |
||||
è: 'e', |
||||
é: 'e', |
||||
ê: 'e', |
||||
ë: 'e', |
||||
Ì: 'I', |
||||
Í: 'I', |
||||
Î: 'I', |
||||
Ï: 'I', |
||||
ì: 'i', |
||||
í: 'i', |
||||
î: 'i', |
||||
ï: 'i', |
||||
Ñ: 'N', |
||||
ñ: 'n', |
||||
Ò: 'O', |
||||
Ó: 'O', |
||||
Ô: 'O', |
||||
Õ: 'O', |
||||
Ö: 'O', |
||||
Ø: 'O', |
||||
ò: 'o', |
||||
ó: 'o', |
||||
ô: 'o', |
||||
õ: 'o', |
||||
ö: 'o', |
||||
ø: 'o', |
||||
Ù: 'U', |
||||
Ú: 'U', |
||||
Û: 'U', |
||||
Ü: 'U', |
||||
ù: 'u', |
||||
ú: 'u', |
||||
û: 'u', |
||||
ü: 'u', |
||||
Ý: 'Y', |
||||
ý: 'y', |
||||
ÿ: 'y', |
||||
Æ: 'Ae', |
||||
æ: 'ae', |
||||
Þ: 'Th', |
||||
þ: 'th', |
||||
ß: 'ss', |
||||
|
||||
Ā: 'A', |
||||
Ă: 'A', |
||||
Ą: 'A', |
||||
ā: 'a', |
||||
ă: 'a', |
||||
ą: 'a', |
||||
Ć: 'C', |
||||
Ĉ: 'C', |
||||
Ċ: 'C', |
||||
Č: 'C', |
||||
ć: 'c', |
||||
ĉ: 'c', |
||||
ċ: 'c', |
||||
č: 'c', |
||||
Ď: 'D', |
||||
Đ: 'D', |
||||
ď: 'd', |
||||
đ: 'd', |
||||
Ē: 'E', |
||||
Ĕ: 'E', |
||||
Ė: 'E', |
||||
Ę: 'E', |
||||
Ě: 'E', |
||||
ē: 'e', |
||||
ĕ: 'e', |
||||
ė: 'e', |
||||
ę: 'e', |
||||
ě: 'e', |
||||
Ĝ: 'G', |
||||
Ğ: 'G', |
||||
Ġ: 'G', |
||||
Ģ: 'G', |
||||
ĝ: 'g', |
||||
ğ: 'g', |
||||
ġ: 'g', |
||||
ģ: 'g', |
||||
Ĥ: 'H', |
||||
Ħ: 'H', |
||||
ĥ: 'h', |
||||
ħ: 'h', |
||||
Ĩ: 'I', |
||||
Ī: 'I', |
||||
Ĭ: 'I', |
||||
Į: 'I', |
||||
İ: 'I', |
||||
ĩ: 'i', |
||||
ī: 'i', |
||||
ĭ: 'i', |
||||
į: 'i', |
||||
ı: 'i', |
||||
Ĵ: 'J', |
||||
ĵ: 'j', |
||||
Ķ: 'K', |
||||
ķ: 'k', |
||||
ĸ: 'k', |
||||
Ĺ: 'L', |
||||
Ļ: 'L', |
||||
Ľ: 'L', |
||||
Ŀ: 'L', |
||||
Ł: 'L', |
||||
ĺ: 'l', |
||||
ļ: 'l', |
||||
ľ: 'l', |
||||
ŀ: 'l', |
||||
ł: 'l', |
||||
Ń: 'N', |
||||
Ņ: 'N', |
||||
Ň: 'N', |
||||
Ŋ: 'N', |
||||
ń: 'n', |
||||
ņ: 'n', |
||||
ň: 'n', |
||||
ŋ: 'n', |
||||
Ō: 'O', |
||||
Ŏ: 'O', |
||||
Ő: 'O', |
||||
ō: 'o', |
||||
ŏ: 'o', |
||||
ő: 'o', |
||||
Ŕ: 'R', |
||||
Ŗ: 'R', |
||||
Ř: 'R', |
||||
ŕ: 'r', |
||||
ŗ: 'r', |
||||
ř: 'r', |
||||
Ś: 'S', |
||||
Ŝ: 'S', |
||||
Ş: 'S', |
||||
Š: 'S', |
||||
ś: 's', |
||||
ŝ: 's', |
||||
ş: 's', |
||||
š: 's', |
||||
Ţ: 'T', |
||||
Ť: 'T', |
||||
Ŧ: 'T', |
||||
ţ: 't', |
||||
ť: 't', |
||||
ŧ: 't', |
||||
Ũ: 'U', |
||||
Ū: 'U', |
||||
Ŭ: 'U', |
||||
Ů: 'U', |
||||
Ű: 'U', |
||||
Ų: 'U', |
||||
ũ: 'u', |
||||
ū: 'u', |
||||
ŭ: 'u', |
||||
ů: 'u', |
||||
ű: 'u', |
||||
ų: 'u', |
||||
Ŵ: 'W', |
||||
ŵ: 'w', |
||||
Ŷ: 'Y', |
||||
ŷ: 'y', |
||||
Ÿ: 'Y', |
||||
Ź: 'Z', |
||||
Ż: 'Z', |
||||
Ž: 'Z', |
||||
ź: 'z', |
||||
ż: 'z', |
||||
ž: 'z', |
||||
IJ: 'IJ', |
||||
ij: 'ij', |
||||
Œ: 'Oe', |
||||
œ: 'oe', |
||||
ʼn: "'n", |
||||
ſ: 's' |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,31 @@
@@ -0,0 +1,31 @@
|
||||
var each = require('./each'); |
||||
var ucs2 = require('./ucs2'); |
||||
var map = require('./map'); |
||||
var utf8 = require('./utf8'); |
||||
exports = function(str) { |
||||
try { |
||||
return decodeURIComponent(str); |
||||
} catch (e) { |
||||
var matches = str.match(regMatcher); |
||||
if (!matches) { |
||||
return str; |
||||
} |
||||
each(matches, function(match) { |
||||
str = str.replace(match, decode(match)); |
||||
}); |
||||
return str; |
||||
} |
||||
}; |
||||
function decode(str) { |
||||
str = str.split('%').slice(1); |
||||
var bytes = map(str, hexToInt); |
||||
str = ucs2.encode(bytes); |
||||
str = utf8.decode(str, true); |
||||
return str; |
||||
} |
||||
function hexToInt(numStr) { |
||||
return +('0x' + numStr); |
||||
} |
||||
var regMatcher = /(%[a-f0-9]{2})+/gi; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,5 @@
@@ -0,0 +1,5 @@
|
||||
var createAssigner = require('./createAssigner'); |
||||
var allKeys = require('./allKeys'); |
||||
exports = createAssigner(allKeys, true); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,17 @@
@@ -0,0 +1,17 @@
|
||||
var toArr = require('./toArr'); |
||||
exports = function(name, requires, method) { |
||||
if (arguments.length === 2) { |
||||
method = requires; |
||||
requires = []; |
||||
} |
||||
define(name, requires, method); |
||||
}; |
||||
var modules = (exports._modules = {}); |
||||
function define(name, requires, method) { |
||||
modules[name] = { |
||||
requires: toArr(requires), |
||||
body: method |
||||
}; |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,26 @@
@@ -0,0 +1,26 @@
|
||||
var castPath = require('./castPath'); |
||||
var isStr = require('./isStr'); |
||||
var isObj = require('./isObj'); |
||||
var each = require('./each'); |
||||
exports = function(obj, prop, descriptor) { |
||||
if (isStr(prop)) { |
||||
defineProp(obj, prop, descriptor); |
||||
} else if (isObj(prop)) { |
||||
each(prop, function(descriptor, prop) { |
||||
defineProp(obj, prop, descriptor); |
||||
}); |
||||
} |
||||
return obj; |
||||
}; |
||||
function defineProp(obj, prop, descriptor) { |
||||
var path = castPath(prop, obj); |
||||
var lastProp = path.pop(); |
||||
|
||||
while ((prop = path.shift())) { |
||||
if (!obj[prop]) obj[prop] = {}; |
||||
obj = obj[prop]; |
||||
} |
||||
Object.defineProperty(obj, lastProp, descriptor); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,8 @@
@@ -0,0 +1,8 @@
|
||||
var isUndef = require('./isUndef'); |
||||
exports = function() { |
||||
for (var i = 0, len = arguments.length; i < len; i++) { |
||||
if (!isUndef(arguments[i])) return arguments[i]; |
||||
} |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,8 @@
@@ -0,0 +1,8 @@
|
||||
var restArgs = require('./restArgs'); |
||||
exports = restArgs(function(fn, wait, args) { |
||||
return setTimeout(function() { |
||||
return fn.apply(null, args); |
||||
}, wait); |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,36 @@
@@ -0,0 +1,36 @@
|
||||
var isNode = require('./isNode'); |
||||
var root = require('./root'); |
||||
var memStorage = require('./memStorage'); |
||||
if (isNode) { |
||||
exports = eval('require')('util').deprecate; |
||||
} else { |
||||
var localStorage = root.localStorage || memStorage; |
||||
exports = function(fn, msg) { |
||||
if (localStorage.getItem('noDeprecation')) { |
||||
return fn; |
||||
} |
||||
var warned = false; |
||||
function deprecated() { |
||||
if (!warned) { |
||||
warned = true; |
||||
|
||||
console.warn(msg); |
||||
} |
||||
for ( |
||||
var _len = arguments.length, args = new Array(_len), _key = 0; |
||||
_key < _len; |
||||
_key++ |
||||
) { |
||||
args[_key] = arguments[_key]; |
||||
} |
||||
return fn.apply(this, args); |
||||
} |
||||
Object.setPrototypeOf(deprecated, fn); |
||||
if (fn.prototype) { |
||||
deprecated.prototype = fn.prototype; |
||||
} |
||||
return deprecated; |
||||
}; |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,51 @@
@@ -0,0 +1,51 @@
|
||||
var isBrowser = require('./isBrowser'); |
||||
var toInt = require('./toInt'); |
||||
var keys = require('./keys'); |
||||
exports = function(ua) { |
||||
ua = ua || (isBrowser ? navigator.userAgent : ''); |
||||
ua = ua.toLowerCase(); |
||||
var ieVer = getVer(ua, 'msie '); |
||||
if (ieVer) |
||||
return { |
||||
version: ieVer, |
||||
name: 'ie' |
||||
}; |
||||
if (regIe11.test(ua)) |
||||
return { |
||||
version: 11, |
||||
name: 'ie' |
||||
}; |
||||
for (var i = 0, len = browsers.length; i < len; i++) { |
||||
var name = browsers[i]; |
||||
var match = ua.match(regBrowsers[name]); |
||||
if (match == null) continue; |
||||
var version = toInt(match[1].split('.')[0]); |
||||
if (name === 'opera') version = getVer(ua, 'version/') || version; |
||||
return { |
||||
name: name, |
||||
version: version |
||||
}; |
||||
} |
||||
return { |
||||
name: 'unknown', |
||||
version: -1 |
||||
}; |
||||
}; |
||||
var regBrowsers = { |
||||
edge: /edge\/([0-9._]+)/, |
||||
firefox: /firefox\/([0-9.]+)(?:\s|$)/, |
||||
opera: /opera\/([0-9.]+)(?:\s|$)/, |
||||
android: /android\s([0-9.]+)/, |
||||
ios: /version\/([0-9._]+).*mobile.*safari.*/, |
||||
safari: /version\/([0-9._]+).*safari/, |
||||
chrome: /(?!chrom.*opr)chrom(?:e|ium)\/([0-9.]+)(:?\s|$)/ |
||||
}; |
||||
var regIe11 = /trident\/7\./; |
||||
var browsers = keys(regBrowsers); |
||||
function getVer(ua, mark) { |
||||
var idx = ua.indexOf(mark); |
||||
if (idx > -1) |
||||
return toInt(ua.substring(idx + mark.length, ua.indexOf('.', idx))); |
||||
} |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,11 @@
@@ -0,0 +1,11 @@
|
||||
var root = require('./root'); |
||||
exports = function() { |
||||
for (var i = 0, len = methods.length; i < len; i++) { |
||||
var method = methods[i]; |
||||
if (typeof root[method] !== 'function') return false; |
||||
} |
||||
return true; |
||||
}; |
||||
var methods = ['afterEach', 'after', 'beforeEach', 'before', 'describe', 'it']; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,39 @@
@@ -0,0 +1,39 @@
|
||||
var isBrowser = require('./isBrowser'); |
||||
var isNode = require('./isNode'); |
||||
exports = function(ua) { |
||||
if (!ua && isBrowser) { |
||||
ua = navigator.userAgent; |
||||
} |
||||
function detect(keyword) { |
||||
return ua.indexOf(keyword) > -1; |
||||
} |
||||
if (ua) { |
||||
ua = ua.toLowerCase(); |
||||
if (detect('windows phone')) return 'windows phone'; |
||||
if (detect('win')) return 'windows'; |
||||
if (detect('android')) return 'android'; |
||||
if (detect('ipad') || detect('iphone') || detect('ipod')) return 'ios'; |
||||
if (detect('mac')) return 'os x'; |
||||
if (detect('linux')) return 'linux'; |
||||
} else if (isNode) { |
||||
var _process = process, |
||||
platform = _process.platform, |
||||
env = _process.env; |
||||
if ( |
||||
platform === 'win32' || |
||||
env.OSTYPE === 'cygwin' || |
||||
env.OSTYPE === 'msys' |
||||
) { |
||||
return 'windows'; |
||||
} |
||||
if (platform === 'darwin') { |
||||
return 'os x'; |
||||
} |
||||
if (platform === 'linux') { |
||||
return 'linux'; |
||||
} |
||||
} |
||||
return 'unknown'; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,12 @@
@@ -0,0 +1,12 @@
|
||||
var restArgs = require('./restArgs'); |
||||
var flatten = require('./flatten'); |
||||
var filter = require('./filter'); |
||||
var contain = require('./contain'); |
||||
exports = restArgs(function(arr, args) { |
||||
args = flatten(args); |
||||
return filter(arr, function(val) { |
||||
return !contain(args, val); |
||||
}); |
||||
}); |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,6 @@
@@ -0,0 +1,6 @@
|
||||
var splitCase = require('./splitCase'); |
||||
exports = function(str) { |
||||
return splitCase(str).join('.'); |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,39 @@
@@ -0,0 +1,39 @@
|
||||
var toInt = require('./toInt'); |
||||
var lpad = require('./lpad'); |
||||
var toStr = require('./toStr'); |
||||
var floor = Math.floor; |
||||
exports = function(duration) { |
||||
var mask = |
||||
arguments.length > 1 && arguments[1] !== undefined |
||||
? arguments[1] |
||||
: 'hh:mm:ss'; |
||||
duration = toInt(duration); |
||||
var d = floor(duration / 86400000); |
||||
var h = floor(duration / 3600000) % 24; |
||||
var m = floor(duration / 60000) % 60; |
||||
var s = floor(duration / 1000) % 60; |
||||
var l = floor(duration) % 1000; |
||||
var flags = { |
||||
d: d, |
||||
h: h, |
||||
hh: padZero(h), |
||||
m: m, |
||||
mm: padZero(m), |
||||
s: s, |
||||
ss: padZero(s), |
||||
l: l, |
||||
ll: padZero(l, 3) |
||||
}; |
||||
return mask.replace(regToken, function(match) { |
||||
if (match in flags) return flags[match]; |
||||
return match.slice(1, match.length - 1); |
||||
}); |
||||
}; |
||||
var padZero = function(str) { |
||||
var len = |
||||
arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2; |
||||
return lpad(toStr(str), len, '0'); |
||||
}; |
||||
var regToken = /d{1,2}|h{1,2}|m{1,2}|s{1,2}|l{1,2}|"[^"]*"|'[^']*'/g; |
||||
|
||||
module.exports = exports; |
||||
@ -0,0 +1,18 @@
@@ -0,0 +1,18 @@
|
||||
var isArrLike = require('./isArrLike'); |
||||
var keys = require('./keys'); |
||||
var optimizeCb = require('./optimizeCb'); |
||||
exports = function(obj, iterator, ctx) { |
||||
iterator = optimizeCb(iterator, ctx); |
||||
var i, len; |
||||
if (isArrLike(obj)) { |
||||
for (i = 0, len = obj.length; i < len; i++) iterator(obj[i], i, obj); |
||||
} else { |
||||
var _keys = keys(obj); |
||||
for (i = 0, len = _keys.length; i < len; i++) { |
||||
iterator(obj[_keys[i]], _keys[i], obj); |
||||
} |
||||
} |
||||
return obj; |
||||
}; |
||||
|
||||
module.exports = exports; |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue