|
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ |
|
(function (process){ |
|
// Copyright Joyent, Inc. and other Node contributors. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a |
|
// copy of this software and associated documentation files (the |
|
// "Software"), to deal in the Software without restriction, including |
|
// without limitation the rights to use, copy, modify, merge, publish, |
|
// distribute, sublicense, and/or sell copies of the Software, and to permit |
|
// persons to whom the Software is furnished to do so, subject to the |
|
// following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included |
|
// in all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN |
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
|
// USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
|
|
// resolves . and .. elements in a path array with directory names there |
|
// must be no slashes, empty elements, or device names (c:\) in the array |
|
// (so also no leading and trailing slashes - it does not distinguish |
|
// relative and absolute paths) |
|
function normalizeArray(parts, allowAboveRoot) { |
|
// if the path tries to go above the root, `up` ends up > 0 |
|
var up = 0; |
|
for (var i = parts.length - 1; i >= 0; i--) { |
|
var last = parts[i]; |
|
if (last === '.') { |
|
parts.splice(i, 1); |
|
} else if (last === '..') { |
|
parts.splice(i, 1); |
|
up++; |
|
} else if (up) { |
|
parts.splice(i, 1); |
|
up--; |
|
} |
|
} |
|
|
|
// if the path is allowed to go above the root, restore leading ..s |
|
if (allowAboveRoot) { |
|
for (; up--; up) { |
|
parts.unshift('..'); |
|
} |
|
} |
|
|
|
return parts; |
|
} |
|
|
|
// Split a filename into [root, dir, basename, ext], unix version |
|
// 'root' is just a slash, or nothing. |
|
var splitPathRe = |
|
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; |
|
var splitPath = function(filename) { |
|
return splitPathRe.exec(filename).slice(1); |
|
}; |
|
|
|
// path.resolve([from ...], to) |
|
// posix version |
|
exports.resolve = function() { |
|
var resolvedPath = '', |
|
resolvedAbsolute = false; |
|
|
|
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { |
|
var path = (i >= 0) ? arguments[i] : process.cwd(); |
|
|
|
// Skip empty and invalid entries |
|
if (typeof path !== 'string') { |
|
throw new TypeError('Arguments to path.resolve must be strings'); |
|
} else if (!path) { |
|
continue; |
|
} |
|
|
|
resolvedPath = path + '/' + resolvedPath; |
|
resolvedAbsolute = path.charAt(0) === '/'; |
|
} |
|
|
|
// At this point the path should be resolved to a full absolute path, but |
|
// handle relative paths to be safe (might happen when process.cwd() fails) |
|
|
|
// Normalize the path |
|
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { |
|
return !!p; |
|
}), !resolvedAbsolute).join('/'); |
|
|
|
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; |
|
}; |
|
|
|
// path.normalize(path) |
|
// posix version |
|
exports.normalize = function(path) { |
|
var isAbsolute = exports.isAbsolute(path), |
|
trailingSlash = substr(path, -1) === '/'; |
|
|
|
// Normalize the path |
|
path = normalizeArray(filter(path.split('/'), function(p) { |
|
return !!p; |
|
}), !isAbsolute).join('/'); |
|
|
|
if (!path && !isAbsolute) { |
|
path = '.'; |
|
} |
|
if (path && trailingSlash) { |
|
path += '/'; |
|
} |
|
|
|
return (isAbsolute ? '/' : '') + path; |
|
}; |
|
|
|
// posix version |
|
exports.isAbsolute = function(path) { |
|
return path.charAt(0) === '/'; |
|
}; |
|
|
|
// posix version |
|
exports.join = function() { |
|
var paths = Array.prototype.slice.call(arguments, 0); |
|
return exports.normalize(filter(paths, function(p, index) { |
|
if (typeof p !== 'string') { |
|
throw new TypeError('Arguments to path.join must be strings'); |
|
} |
|
return p; |
|
}).join('/')); |
|
}; |
|
|
|
|
|
// path.relative(from, to) |
|
// posix version |
|
exports.relative = function(from, to) { |
|
from = exports.resolve(from).substr(1); |
|
to = exports.resolve(to).substr(1); |
|
|
|
function trim(arr) { |
|
var start = 0; |
|
for (; start < arr.length; start++) { |
|
if (arr[start] !== '') break; |
|
} |
|
|
|
var end = arr.length - 1; |
|
for (; end >= 0; end--) { |
|
if (arr[end] !== '') break; |
|
} |
|
|
|
if (start > end) return []; |
|
return arr.slice(start, end - start + 1); |
|
} |
|
|
|
var fromParts = trim(from.split('/')); |
|
var toParts = trim(to.split('/')); |
|
|
|
var length = Math.min(fromParts.length, toParts.length); |
|
var samePartsLength = length; |
|
for (var i = 0; i < length; i++) { |
|
if (fromParts[i] !== toParts[i]) { |
|
samePartsLength = i; |
|
break; |
|
} |
|
} |
|
|
|
var outputParts = []; |
|
for (var i = samePartsLength; i < fromParts.length; i++) { |
|
outputParts.push('..'); |
|
} |
|
|
|
outputParts = outputParts.concat(toParts.slice(samePartsLength)); |
|
|
|
return outputParts.join('/'); |
|
}; |
|
|
|
exports.sep = '/'; |
|
exports.delimiter = ':'; |
|
|
|
exports.dirname = function(path) { |
|
var result = splitPath(path), |
|
root = result[0], |
|
dir = result[1]; |
|
|
|
if (!root && !dir) { |
|
// No dirname whatsoever |
|
return '.'; |
|
} |
|
|
|
if (dir) { |
|
// It has a dirname, strip trailing slash |
|
dir = dir.substr(0, dir.length - 1); |
|
} |
|
|
|
return root + dir; |
|
}; |
|
|
|
|
|
exports.basename = function(path, ext) { |
|
var f = splitPath(path)[2]; |
|
// TODO: make this comparison case-insensitive on windows? |
|
if (ext && f.substr(-1 * ext.length) === ext) { |
|
f = f.substr(0, f.length - ext.length); |
|
} |
|
return f; |
|
}; |
|
|
|
|
|
exports.extname = function(path) { |
|
return splitPath(path)[3]; |
|
}; |
|
|
|
function filter (xs, f) { |
|
if (xs.filter) return xs.filter(f); |
|
var res = []; |
|
for (var i = 0; i < xs.length; i++) { |
|
if (f(xs[i], i, xs)) res.push(xs[i]); |
|
} |
|
return res; |
|
} |
|
|
|
// String.prototype.substr - negative index don't work in IE8 |
|
var substr = 'ab'.substr(-1) === 'b' |
|
? function (str, start, len) { return str.substr(start, len) } |
|
: function (str, start, len) { |
|
if (start < 0) start = str.length + start; |
|
return str.substr(start, len); |
|
} |
|
; |
|
|
|
}).call(this,require('_process')) |
|
},{"_process":2}],2:[function(require,module,exports){ |
|
// shim for using process in browser |
|
var process = module.exports = {}; |
|
|
|
// cached from whatever global is present so that test runners that stub it |
|
// don't break things. But we need to wrap it in a try catch in case it is |
|
// wrapped in strict mode code which doesn't define any globals. It's inside a |
|
// function because try/catches deoptimize in certain engines. |
|
|
|
var cachedSetTimeout; |
|
var cachedClearTimeout; |
|
|
|
function defaultSetTimout() { |
|
throw new Error('setTimeout has not been defined'); |
|
} |
|
function defaultClearTimeout () { |
|
throw new Error('clearTimeout has not been defined'); |
|
} |
|
(function () { |
|
try { |
|
if (typeof setTimeout === 'function') { |
|
cachedSetTimeout = setTimeout; |
|
} else { |
|
cachedSetTimeout = defaultSetTimout; |
|
} |
|
} catch (e) { |
|
cachedSetTimeout = defaultSetTimout; |
|
} |
|
try { |
|
if (typeof clearTimeout === 'function') { |
|
cachedClearTimeout = clearTimeout; |
|
} else { |
|
cachedClearTimeout = defaultClearTimeout; |
|
} |
|
} catch (e) { |
|
cachedClearTimeout = defaultClearTimeout; |
|
} |
|
} ()) |
|
function runTimeout(fun) { |
|
if (cachedSetTimeout === setTimeout) { |
|
//normal enviroments in sane situations |
|
return setTimeout(fun, 0); |
|
} |
|
// if setTimeout wasn't available but was latter defined |
|
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { |
|
cachedSetTimeout = setTimeout; |
|
return setTimeout(fun, 0); |
|
} |
|
try { |
|
// when when somebody has screwed with setTimeout but no I.E. maddness |
|
return cachedSetTimeout(fun, 0); |
|
} catch(e){ |
|
try { |
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
|
return cachedSetTimeout.call(null, fun, 0); |
|
} catch(e){ |
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error |
|
return cachedSetTimeout.call(this, fun, 0); |
|
} |
|
} |
|
|
|
|
|
} |
|
function runClearTimeout(marker) { |
|
if (cachedClearTimeout === clearTimeout) { |
|
//normal enviroments in sane situations |
|
return clearTimeout(marker); |
|
} |
|
// if clearTimeout wasn't available but was latter defined |
|
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { |
|
cachedClearTimeout = clearTimeout; |
|
return clearTimeout(marker); |
|
} |
|
try { |
|
// when when somebody has screwed with setTimeout but no I.E. maddness |
|
return cachedClearTimeout(marker); |
|
} catch (e){ |
|
try { |
|
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally |
|
return cachedClearTimeout.call(null, marker); |
|
} catch (e){ |
|
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. |
|
// Some versions of I.E. have different rules for clearTimeout vs setTimeout |
|
return cachedClearTimeout.call(this, marker); |
|
} |
|
} |
|
|
|
|
|
|
|
} |
|
var queue = []; |
|
var draining = false; |
|
var currentQueue; |
|
var queueIndex = -1; |
|
|
|
function cleanUpNextTick() { |
|
if (!draining || !currentQueue) { |
|
return; |
|
} |
|
draining = false; |
|
if (currentQueue.length) { |
|
queue = currentQueue.concat(queue); |
|
} else { |
|
queueIndex = -1; |
|
} |
|
if (queue.length) { |
|
drainQueue(); |
|
} |
|
} |
|
|
|
function drainQueue() { |
|
if (draining) { |
|
return; |
|
} |
|
var timeout = runTimeout(cleanUpNextTick); |
|
draining = true; |
|
|
|
var len = queue.length; |
|
while(len) { |
|
currentQueue = queue; |
|
queue = []; |
|
while (++queueIndex < len) { |
|
if (currentQueue) { |
|
currentQueue[queueIndex].run(); |
|
} |
|
} |
|
queueIndex = -1; |
|
len = queue.length; |
|
} |
|
currentQueue = null; |
|
draining = false; |
|
runClearTimeout(timeout); |
|
} |
|
|
|
process.nextTick = function (fun) { |
|
var args = new Array(arguments.length - 1); |
|
if (arguments.length > 1) { |
|
for (var i = 1; i < arguments.length; i++) { |
|
args[i - 1] = arguments[i]; |
|
} |
|
} |
|
queue.push(new Item(fun, args)); |
|
if (queue.length === 1 && !draining) { |
|
runTimeout(drainQueue); |
|
} |
|
}; |
|
|
|
// v8 likes predictible objects |
|
function Item(fun, array) { |
|
this.fun = fun; |
|
this.array = array; |
|
} |
|
Item.prototype.run = function () { |
|
this.fun.apply(null, this.array); |
|
}; |
|
process.title = 'browser'; |
|
process.browser = true; |
|
process.env = {}; |
|
process.argv = []; |
|
process.version = ''; // empty string to avoid regexp issues |
|
process.versions = {}; |
|
|
|
function noop() {} |
|
|
|
process.on = noop; |
|
process.addListener = noop; |
|
process.once = noop; |
|
process.off = noop; |
|
process.removeListener = noop; |
|
process.removeAllListeners = noop; |
|
process.emit = noop; |
|
process.prependListener = noop; |
|
process.prependOnceListener = noop; |
|
|
|
process.listeners = function (name) { return [] } |
|
|
|
process.binding = function (name) { |
|
throw new Error('process.binding is not supported'); |
|
}; |
|
|
|
process.cwd = function () { return '/' }; |
|
process.chdir = function (dir) { |
|
throw new Error('process.chdir is not supported'); |
|
}; |
|
process.umask = function() { return 0; }; |
|
|
|
},{}],3:[function(require,module,exports){ |
|
var MomentBusinessTime = require('moment-business-time'); |
|
|
|
console.log(MomentBusinessTime); |
|
},{"moment-business-time":8}],4:[function(require,module,exports){ |
|
'use strict'; |
|
module.exports = balanced; |
|
function balanced(a, b, str) { |
|
if (a instanceof RegExp) a = maybeMatch(a, str); |
|
if (b instanceof RegExp) b = maybeMatch(b, str); |
|
|
|
var r = range(a, b, str); |
|
|
|
return r && { |
|
start: r[0], |
|
end: r[1], |
|
pre: str.slice(0, r[0]), |
|
body: str.slice(r[0] + a.length, r[1]), |
|
post: str.slice(r[1] + b.length) |
|
}; |
|
} |
|
|
|
function maybeMatch(reg, str) { |
|
var m = str.match(reg); |
|
return m ? m[0] : null; |
|
} |
|
|
|
balanced.range = range; |
|
function range(a, b, str) { |
|
var begs, beg, left, right, result; |
|
var ai = str.indexOf(a); |
|
var bi = str.indexOf(b, ai + 1); |
|
var i = ai; |
|
|
|
if (ai >= 0 && bi > 0) { |
|
begs = []; |
|
left = str.length; |
|
|
|
while (i >= 0 && !result) { |
|
if (i == ai) { |
|
begs.push(i); |
|
ai = str.indexOf(a, i + 1); |
|
} else if (begs.length == 1) { |
|
result = [ begs.pop(), bi ]; |
|
} else { |
|
beg = begs.pop(); |
|
if (beg < left) { |
|
left = beg; |
|
right = bi; |
|
} |
|
|
|
bi = str.indexOf(b, i + 1); |
|
} |
|
|
|
i = ai < bi && ai >= 0 ? ai : bi; |
|
} |
|
|
|
if (begs.length) { |
|
result = [ left, right ]; |
|
} |
|
} |
|
|
|
return result; |
|
} |
|
|
|
},{}],5:[function(require,module,exports){ |
|
var concatMap = require('concat-map'); |
|
var balanced = require('balanced-match'); |
|
|
|
module.exports = expandTop; |
|
|
|
var escSlash = '\0SLASH'+Math.random()+'\0'; |
|
var escOpen = '\0OPEN'+Math.random()+'\0'; |
|
var escClose = '\0CLOSE'+Math.random()+'\0'; |
|
var escComma = '\0COMMA'+Math.random()+'\0'; |
|
var escPeriod = '\0PERIOD'+Math.random()+'\0'; |
|
|
|
function numeric(str) { |
|
return parseInt(str, 10) == str |
|
? parseInt(str, 10) |
|
: str.charCodeAt(0); |
|
} |
|
|
|
function escapeBraces(str) { |
|
return str.split('\\\\').join(escSlash) |
|
.split('\\{').join(escOpen) |
|
.split('\\}').join(escClose) |
|
.split('\\,').join(escComma) |
|
.split('\\.').join(escPeriod); |
|
} |
|
|
|
function unescapeBraces(str) { |
|
return str.split(escSlash).join('\\') |
|
.split(escOpen).join('{') |
|
.split(escClose).join('}') |
|
.split(escComma).join(',') |
|
.split(escPeriod).join('.'); |
|
} |
|
|
|
|
|
// Basically just str.split(","), but handling cases |
|
// where we have nested braced sections, which should be |
|
// treated as individual members, like {a,{b,c},d} |
|
function parseCommaParts(str) { |
|
if (!str) |
|
return ['']; |
|
|
|
var parts = []; |
|
var m = balanced('{', '}', str); |
|
|
|
if (!m) |
|
return str.split(','); |
|
|
|
var pre = m.pre; |
|
var body = m.body; |
|
var post = m.post; |
|
var p = pre.split(','); |
|
|
|
p[p.length-1] += '{' + body + '}'; |
|
var postParts = parseCommaParts(post); |
|
if (post.length) { |
|
p[p.length-1] += postParts.shift(); |
|
p.push.apply(p, postParts); |
|
} |
|
|
|
parts.push.apply(parts, p); |
|
|
|
return parts; |
|
} |
|
|
|
function expandTop(str) { |
|
if (!str) |
|
return []; |
|
|
|
// I don't know why Bash 4.3 does this, but it does. |
|
// Anything starting with {} will have the first two bytes preserved |
|
// but *only* at the top level, so {},a}b will not expand to anything, |
|
// but a{},b}c will be expanded to [a}c,abc]. |
|
// One could argue that this is a bug in Bash, but since the goal of |
|
// this module is to match Bash's rules, we escape a leading {} |
|
if (str.substr(0, 2) === '{}') { |
|
str = '\\{\\}' + str.substr(2); |
|
} |
|
|
|
return expand(escapeBraces(str), true).map(unescapeBraces); |
|
} |
|
|
|
function identity(e) { |
|
return e; |
|
} |
|
|
|
function embrace(str) { |
|
return '{' + str + '}'; |
|
} |
|
function isPadded(el) { |
|
return /^-?0\d/.test(el); |
|
} |
|
|
|
function lte(i, y) { |
|
return i <= y; |
|
} |
|
function gte(i, y) { |
|
return i >= y; |
|
} |
|
|
|
function expand(str, isTop) { |
|
var expansions = []; |
|
|
|
var m = balanced('{', '}', str); |
|
if (!m || /\$$/.test(m.pre)) return [str]; |
|
|
|
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); |
|
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); |
|
var isSequence = isNumericSequence || isAlphaSequence; |
|
var isOptions = m.body.indexOf(',') >= 0; |
|
if (!isSequence && !isOptions) { |
|
// {a},b} |
|
if (m.post.match(/,.*\}/)) { |
|
str = m.pre + '{' + m.body + escClose + m.post; |
|
return expand(str); |
|
} |
|
return [str]; |
|
} |
|
|
|
var n; |
|
if (isSequence) { |
|
n = m.body.split(/\.\./); |
|
} else { |
|
n = parseCommaParts(m.body); |
|
if (n.length === 1) { |
|
// x{{a,b}}y ==> x{a}y x{b}y |
|
n = expand(n[0], false).map(embrace); |
|
if (n.length === 1) { |
|
var post = m.post.length |
|
? expand(m.post, false) |
|
: ['']; |
|
return post.map(function(p) { |
|
return m.pre + n[0] + p; |
|
}); |
|
} |
|
} |
|
} |
|
|
|
// at this point, n is the parts, and we know it's not a comma set |
|
// with a single entry. |
|
|
|
// no need to expand pre, since it is guaranteed to be free of brace-sets |
|
var pre = m.pre; |
|
var post = m.post.length |
|
? expand(m.post, false) |
|
: ['']; |
|
|
|
var N; |
|
|
|
if (isSequence) { |
|
var x = numeric(n[0]); |
|
var y = numeric(n[1]); |
|
var width = Math.max(n[0].length, n[1].length) |
|
var incr = n.length == 3 |
|
? Math.abs(numeric(n[2])) |
|
: 1; |
|
var test = lte; |
|
var reverse = y < x; |
|
if (reverse) { |
|
incr *= -1; |
|
test = gte; |
|
} |
|
var pad = n.some(isPadded); |
|
|
|
N = []; |
|
|
|
for (var i = x; test(i, y); i += incr) { |
|
var c; |
|
if (isAlphaSequence) { |
|
c = String.fromCharCode(i); |
|
if (c === '\\') |
|
c = ''; |
|
} else { |
|
c = String(i); |
|
if (pad) { |
|
var need = width - c.length; |
|
if (need > 0) { |
|
var z = new Array(need + 1).join('0'); |
|
if (i < 0) |
|
c = '-' + z + c.slice(1); |
|
else |
|
c = z + c; |
|
} |
|
} |
|
} |
|
N.push(c); |
|
} |
|
} else { |
|
N = concatMap(n, function(el) { return expand(el, false) }); |
|
} |
|
|
|
for (var j = 0; j < N.length; j++) { |
|
for (var k = 0; k < post.length; k++) { |
|
var expansion = pre + N[j] + post[k]; |
|
if (!isTop || isSequence || expansion) |
|
expansions.push(expansion); |
|
} |
|
} |
|
|
|
return expansions; |
|
} |
|
|
|
|
|
},{"balanced-match":4,"concat-map":6}],6:[function(require,module,exports){ |
|
module.exports = function (xs, fn) { |
|
var res = []; |
|
for (var i = 0; i < xs.length; i++) { |
|
var x = fn(xs[i], i); |
|
if (isArray(x)) res.push.apply(res, x); |
|
else res.push(x); |
|
} |
|
return res; |
|
}; |
|
|
|
var isArray = Array.isArray || function (xs) { |
|
return Object.prototype.toString.call(xs) === '[object Array]'; |
|
}; |
|
|
|
},{}],7:[function(require,module,exports){ |
|
module.exports = minimatch |
|
minimatch.Minimatch = Minimatch |
|
|
|
var path = { sep: '/' } |
|
try { |
|
path = require('path') |
|
} catch (er) {} |
|
|
|
var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {} |
|
var expand = require('brace-expansion') |
|
|
|
var plTypes = { |
|
'!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, |
|
'?': { open: '(?:', close: ')?' }, |
|
'+': { open: '(?:', close: ')+' }, |
|
'*': { open: '(?:', close: ')*' }, |
|
'@': { open: '(?:', close: ')' } |
|
} |
|
|
|
// any single thing other than / |
|
// don't need to escape / when using new RegExp() |
|
var qmark = '[^/]' |
|
|
|
// * => any number of characters |
|
var star = qmark + '*?' |
|
|
|
// ** when dots are allowed. Anything goes, except .. and . |
|
// not (^ or / followed by one or two dots followed by $ or /), |
|
// followed by anything, any number of times. |
|
var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' |
|
|
|
// not a ^ or / followed by a dot, |
|
// followed by anything, any number of times. |
|
var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' |
|
|
|
// characters that need to be escaped in RegExp. |
|
var reSpecials = charSet('().*{}+?[]^$\\!') |
|
|
|
// "abc" -> { a:true, b:true, c:true } |
|
function charSet (s) { |
|
return s.split('').reduce(function (set, c) { |
|
set[c] = true |
|
return set |
|
}, {}) |
|
} |
|
|
|
// normalizes slashes. |
|
var slashSplit = /\/+/ |
|
|
|
minimatch.filter = filter |
|
function filter (pattern, options) { |
|
options = options || {} |
|
return function (p, i, list) { |
|
return minimatch(p, pattern, options) |
|
} |
|
} |
|
|
|
function ext (a, b) { |
|
a = a || {} |
|
b = b || {} |
|
var t = {} |
|
Object.keys(b).forEach(function (k) { |
|
t[k] = b[k] |
|
}) |
|
Object.keys(a).forEach(function (k) { |
|
t[k] = a[k] |
|
}) |
|
return t |
|
} |
|
|
|
minimatch.defaults = function (def) { |
|
if (!def || !Object.keys(def).length) return minimatch |
|
|
|
var orig = minimatch |
|
|
|
var m = function minimatch (p, pattern, options) { |
|
return orig.minimatch(p, pattern, ext(def, options)) |
|
} |
|
|
|
m.Minimatch = function Minimatch (pattern, options) { |
|
return new orig.Minimatch(pattern, ext(def, options)) |
|
} |
|
|
|
return m |
|
} |
|
|
|
Minimatch.defaults = function (def) { |
|
if (!def || !Object.keys(def).length) return Minimatch |
|
return minimatch.defaults(def).Minimatch |
|
} |
|
|
|
function minimatch (p, pattern, options) { |
|
if (typeof pattern !== 'string') { |
|
throw new TypeError('glob pattern string required') |
|
} |
|
|
|
if (!options) options = {} |
|
|
|
// shortcut: comments match nothing. |
|
if (!options.nocomment && pattern.charAt(0) === '#') { |
|
return false |
|
} |
|
|
|
// "" only matches "" |
|
if (pattern.trim() === '') return p === '' |
|
|
|
return new Minimatch(pattern, options).match(p) |
|
} |
|
|
|
function Minimatch (pattern, options) { |
|
if (!(this instanceof Minimatch)) { |
|
return new Minimatch(pattern, options) |
|
} |
|
|
|
if (typeof pattern !== 'string') { |
|
throw new TypeError('glob pattern string required') |
|
} |
|
|
|
if (!options) options = {} |
|
pattern = pattern.trim() |
|
|
|
// windows support: need to use /, not \ |
|
if (path.sep !== '/') { |
|
pattern = pattern.split(path.sep).join('/') |
|
} |
|
|
|
this.options = options |
|
this.set = [] |
|
this.pattern = pattern |
|
this.regexp = null |
|
this.negate = false |
|
this.comment = false |
|
this.empty = false |
|
|
|
// make the set of regexps etc. |
|
this.make() |
|
} |
|
|
|
Minimatch.prototype.debug = function () {} |
|
|
|
Minimatch.prototype.make = make |
|
function make () { |
|
// don't do it more than once. |
|
if (this._made) return |
|
|
|
var pattern = this.pattern |
|
var options = this.options |
|
|
|
// empty patterns and comments match nothing. |
|
if (!options.nocomment && pattern.charAt(0) === '#') { |
|
this.comment = true |
|
return |
|
} |
|
if (!pattern) { |
|
this.empty = true |
|
return |
|
} |
|
|
|
// step 1: figure out negation, etc. |
|
this.parseNegate() |
|
|
|
// step 2: expand braces |
|
var set = this.globSet = this.braceExpand() |
|
|
|
if (options.debug) this.debug = console.error |
|
|
|
this.debug(this.pattern, set) |
|
|
|
// step 3: now we have a set, so turn each one into a series of path-portion |
|
// matching patterns. |
|
// These will be regexps, except in the case of "**", which is |
|
// set to the GLOBSTAR object for globstar behavior, |
|
// and will not contain any / characters |
|
set = this.globParts = set.map(function (s) { |
|
return s.split(slashSplit) |
|
}) |
|
|
|
this.debug(this.pattern, set) |
|
|
|
// glob --> regexps |
|
set = set.map(function (s, si, set) { |
|
return s.map(this.parse, this) |
|
}, this) |
|
|
|
this.debug(this.pattern, set) |
|
|
|
// filter out everything that didn't compile properly. |
|
set = set.filter(function (s) { |
|
return s.indexOf(false) === -1 |
|
}) |
|
|
|
this.debug(this.pattern, set) |
|
|
|
this.set = set |
|
} |
|
|
|
Minimatch.prototype.parseNegate = parseNegate |
|
function parseNegate () { |
|
var pattern = this.pattern |
|
var negate = false |
|
var options = this.options |
|
var negateOffset = 0 |
|
|
|
if (options.nonegate) return |
|
|
|
for (var i = 0, l = pattern.length |
|
; i < l && pattern.charAt(i) === '!' |
|
; i++) { |
|
negate = !negate |
|
negateOffset++ |
|
} |
|
|
|
if (negateOffset) this.pattern = pattern.substr(negateOffset) |
|
this.negate = negate |
|
} |
|
|
|
// Brace expansion: |
|
// a{b,c}d -> abd acd |
|
// a{b,}c -> abc ac |
|
// a{0..3}d -> a0d a1d a2d a3d |
|
// a{b,c{d,e}f}g -> abg acdfg acefg |
|
// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg |
|
// |
|
// Invalid sets are not expanded. |
|
// a{2..}b -> a{2..}b |
|
// a{b}c -> a{b}c |
|
minimatch.braceExpand = function (pattern, options) { |
|
return braceExpand(pattern, options) |
|
} |
|
|
|
Minimatch.prototype.braceExpand = braceExpand |
|
|
|
function braceExpand (pattern, options) { |
|
if (!options) { |
|
if (this instanceof Minimatch) { |
|
options = this.options |
|
} else { |
|
options = {} |
|
} |
|
} |
|
|
|
pattern = typeof pattern === 'undefined' |
|
? this.pattern : pattern |
|
|
|
if (typeof pattern === 'undefined') { |
|
throw new TypeError('undefined pattern') |
|
} |
|
|
|
if (options.nobrace || |
|
!pattern.match(/\{.*\}/)) { |
|
// shortcut. no need to expand. |
|
return [pattern] |
|
} |
|
|
|
return expand(pattern) |
|
} |
|
|
|
// parse a component of the expanded set. |
|
// At this point, no pattern may contain "/" in it |
|
// so we're going to return a 2d array, where each entry is the full |
|
// pattern, split on '/', and then turned into a regular expression. |
|
// A regexp is made at the end which joins each array with an |
|
// escaped /, and another full one which joins each regexp with |. |
|
// |
|
// Following the lead of Bash 4.1, note that "**" only has special meaning |
|
// when it is the *only* thing in a path portion. Otherwise, any series |
|
// of * is equivalent to a single *. Globstar behavior is enabled by |
|
// default, and can be disabled by setting options.noglobstar. |
|
Minimatch.prototype.parse = parse |
|
var SUBPARSE = {} |
|
function parse (pattern, isSub) { |
|
if (pattern.length > 1024 * 64) { |
|
throw new TypeError('pattern is too long') |
|
} |
|
|
|
var options = this.options |
|
|
|
// shortcuts |
|
if (!options.noglobstar && pattern === '**') return GLOBSTAR |
|
if (pattern === '') return '' |
|
|
|
var re = '' |
|
var hasMagic = !!options.nocase |
|
var escaping = false |
|
// ? => one single character |
|
var patternListStack = [] |
|
var negativeLists = [] |
|
var stateChar |
|
var inClass = false |
|
var reClassStart = -1 |
|
var classStart = -1 |
|
// . and .. never match anything that doesn't start with ., |
|
// even when options.dot is set. |
|
var patternStart = pattern.charAt(0) === '.' ? '' // anything |
|
// not (start or / followed by . or .. followed by / or end) |
|
: options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))' |
|
: '(?!\\.)' |
|
var self = this |
|
|
|
function clearStateChar () { |
|
if (stateChar) { |
|
// we had some state-tracking character |
|
// that wasn't consumed by this pass. |
|
switch (stateChar) { |
|
case '*': |
|
re += star |
|
hasMagic = true |
|
break |
|
case '?': |
|
re += qmark |
|
hasMagic = true |
|
break |
|
default: |
|
re += '\\' + stateChar |
|
break |
|
} |
|
self.debug('clearStateChar %j %j', stateChar, re) |
|
stateChar = false |
|
} |
|
} |
|
|
|
for (var i = 0, len = pattern.length, c |
|
; (i < len) && (c = pattern.charAt(i)) |
|
; i++) { |
|
this.debug('%s\t%s %s %j', pattern, i, re, c) |
|
|
|
// skip over any that are escaped. |
|
if (escaping && reSpecials[c]) { |
|
re += '\\' + c |
|
escaping = false |
|
continue |
|
} |
|
|
|
switch (c) { |
|
case '/': |
|
// completely not allowed, even escaped. |
|
// Should already be path-split by now. |
|
return false |
|
|
|
case '\\': |
|
clearStateChar() |
|
escaping = true |
|
continue |
|
|
|
// the various stateChar values |
|
// for the "extglob" stuff. |
|
case '?': |
|
case '*': |
|
case '+': |
|
case '@': |
|
case '!': |
|
this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) |
|
|
|
// all of those are literals inside a class, except that |
|
// the glob [!a] means [^a] in regexp |
|
if (inClass) { |
|
this.debug(' in class') |
|
if (c === '!' && i === classStart + 1) c = '^' |
|
re += c |
|
continue |
|
} |
|
|
|
// if we already have a stateChar, then it means |
|
// that there was something like ** or +? in there. |
|
// Handle the stateChar, then proceed with this one. |
|
self.debug('call clearStateChar %j', stateChar) |
|
clearStateChar() |
|
stateChar = c |
|
// if extglob is disabled, then +(asdf|foo) isn't a thing. |
|
// just clear the statechar *now*, rather than even diving into |
|
// the patternList stuff. |
|
if (options.noext) clearStateChar() |
|
continue |
|
|
|
case '(': |
|
if (inClass) { |
|
re += '(' |
|
continue |
|
} |
|
|
|
if (!stateChar) { |
|
re += '\\(' |
|
continue |
|
} |
|
|
|
patternListStack.push({ |
|
type: stateChar, |
|
start: i - 1, |
|
reStart: re.length, |
|
open: plTypes[stateChar].open, |
|
close: plTypes[stateChar].close |
|
}) |
|
// negation is (?:(?!js)[^/]*) |
|
re += stateChar === '!' ? '(?:(?!(?:' : '(?:' |
|
this.debug('plType %j %j', stateChar, re) |
|
stateChar = false |
|
continue |
|
|
|
case ')': |
|
if (inClass || !patternListStack.length) { |
|
re += '\\)' |
|
continue |
|
} |
|
|
|
clearStateChar() |
|
hasMagic = true |
|
var pl = patternListStack.pop() |
|
// negation is (?:(?!js)[^/]*) |
|
// The others are (?:<pattern>)<type> |
|
re += pl.close |
|
if (pl.type === '!') { |
|
negativeLists.push(pl) |
|
} |
|
pl.reEnd = re.length |
|
continue |
|
|
|
case '|': |
|
if (inClass || !patternListStack.length || escaping) { |
|
re += '\\|' |
|
escaping = false |
|
continue |
|
} |
|
|
|
clearStateChar() |
|
re += '|' |
|
continue |
|
|
|
// these are mostly the same in regexp and glob |
|
case '[': |
|
// swallow any state-tracking char before the [ |
|
clearStateChar() |
|
|
|
if (inClass) { |
|
re += '\\' + c |
|
continue |
|
} |
|
|
|
inClass = true |
|
classStart = i |
|
reClassStart = re.length |
|
re += c |
|
continue |
|
|
|
case ']': |
|
// a right bracket shall lose its special |
|
// meaning and represent itself in |
|
// a bracket expression if it occurs |
|
// first in the list. -- POSIX.2 2.8.3.2 |
|
if (i === classStart + 1 || !inClass) { |
|
re += '\\' + c |
|
escaping = false |
|
continue |
|
} |
|
|
|
// handle the case where we left a class open. |
|
// "[z-a]" is valid, equivalent to "\[z-a\]" |
|
if (inClass) { |
|
// split where the last [ was, make sure we don't have |
|
// an invalid re. if so, re-walk the contents of the |
|
// would-be class to re-translate any characters that |
|
// were passed through as-is |
|
// TODO: It would probably be faster to determine this |
|
// without a try/catch and a new RegExp, but it's tricky |
|
// to do safely. For now, this is safe and works. |
|
var cs = pattern.substring(classStart + 1, i) |
|
try { |
|
RegExp('[' + cs + ']') |
|
} catch (er) { |
|
// not a valid class! |
|
var sp = this.parse(cs, SUBPARSE) |
|
re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]' |
|
hasMagic = hasMagic || sp[1] |
|
inClass = false |
|
continue |
|
} |
|
} |
|
|
|
// finish up the class. |
|
hasMagic = true |
|
inClass = false |
|
re += c |
|
continue |
|
|
|
default: |
|
// swallow any state char that wasn't consumed |
|
clearStateChar() |
|
|
|
if (escaping) { |
|
// no need |
|
escaping = false |
|
} else if (reSpecials[c] |
|
&& !(c === '^' && inClass)) { |
|
re += '\\' |
|
} |
|
|
|
re += c |
|
|
|
} // switch |
|
} // for |
|
|
|
// handle the case where we left a class open. |
|
// "[abc" is valid, equivalent to "\[abc" |
|
if (inClass) { |
|
// split where the last [ was, and escape it |
|
// this is a huge pita. We now have to re-walk |
|
// the contents of the would-be class to re-translate |
|
// any characters that were passed through as-is |
|
cs = pattern.substr(classStart + 1) |
|
sp = this.parse(cs, SUBPARSE) |
|
re = re.substr(0, reClassStart) + '\\[' + sp[0] |
|
hasMagic = hasMagic || sp[1] |
|
} |
|
|
|
// handle the case where we had a +( thing at the *end* |
|
// of the pattern. |
|
// each pattern list stack adds 3 chars, and we need to go through |
|
// and escape any | chars that were passed through as-is for the regexp. |
|
// Go through and escape them, taking care not to double-escape any |
|
// | chars that were already escaped. |
|
for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { |
|
var tail = re.slice(pl.reStart + pl.open.length) |
|
this.debug('setting tail', re, pl) |
|
// maybe some even number of \, then maybe 1 \, followed by a | |
|
tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) { |
|
if (!$2) { |
|
// the | isn't already escaped, so escape it. |
|
$2 = '\\' |
|
} |
|
|
|
// need to escape all those slashes *again*, without escaping the |
|
// one that we need for escaping the | character. As it works out, |
|
// escaping an even number of slashes can be done by simply repeating |
|
// it exactly after itself. That's why this trick works. |
|
// |
|
// I am sorry that you have to see this. |
|
return $1 + $1 + $2 + '|' |
|
}) |
|
|
|
this.debug('tail=%j\n %s', tail, tail, pl, re) |
|
var t = pl.type === '*' ? star |
|
: pl.type === '?' ? qmark |
|
: '\\' + pl.type |
|
|
|
hasMagic = true |
|
re = re.slice(0, pl.reStart) + t + '\\(' + tail |
|
} |
|
|
|
// handle trailing things that only matter at the very end. |
|
clearStateChar() |
|
if (escaping) { |
|
// trailing \\ |
|
re += '\\\\' |
|
} |
|
|
|
// only need to apply the nodot start if the re starts with |
|
// something that could conceivably capture a dot |
|
var addPatternStart = false |
|
switch (re.charAt(0)) { |
|
case '.': |
|
case '[': |
|
case '(': addPatternStart = true |
|
} |
|
|
|
// Hack to work around lack of negative lookbehind in JS |
|
// A pattern like: *.!(x).!(y|z) needs to ensure that a name |
|
// like 'a.xyz.yz' doesn't match. So, the first negative |
|
// lookahead, has to look ALL the way ahead, to the end of |
|
// the pattern. |
|
for (var n = negativeLists.length - 1; n > -1; n--) { |
|
var nl = negativeLists[n] |
|
|
|
var nlBefore = re.slice(0, nl.reStart) |
|
var nlFirst = re.slice(nl.reStart, nl.reEnd - 8) |
|
var nlLast = re.slice(nl.reEnd - 8, nl.reEnd) |
|
var nlAfter = re.slice(nl.reEnd) |
|
|
|
nlLast += nlAfter |
|
|
|
// Handle nested stuff like *(*.js|!(*.json)), where open parens |
|
// mean that we should *not* include the ) in the bit that is considered |
|
// "after" the negated section. |
|
var openParensBefore = nlBefore.split('(').length - 1 |
|
var cleanAfter = nlAfter |
|
for (i = 0; i < openParensBefore; i++) { |
|
cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') |
|
} |
|
nlAfter = cleanAfter |
|
|
|
var dollar = '' |
|
if (nlAfter === '' && isSub !== SUBPARSE) { |
|
dollar = '$' |
|
} |
|
var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast |
|
re = newRe |
|
} |
|
|
|
// if the re is not "" at this point, then we need to make sure |
|
// it doesn't match against an empty path part. |
|
// Otherwise a/* will match a/, which it should not. |
|
if (re !== '' && hasMagic) { |
|
re = '(?=.)' + re |
|
} |
|
|
|
if (addPatternStart) { |
|
re = patternStart + re |
|
} |
|
|
|
// parsing just a piece of a larger pattern. |
|
if (isSub === SUBPARSE) { |
|
return [re, hasMagic] |
|
} |
|
|
|
// skip the regexp for non-magical patterns |
|
// unescape anything in it, though, so that it'll be |
|
// an exact match against a file etc. |
|
if (!hasMagic) { |
|
return globUnescape(pattern) |
|
} |
|
|
|
var flags = options.nocase ? 'i' : '' |
|
try { |
|
var regExp = new RegExp('^' + re + '$', flags) |
|
} catch (er) { |
|
// If it was an invalid regular expression, then it can't match |
|
// anything. This trick looks for a character after the end of |
|
// the string, which is of course impossible, except in multi-line |
|
// mode, but it's not a /m regex. |
|
return new RegExp('$.') |
|
} |
|
|
|
regExp._glob = pattern |
|
regExp._src = re |
|
|
|
return regExp |
|
} |
|
|
|
minimatch.makeRe = function (pattern, options) { |
|
return new Minimatch(pattern, options || {}).makeRe() |
|
} |
|
|
|
Minimatch.prototype.makeRe = makeRe |
|
function makeRe () { |
|
if (this.regexp || this.regexp === false) return this.regexp |
|
|
|
// at this point, this.set is a 2d array of partial |
|
// pattern strings, or "**". |
|
// |
|
// It's better to use .match(). This function shouldn't |
|
// be used, really, but it's pretty convenient sometimes, |
|
// when you just want to work with a regex. |
|
var set = this.set |
|
|
|
if (!set.length) { |
|
this.regexp = false |
|
return this.regexp |
|
} |
|
var options = this.options |
|
|
|
var twoStar = options.noglobstar ? star |
|
: options.dot ? twoStarDot |
|
: twoStarNoDot |
|
var flags = options.nocase ? 'i' : '' |
|
|
|
var re = set.map(function (pattern) { |
|
return pattern.map(function (p) { |
|
return (p === GLOBSTAR) ? twoStar |
|
: (typeof p === 'string') ? regExpEscape(p) |
|
: p._src |
|
}).join('\\\/') |
|
}).join('|') |
|
|
|
// must match entire pattern |
|
// ending in a * or ** will make it less strict. |
|
re = '^(?:' + re + ')$' |
|
|
|
// can match anything, as long as it's not this. |
|
if (this.negate) re = '^(?!' + re + ').*$' |
|
|
|
try { |
|
this.regexp = new RegExp(re, flags) |
|
} catch (ex) { |
|
this.regexp = false |
|
} |
|
return this.regexp |
|
} |
|
|
|
minimatch.match = function (list, pattern, options) { |
|
options = options || {} |
|
var mm = new Minimatch(pattern, options) |
|
list = list.filter(function (f) { |
|
return mm.match(f) |
|
}) |
|
if (mm.options.nonull && !list.length) { |
|
list.push(pattern) |
|
} |
|
return list |
|
} |
|
|
|
Minimatch.prototype.match = match |
|
function match (f, partial) { |
|
this.debug('match', f, this.pattern) |
|
// short-circuit in the case of busted things. |
|
// comments, etc. |
|
if (this.comment) return false |
|
if (this.empty) return f === '' |
|
|
|
if (f === '/' && partial) return true |
|
|
|
var options = this.options |
|
|
|
// windows: need to use /, not \ |
|
if (path.sep !== '/') { |
|
f = f.split(path.sep).join('/') |
|
} |
|
|
|
// treat the test path as a set of pathparts. |
|
f = f.split(slashSplit) |
|
this.debug(this.pattern, 'split', f) |
|
|
|
// just ONE of the pattern sets in this.set needs to match |
|
// in order for it to be valid. If negating, then just one |
|
// match means that we have failed. |
|
// Either way, return on the first hit. |
|
|
|
var set = this.set |
|
this.debug(this.pattern, 'set', set) |
|
|
|
// Find the basename of the path by looking for the last non-empty segment |
|
var filename |
|
var i |
|
for (i = f.length - 1; i >= 0; i--) { |
|
filename = f[i] |
|
if (filename) break |
|
} |
|
|
|
for (i = 0; i < set.length; i++) { |
|
var pattern = set[i] |
|
var file = f |
|
if (options.matchBase && pattern.length === 1) { |
|
file = [filename] |
|
} |
|
var hit = this.matchOne(file, pattern, partial) |
|
if (hit) { |
|
if (options.flipNegate) return true |
|
return !this.negate |
|
} |
|
} |
|
|
|
// didn't get any hits. this is success if it's a negative |
|
// pattern, failure otherwise. |
|
if (options.flipNegate) return false |
|
return this.negate |
|
} |
|
|
|
// set partial to true to test if, for example, |
|
// "/a/b" matches the start of "/*/b/*/d" |
|
// Partial means, if you run out of file before you run |
|
// out of pattern, then that's fine, as long as all |
|
// the parts match. |
|
Minimatch.prototype.matchOne = function (file, pattern, partial) { |
|
var options = this.options |
|
|
|
this.debug('matchOne', |
|
{ 'this': this, file: file, pattern: pattern }) |
|
|
|
this.debug('matchOne', file.length, pattern.length) |
|
|
|
for (var fi = 0, |
|
pi = 0, |
|
fl = file.length, |
|
pl = pattern.length |
|
; (fi < fl) && (pi < pl) |
|
; fi++, pi++) { |
|
this.debug('matchOne loop') |
|
var p = pattern[pi] |
|
var f = file[fi] |
|
|
|
this.debug(pattern, p, f) |
|
|
|
// should be impossible. |
|
// some invalid regexp stuff in the set. |
|
if (p === false) return false |
|
|
|
if (p === GLOBSTAR) { |
|
this.debug('GLOBSTAR', [pattern, p, f]) |
|
|
|
// "**" |
|
// a/**/b/**/c would match the following: |
|
// a/b/x/y/z/c |
|
// a/x/y/z/b/c |
|
// a/b/x/b/x/c |
|
// a/b/c |
|
// To do this, take the rest of the pattern after |
|
// the **, and see if it would match the file remainder. |
|
// If so, return success. |
|
// If not, the ** "swallows" a segment, and try again. |
|
// This is recursively awful. |
|
// |
|
// a/**/b/**/c matching a/b/x/y/z/c |
|
// - a matches a |
|
// - doublestar |
|
// - matchOne(b/x/y/z/c, b/**/c) |
|
// - b matches b |
|
// - doublestar |
|
// - matchOne(x/y/z/c, c) -> no |
|
// - matchOne(y/z/c, c) -> no |
|
// - matchOne(z/c, c) -> no |
|
// - matchOne(c, c) yes, hit |
|
var fr = fi |
|
var pr = pi + 1 |
|
if (pr === pl) { |
|
this.debug('** at the end') |
|
// a ** at the end will just swallow the rest. |
|
// We have found a match. |
|
// however, it will not swallow /.x, unless |
|
// options.dot is set. |
|
// . and .. are *never* matched by **, for explosively |
|
// exponential reasons. |
|
for (; fi < fl; fi++) { |
|
if (file[fi] === '.' || file[fi] === '..' || |
|
(!options.dot && file[fi].charAt(0) === '.')) return false |
|
} |
|
return true |
|
} |
|
|
|
// ok, let's see if we can swallow whatever we can. |
|
while (fr < fl) { |
|
var swallowee = file[fr] |
|
|
|
this.debug('\nglobstar while', file, fr, pattern, pr, swallowee) |
|
|
|
// XXX remove this slice. Just pass the start index. |
|
if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) { |
|
this.debug('globstar found match!', fr, fl, swallowee) |
|
// found a match. |
|
return true |
|
} else { |
|
// can't swallow "." or ".." ever. |
|
// can only swallow ".foo" when explicitly asked. |
|
if (swallowee === '.' || swallowee === '..' || |
|
(!options.dot && swallowee.charAt(0) === '.')) { |
|
this.debug('dot detected!', file, fr, pattern, pr) |
|
break |
|
} |
|
|
|
// ** swallows a segment, and continue. |
|
this.debug('globstar swallow a segment, and continue') |
|
fr++ |
|
} |
|
} |
|
|
|
// no match was found. |
|
// However, in partial mode, we can't say this is necessarily over. |
|
// If there's more *pattern* left, then |
|
if (partial) { |
|
// ran out of file |
|
this.debug('\n>>> no match, partial?', file, fr, pattern, pr) |
|
if (fr === fl) return true |
|
} |
|
return false |
|
} |
|
|
|
// something other than ** |
|
// non-magic patterns just have to match exactly |
|
// patterns with magic have been turned into regexps. |
|
var hit |
|
if (typeof p === 'string') { |
|
if (options.nocase) { |
|
hit = f.toLowerCase() === p.toLowerCase() |
|
} else { |
|
hit = f === p |
|
} |
|
this.debug('string match', p, f, hit) |
|
} else { |
|
hit = f.match(p) |
|
this.debug('pattern match', p, f, hit) |
|
} |
|
|
|
if (!hit) return false |
|
} |
|
|
|
// Note: ending in / means that we'll get a final "" |
|
// at the end of the pattern. This can only match a |
|
// corresponding "" at the end of the file. |
|
// If the file ends in /, then it can only match a |
|
// a pattern that ends in /, unless the pattern just |
|
// doesn't have any more for it. But, a/b/ should *not* |
|
// match "a/b/*", even though "" matches against the |
|
// [^/]*? pattern, except in partial mode, where it might |
|
// simply not be reached yet. |
|
// However, a/b/ should still satisfy a/* |
|
|
|
// now either we fell off the end of the pattern, or we're done. |
|
if (fi === fl && pi === pl) { |
|
// ran out of pattern and filename at the same time. |
|
// an exact hit! |
|
return true |
|
} else if (fi === fl) { |
|
// ran out of file, but still had pattern left. |
|
// this is ok if we're doing the match as part of |
|
// a glob fs traversal. |
|
return partial |
|
} else if (pi === pl) { |
|
// ran out of pattern, still have file left. |
|
// this is only acceptable if we're on the very last |
|
// empty segment of a file with a trailing slash. |
|
// a/* should match a/b/ |
|
var emptyFileEnd = (fi === fl - 1) && (file[fi] === '') |
|
return emptyFileEnd |
|
} |
|
|
|
// should be unreachable. |
|
throw new Error('wtf?') |
|
} |
|
|
|
// replace stuff like \* with * |
|
function globUnescape (s) { |
|
return s.replace(/\\(.)/g, '$1') |
|
} |
|
|
|
function regExpEscape (s) { |
|
return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') |
|
} |
|
|
|
},{"brace-expansion":5,"path":1}],8:[function(require,module,exports){ |
|
module.exports = require('./lib/business-hours'); |
|
},{"./lib/business-hours":9}],9:[function(require,module,exports){ |
|
(function (process){ |
|
var moment = require('moment'), |
|
minimatch = require('minimatch'); |
|
|
|
var localeData = require('../locale/default'); |
|
moment.updateLocale(moment.locale(), localeData); |
|
|
|
function getLocaleData(key) { |
|
return moment.localeData()['_' + key]; |
|
} |
|
|
|
function openingTimes(d) { |
|
d = d.clone(); |
|
var hours = getLocaleData('workinghours'); |
|
if (!d.isWorkingDay()) { |
|
return null; |
|
} |
|
return hours[d.day()].map(function (time) { |
|
time = time.split(':'); |
|
var _d = d.clone(); |
|
_d.hours(time[0]); |
|
_d.minutes(time[1] || 0); |
|
_d.seconds(time[2] || 0); |
|
_d.milliseconds(0); |
|
return _d; |
|
}); |
|
} |
|
|
|
function incrementDays(fn) { |
|
return function (n, d) { |
|
while (n) { |
|
d[fn](1, 'day'); |
|
if (d.isWorkingDay()) { |
|
n--; |
|
} |
|
} |
|
return d; |
|
}; |
|
} |
|
|
|
function addUnit(unit) { |
|
return function (n, d) { |
|
if (!d.isWorkingTime()) { |
|
d = d.nextWorkingTime(); |
|
} |
|
while (n > 0) { |
|
var jump = openingTimes(d)[1].diff(d, unit); |
|
if (jump > n) { |
|
jump = n; |
|
} |
|
if (jump < 1) { |
|
jump = 1; |
|
} |
|
var then = d.clone().add(jump, unit); |
|
n -= jump; |
|
if (then.isWorkingTime()) { |
|
d = d.add(jump, unit); |
|
} else { |
|
var next = then.nextWorkingTime(); |
|
var diff = then.diff(openingTimes(d)[1], unit, true); |
|
d = next.add(diff,unit); |
|
} |
|
} |
|
return d; |
|
}; |
|
} |
|
|
|
function subtractUnit(unit) { |
|
return function (n, d) { |
|
if (!d.isWorkingTime()) { |
|
d = d.lastWorkingTime(); |
|
} |
|
while (n > 0) { |
|
var jump = -1 * openingTimes(d)[0].diff(d, unit); |
|
if (jump > n) { |
|
jump = n; |
|
} |
|
if (jump < 1) { |
|
jump = 1; |
|
} |
|
var then = d.clone().subtract(jump, unit); |
|
n -= jump; |
|
if (then.isWorkingTime()) { |
|
d = d.subtract(jump, unit); |
|
} else { |
|
var next = then.lastWorkingTime(); |
|
var diff = then.diff(openingTimes(d)[0], unit, true); |
|
d = next.add(diff,unit); |
|
} |
|
} |
|
return d; |
|
}; |
|
} |
|
|
|
function copy(from, to) { |
|
['year', 'month', 'date', 'hour', 'minute', 'second', 'millisecond'].forEach(function (unit) { |
|
to.set(unit, from.get(unit)); |
|
}); |
|
return to; |
|
} |
|
|
|
|
|
function add(d, num, unit) { |
|
|
|
if(num < 0){ |
|
return subtract(d, -(num), unit); |
|
} |
|
|
|
unit = moment.normalizeUnits(unit); |
|
|
|
|
|
if (unit === 'day' ) { |
|
d = incrementDays('add')(num, d); |
|
} else if (unit) { |
|
d = addUnit(unit)(num, d); |
|
} |
|
return d; |
|
} |
|
|
|
function subtract(d, num, unit) { |
|
|
|
if(num < 0){ |
|
return add(d, -(num), unit); |
|
} |
|
unit = moment.normalizeUnits(unit); |
|
if (unit === 'day') { |
|
d = incrementDays('subtract')(num, d); |
|
} else if (unit) { |
|
d = subtractUnit(unit)(num, d); |
|
} |
|
return d; |
|
} |
|
|
|
function addOrSubtractMethod(fn) { |
|
return function (num, unit) { |
|
if (typeof unit !== 'string') { |
|
throw new Error('unit must be defined'); |
|
} |
|
if (typeof num !== 'number') { |
|
throw new Error('duration must be defined'); |
|
} |
|
var args = [].slice.call(arguments); |
|
if (args.length % 2) { |
|
throw new Error('moment#(add/subtract)WorkingTime requires an even number of arguments'); |
|
} |
|
|
|
var d = this; |
|
|
|
while (args.length >= 2) { |
|
d = fn.bind(null, d).apply(null, args.slice(-2)); |
|
args = args.slice(0, -2); |
|
} |
|
|
|
return copy(d, this); |
|
}; |
|
} |
|
|
|
moment.fn.addWorkingTime = addOrSubtractMethod(add); |
|
moment.fn.subtractWorkingTime = addOrSubtractMethod(subtract); |
|
|
|
moment.fn.isBusinessDay = function isBusinessDay() { |
|
var hours = getLocaleData('workinghours'); |
|
return !!hours[this.day()] && !this.isHoliday(); |
|
}; |
|
moment.fn.isWorkingDay = moment.fn.isBusinessDay; |
|
|
|
moment.fn.isWorkingTime = function isWorkingTime() { |
|
var openinghours = openingTimes(this); |
|
if (!openinghours) { |
|
return false; |
|
} else { |
|
return this.isSameOrAfter(openinghours[0]) && this.isSameOrBefore(openinghours[1]); |
|
} |
|
}; |
|
|
|
moment.fn.isHoliday = function isHoliday() { |
|
var isHoliday = false, |
|
today = this.format('YYYY-MM-DD'); |
|
getLocaleData('holidays').forEach(function (holiday) { |
|
if (minimatch(today, holiday)) { |
|
isHoliday = true; |
|
} |
|
}); |
|
return isHoliday; |
|
}; |
|
|
|
moment.fn.nextWorkingDay = function nextWorkingDay() { |
|
var d = this.clone(); |
|
d = d.add(1, 'day'); |
|
while (!d.isWorkingDay()) { |
|
d = d.add(1, 'day'); |
|
} |
|
return d; |
|
}; |
|
|
|
moment.fn.lastWorkingDay = function nextWorkingDay() { |
|
var d = this.clone(); |
|
d = d.subtract(1, 'day'); |
|
while (!d.isWorkingDay()) { |
|
d = d.subtract(1, 'day'); |
|
} |
|
return d; |
|
}; |
|
|
|
moment.fn.nextWorkingTime = function nextWorkingTime() { |
|
if (this.isWorkingDay()) { |
|
var openinghours = openingTimes(this); |
|
if (this.isBefore(openinghours[0])) { |
|
return openinghours[0]; |
|
} else if (this.isAfter(openinghours[1])) { |
|
return openingTimes(this.nextWorkingDay())[0]; |
|
} else { |
|
return this.clone(); |
|
} |
|
} else { |
|
return openingTimes(this.nextWorkingDay())[0]; |
|
} |
|
}; |
|
|
|
moment.fn.lastWorkingTime = function nextWorkingTime() { |
|
if (this.isWorkingDay()) { |
|
var openinghours = openingTimes(this); |
|
if (this.isAfter(openinghours[1])) { |
|
return openinghours[1]; |
|
} else if (this.isBefore(openinghours[0])) { |
|
return openingTimes(this.lastWorkingDay())[1]; |
|
} else { |
|
return this.clone(); |
|
} |
|
} else { |
|
return openingTimes(this.lastWorkingDay())[1]; |
|
} |
|
}; |
|
|
|
moment.fn.workingDiff = function workingDiff(comparator, unit, detail) { |
|
unit = unit || 'milliseconds'; |
|
unit = moment.normalizeUnits(unit); |
|
|
|
comparator = moment(comparator); |
|
|
|
if (['year', 'month', 'week'].indexOf(unit) > -1) { |
|
return this.diff(comparator, unit, detail); |
|
} |
|
|
|
// ensure `from` is always before `to` |
|
var from, to, diff = 0, multiplier = 1; |
|
if (this.isAfter(comparator)) { |
|
to = this.clone(); |
|
from = comparator.clone(); |
|
multiplier = -1; |
|
} else { |
|
to = comparator.clone(); |
|
from = this.clone(); |
|
} |
|
|
|
// normalise to nearest working times |
|
if (!from.isWorkingTime()) { |
|
from = from.nextWorkingTime(); |
|
} |
|
if (!to.isWorkingTime()) { |
|
to = to.lastWorkingTime(); |
|
} |
|
|
|
// if `from` is now after `to` then we have two timestamps on the same night, so diff is zero |
|
if (from.isAfter(to)) { |
|
return 0; |
|
} |
|
|
|
// iterate to the same day |
|
while(from.format('L') !== to.format('L')) { |
|
if (unit === 'day') { |
|
diff--; |
|
from = from.addWorkingTime(1, 'day'); |
|
} else { |
|
diff += from.diff(openingTimes(from)[1], unit, true); |
|
from = openingTimes(from.nextWorkingDay())[0]; |
|
} |
|
} |
|
|
|
if (unit !== 'day') { |
|
diff += from.diff(to, unit, true); |
|
} else if (detail) { |
|
if (process.env.NODE_ENV !== 'production') { |
|
console.warn('WARNING: passing `true` as a third argument to `workingDiff` may lead to ambiguous results'); |
|
console.warn('See https://github.com/lennym/moment-business-time/issues/12#issuecomment-199710566'); |
|
} |
|
var hours = from.diff(to, 'hour', true), |
|
denominator = comparator.isWorkingDay() ? comparator : comparator.nextWorkingDay(), |
|
total = openingTimes(denominator)[1].diff(openingTimes(denominator)[0], 'hour', true); |
|
diff += hours/total; |
|
} |
|
|
|
if(!detail) { |
|
diff = diff < 0 ? Math.ceil(diff) : Math.floor(diff); |
|
} |
|
|
|
return multiplier * diff; |
|
|
|
}; |
|
|
|
|
|
module.exports = moment; |
|
|
|
}).call(this,require('_process')) |
|
},{"../locale/default":10,"_process":2,"minimatch":7,"moment":11}],10:[function(require,module,exports){ |
|
module.exports = { |
|
workinghours: { |
|
0: null, |
|
1: ['09:00:00', '17:00:00'], |
|
2: ['09:00:00', '17:00:00'], |
|
3: ['09:00:00', '17:00:00'], |
|
4: ['09:00:00', '17:00:00'], |
|
5: ['09:00:00', '17:00:00'], |
|
6: null |
|
}, |
|
holidays: [] |
|
}; |
|
|
|
},{}],11:[function(require,module,exports){ |
|
//! moment.js |
|
|
|
;(function (global, factory) { |
|
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : |
|
typeof define === 'function' && define.amd ? define(factory) : |
|
global.moment = factory() |
|
}(this, (function () { 'use strict'; |
|
|
|
var hookCallback; |
|
|
|
function hooks () { |
|
return hookCallback.apply(null, arguments); |
|
} |
|
|
|
// This is done to register the method called with moment() |
|
// without creating circular dependencies. |
|
function setHookCallback (callback) { |
|
hookCallback = callback; |
|
} |
|
|
|
function isArray(input) { |
|
return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'; |
|
} |
|
|
|
function isObject(input) { |
|
// IE8 will treat undefined and null as object if it wasn't for |
|
// input != null |
|
return input != null && Object.prototype.toString.call(input) === '[object Object]'; |
|
} |
|
|
|
function isObjectEmpty(obj) { |
|
if (Object.getOwnPropertyNames) { |
|
return (Object.getOwnPropertyNames(obj).length === 0); |
|
} else { |
|
var k; |
|
for (k in obj) { |
|
if (obj.hasOwnProperty(k)) { |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
} |
|
|
|
function isUndefined(input) { |
|
return input === void 0; |
|
} |
|
|
|
function isNumber(input) { |
|
return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]'; |
|
} |
|
|
|
function isDate(input) { |
|
return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'; |
|
} |
|
|
|
function map(arr, fn) { |
|
var res = [], i; |
|
for (i = 0; i < arr.length; ++i) { |
|
res.push(fn(arr[i], i)); |
|
} |
|
return res; |
|
} |
|
|
|
function hasOwnProp(a, b) { |
|
return Object.prototype.hasOwnProperty.call(a, b); |
|
} |
|
|
|
function extend(a, b) { |
|
for (var i in b) { |
|
if (hasOwnProp(b, i)) { |
|
a[i] = b[i]; |
|
} |
|
} |
|
|
|
if (hasOwnProp(b, 'toString')) { |
|
a.toString = b.toString; |
|
} |
|
|
|
if (hasOwnProp(b, 'valueOf')) { |
|
a.valueOf = b.valueOf; |
|
} |
|
|
|
return a; |
|
} |
|
|
|
function createUTC (input, format, locale, strict) { |
|
return createLocalOrUTC(input, format, locale, strict, true).utc(); |
|
} |
|
|
|
function defaultParsingFlags() { |
|
// We need to deep clone this object. |
|
return { |
|
empty : false, |
|
unusedTokens : [], |
|
unusedInput : [], |
|
overflow : -2, |
|
charsLeftOver : 0, |
|
nullInput : false, |
|
invalidMonth : null, |
|
invalidFormat : false, |
|
userInvalidated : false, |
|
iso : false, |
|
parsedDateParts : [], |
|
meridiem : null, |
|
rfc2822 : false, |
|
weekdayMismatch : false |
|
}; |
|
} |
|
|
|
function getParsingFlags(m) { |
|
if (m._pf == null) { |
|
m._pf = defaultParsingFlags(); |
|
} |
|
return m._pf; |
|
} |
|
|
|
var some; |
|
if (Array.prototype.some) { |
|
some = Array.prototype.some; |
|
} else { |
|
some = function (fun) { |
|
var t = Object(this); |
|
var len = t.length >>> 0; |
|
|
|
for (var i = 0; i < len; i++) { |
|
if (i in t && fun.call(this, t[i], i, t)) { |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
}; |
|
} |
|
|
|
function isValid(m) { |
|
if (m._isValid == null) { |
|
var flags = getParsingFlags(m); |
|
var parsedParts = some.call(flags.parsedDateParts, function (i) { |
|
return i != null; |
|
}); |
|
var isNowValid = !isNaN(m._d.getTime()) && |
|
flags.overflow < 0 && |
|
!flags.empty && |
|
!flags.invalidMonth && |
|
!flags.invalidWeekday && |
|
!flags.weekdayMismatch && |
|
!flags.nullInput && |
|
!flags.invalidFormat && |
|
!flags.userInvalidated && |
|
(!flags.meridiem || (flags.meridiem && parsedParts)); |
|
|
|
if (m._strict) { |
|
isNowValid = isNowValid && |
|
flags.charsLeftOver === 0 && |
|
flags.unusedTokens.length === 0 && |
|
flags.bigHour === undefined; |
|
} |
|
|
|
if (Object.isFrozen == null || !Object.isFrozen(m)) { |
|
m._isValid = isNowValid; |
|
} |
|
else { |
|
return isNowValid; |
|
} |
|
} |
|
return m._isValid; |
|
} |
|
|
|
function createInvalid (flags) { |
|
var m = createUTC(NaN); |
|
if (flags != null) { |
|
extend(getParsingFlags(m), flags); |
|
} |
|
else { |
|
getParsingFlags(m).userInvalidated = true; |
|
} |
|
|
|
return m; |
|
} |
|
|
|
// Plugins that add properties should also add the key here (null value), |
|
// so we can properly clone ourselves. |
|
var momentProperties = hooks.momentProperties = []; |
|
|
|
function copyConfig(to, from) { |
|
var i, prop, val; |
|
|
|
if (!isUndefined(from._isAMomentObject)) { |
|
to._isAMomentObject = from._isAMomentObject; |
|
} |
|
if (!isUndefined(from._i)) { |
|
to._i = from._i; |
|
} |
|
if (!isUndefined(from._f)) { |
|
to._f = from._f; |
|
} |
|
if (!isUndefined(from._l)) { |
|
to._l = from._l; |
|
} |
|
if (!isUndefined(from._strict)) { |
|
to._strict = from._strict; |
|
} |
|
if (!isUndefined(from._tzm)) { |
|
to._tzm = from._tzm; |
|
} |
|
if (!isUndefined(from._isUTC)) { |
|
to._isUTC = from._isUTC; |
|
} |
|
if (!isUndefined(from._offset)) { |
|
to._offset = from._offset; |
|
} |
|
if (!isUndefined(from._pf)) { |
|
to._pf = getParsingFlags(from); |
|
} |
|
if (!isUndefined(from._locale)) { |
|
to._locale = from._locale; |
|
} |
|
|
|
if (momentProperties.length > 0) { |
|
for (i = 0; i < momentProperties.length; i++) { |
|
prop = momentProperties[i]; |
|
val = from[prop]; |
|
if (!isUndefined(val)) { |
|
to[prop] = val; |
|
} |
|
} |
|
} |
|
|
|
return to; |
|
} |
|
|
|
var updateInProgress = false; |
|
|
|
// Moment prototype object |
|
function Moment(config) { |
|
copyConfig(this, config); |
|
this._d = new Date(config._d != null ? config._d.getTime() : NaN); |
|
if (!this.isValid()) { |
|
this._d = new Date(NaN); |
|
} |
|
// Prevent infinite loop in case updateOffset creates new moment |
|
// objects. |
|
if (updateInProgress === false) { |
|
updateInProgress = true; |
|
hooks.updateOffset(this); |
|
updateInProgress = false; |
|
} |
|
} |
|
|
|
function isMoment (obj) { |
|
return obj instanceof Moment || (obj != null && obj._isAMomentObject != null); |
|
} |
|
|
|
function absFloor (number) { |
|
if (number < 0) { |
|
// -0 -> 0 |
|
return Math.ceil(number) || 0; |
|
} else { |
|
return Math.floor(number); |
|
} |
|
} |
|
|
|
function toInt(argumentForCoercion) { |
|
var coercedNumber = +argumentForCoercion, |
|
value = 0; |
|
|
|
if (coercedNumber !== 0 && isFinite(coercedNumber)) { |
|
value = absFloor(coercedNumber); |
|
} |
|
|
|
return value; |
|
} |
|
|
|
// compare two arrays, return the number of differences |
|
function compareArrays(array1, array2, dontConvert) { |
|
var len = Math.min(array1.length, array2.length), |
|
lengthDiff = Math.abs(array1.length - array2.length), |
|
diffs = 0, |
|
i; |
|
for (i = 0; i < len; i++) { |
|
if ((dontConvert && array1[i] !== array2[i]) || |
|
(!dontConvert |