7257 lines
730 KiB
JavaScript
7257 lines
730 KiB
JavaScript
|
(function (f) {
|
|||
|
|
if (typeof exports === "object" && typeof module !== "undefined") {
|
|||
|
|
module.exports = f();
|
|||
|
|
} else if (typeof define === "function" && define.amd) {
|
|||
|
|
define([], f);
|
|||
|
|
} else {
|
|||
|
|
var g;
|
|||
|
|
if (typeof window !== "undefined") {
|
|||
|
|
g = window;
|
|||
|
|
} else if (typeof global !== "undefined") {
|
|||
|
|
g = global;
|
|||
|
|
} else if (typeof self !== "undefined") {
|
|||
|
|
g = self;
|
|||
|
|
} else {
|
|||
|
|
g = this;
|
|||
|
|
}
|
|||
|
|
(g.lunr || (g.lunr = {})).wordcut = f();
|
|||
|
|
}
|
|||
|
|
})(function () {
|
|||
|
|
var define, module, exports;
|
|||
|
|
return (function e(t, n, r) {
|
|||
|
|
function s(o, u) {
|
|||
|
|
if (!n[o]) {
|
|||
|
|
if (!t[o]) {
|
|||
|
|
var a = typeof require == "function" && require;
|
|||
|
|
if (!u && a) return a(o, !0);
|
|||
|
|
if (i) return i(o, !0);
|
|||
|
|
var f = new Error("Cannot find module '" + o + "'");
|
|||
|
|
throw ((f.code = "MODULE_NOT_FOUND"), f);
|
|||
|
|
}
|
|||
|
|
var l = (n[o] = { exports: {} });
|
|||
|
|
t[o][0].call(
|
|||
|
|
l.exports,
|
|||
|
|
function (e) {
|
|||
|
|
var n = t[o][1][e];
|
|||
|
|
return s(n ? n : e);
|
|||
|
|
},
|
|||
|
|
l,
|
|||
|
|
l.exports,
|
|||
|
|
e,
|
|||
|
|
t,
|
|||
|
|
n,
|
|||
|
|
r
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
return n[o].exports;
|
|||
|
|
}
|
|||
|
|
var i = typeof require == "function" && require;
|
|||
|
|
for (var o = 0; o < r.length; o++) s(r[o]);
|
|||
|
|
return s;
|
|||
|
|
})(
|
|||
|
|
{
|
|||
|
|
1: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var _ = require("underscore");
|
|||
|
|
|
|||
|
|
var Acceptors = {
|
|||
|
|
creators: null,
|
|||
|
|
current: null,
|
|||
|
|
tag: null,
|
|||
|
|
|
|||
|
|
init: function () {
|
|||
|
|
this.creators = [];
|
|||
|
|
this.current = [];
|
|||
|
|
this.tag = {};
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
reset: function () {
|
|||
|
|
this.current = [];
|
|||
|
|
this.tag = {};
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
transit: function (ch) {
|
|||
|
|
var self = this;
|
|||
|
|
|
|||
|
|
self.creators.forEach(function (creator) {
|
|||
|
|
var acceptor = creator.createAcceptor(self.tag);
|
|||
|
|
if (acceptor) self.current.push(acceptor);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
var _current = [];
|
|||
|
|
self.tag = {};
|
|||
|
|
|
|||
|
|
for (var i = 0; i < self.current.length; i++) {
|
|||
|
|
var _acceptor = self.current[i],
|
|||
|
|
acceptor = _acceptor.transit(ch);
|
|||
|
|
|
|||
|
|
if (!acceptor.isError) {
|
|||
|
|
_current.push(acceptor);
|
|||
|
|
self.tag[acceptor.tag] = acceptor;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
self.current = _current;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
getFinalAcceptors: function () {
|
|||
|
|
return this.current.filter(function (acceptor) {
|
|||
|
|
return acceptor.isFinal;
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports = function () {
|
|||
|
|
var acceptors = _.clone(Acceptors);
|
|||
|
|
acceptors.init();
|
|||
|
|
return acceptors;
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{ underscore: 25 },
|
|||
|
|
],
|
|||
|
|
2: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (__dirname) {
|
|||
|
|
var LEFT = 0;
|
|||
|
|
var RIGHT = 1;
|
|||
|
|
var path = require("path");
|
|||
|
|
var glob = require("glob");
|
|||
|
|
|
|||
|
|
var WordcutDict = {
|
|||
|
|
init: function (dictPathFile, withDefault, words) {
|
|||
|
|
withDefault = withDefault || false;
|
|||
|
|
defaultDict =
|
|||
|
|
path.normalize(__dirname + "/..") + "/data/tdict-*.txt";
|
|||
|
|
this.dict = [];
|
|||
|
|
var dictPathIsDefined = dictPathFile !== undefined;
|
|||
|
|
var dictPath =
|
|||
|
|
withDefault || !dictPathIsDefined ? [defaultDict] : [];
|
|||
|
|
var dictPathFile = dictPathFile || defaultDict;
|
|||
|
|
|
|||
|
|
if (dictPathIsDefined) {
|
|||
|
|
if (Array.isArray(dictPathFile)) {
|
|||
|
|
dictPath.concat.apply(dictPath, dictPathFile);
|
|||
|
|
} else {
|
|||
|
|
dictPath.push(dictPathFile);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.addFiles(dictPath, false);
|
|||
|
|
|
|||
|
|
if (words !== undefined) {
|
|||
|
|
this.addWords(words, false);
|
|||
|
|
}
|
|||
|
|
this.finalizeDict();
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addWords: function (words, finalize) {
|
|||
|
|
finalize = finalize === undefined || finalize;
|
|||
|
|
this.dict.push.apply(this.dict, words);
|
|||
|
|
if (finalize) {
|
|||
|
|
this.finalizeDict();
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
finalizeDict: function () {
|
|||
|
|
this.dict = this.sortuniq(this.dict);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
addFiles: function (files, finalize) {
|
|||
|
|
finalize = finalize === undefined || finalize;
|
|||
|
|
|
|||
|
|
for (var i = 0; i < 1; i++) {
|
|||
|
|
words = "ก.ก.\nก.ก.น.\nก.ข.ค.\nก.ค.\nก.จ.\nก.ช.น.\nก.ฌ.\nก.ต.\nก.ต.ง.\nก.ต.ช.\nก.ตร.\nก.ท.\nก.น.ช.\nก.บช.\nก.บถ.\nก.ป.ส.\nก.พ.\nก.ม.\nก.ย.\nก.ร.\nก.ล.ต.\nก.ว.\nก.ศ.ว.\nก.ส.ท.\nก.ส.ธ.\nก.ส.อ.\nก.อ.\nกก.ตชด.\nกก.ตร.น.\nกก.ภ.จว.\nกก.รสช.\nกกบ.ขส.ทบ.\nกกล.รพน.\nกง.กห.\nกง.ทบ.\nกง.ทร.\nกซข.ป.\nกซม.ป.\nกทม.กรุงเทพมหานคร\nกบ.ทบ.\nกป.สป.\nกพ.ทบ.\nกพ.ทร.\nกพ.ทหาร\nกร.ทบ.\nกรป.กลาง\nกรอ.พอ.\nกศ.ด.\nกศ.บ.\nกศ.บป.\nกศ.ม.\nกษ.ด.\nกษ.บ.\nกษ.ม.\nกส.ด.\nกส.ทบ.\nกส.บ.\nกส.ม.\nกอ.ปค.\nกอ.รพน.\nกอ.รมน.\nกอ.รสต.\nข.ต.ว.\nขว.ทบ.\nขว.ทร.\nขว.ทหาร\nขส.ทบ.\nขส.ทร.\nขส.ทอ.\nค.ด.\nค.บ.\nค.พ.ศ.\nค.ม.\nค.ร.น.\nค.ร.ฟ.\nค.ร.ม.\nค.ศ.\nค.อ.ด.\nค.อ.บ.\nค.อ.ม.\nคศ.ด.\nคศ.บ.\nคศ.ม.\nง.ด.\nจ.จ.\nจ.จ.จ.\nจ.ช.\nจ.ต.\nจ.ท.\nจ.ป.ร.\nจ.ม.\nจ.ศ.\nจ.ส.ต.\nจ.ส.ท.\nจ.ส.อ.\nจ.อ.\nจ.อ.ร.\nจ.๑๘\nจก.ธน.\nจก.สน.\nช.ค.\nช.ค.บ.\nช.พ.ค.\nช.ส.\nช.ส.ค.\nฌ.ป.ค.\nฌ.ศ.ร.\nฌ.ส.อ.\nฐท.สห.\nด.ช.\nด.ญ.\nด.ต.\nด.ศ.ค.\nด.ศ.ร.\nดย.ทร.\nต.ก.\nต.ค.\nต.จ.\nต.จ.ว.\nต.ช.\nต.ต.\nต.บ.\nต.ม.\nต.ร.\nต.ศ.ร.\nต.ห.\nต.อ.\nต.อ.จ.\nตร.กม.\nตร.ซม.\nตร.ต.\nตร.ทล.\nตร.น.\nตร.ปม.\nตร.ภ.\nตร.ม.\nตร.รฟ.\nตร.ว.\nตร.ส.\nตร.สข.\nท.จ.\nท.จ.ว.\nท.ช.\nท.ญ.\nท.ด.\nท.ท.ท.\nท.ทบ.\nท.บ.\nท.พ.\nท.ม.\nท.ศ.\nทก.ด.\nทก.บ.\nทก.ม.\nทส.ปช.\nทส.รมว.กห.\nทุ.ส.นิ.ม.\nธ.ก.ส.\nธ.ค.\nธ.ญ\nธ.บ.\nน.ช.\nน.ญ.\nน.ด.\nน.ต.\nน.ท.\nน.น.\nน.บ.\nน.บ.ท.\nน.ป.ท.\nน.พ.\nน.ม.\nน.ร.\nน.ว.\nน.ศ.\nน.ส.\nน.ส.พ.\nน.ส.๓\nน.สพ.\nน.อ.\nนปพ.ภ.\nนศ.ด.\nนศ.บ.\nนศ.ม.\nบ.ก.\nบ.ข.ส.\nบ.ช.\nบ.ด.ท.\nบ.ตร.\nบ.ภ.\nบ.ม.\nบก.จร.\nบก.ตชด.\nบก.ตม.\nบก.ทล.\nบก.น.\nบก.ป.\nบก.ปค.\nบก.ปม.\nบก.ภ.เขต\nบก.รน.\nบก.รฟ.\nบก.ร้อย.ตชด.\nบก.ส.\nบกข.ป.\nบจพ.ป.\nบช.ก.\nบช.ด.\nบช.ตชด.\nบช.น.\nบช.บ.\nบช.ปส.\nบช.ภ.\nบช.ม.\nบชท.ป.\nบชน.ป.\nบชส.ป.\nบธ.ด.\nบธ.บ.\nบธ.ม.\nบนท.ป.\nบนอ.ป.\nบปช.ป.\nป.กท.\nป.กศ.\nป.กศ.สูง\nป.จ.\nป.จ.ว.\nป.ช.\nป.ธ.\nป.ป.\nป.ป.ก.\nป.ป.ช.\nป.ป.ป.\nป.ป.ร.\nป.ป.ส.\nป.พ.\nป.พ.พ.\nป.พย.\nป.ม.\nป.ม.ก.\nป.ม.ช.\nป.ม.ธ.\nป.ม.ศ.\nป.ม.อ.\nป.ร.ร.๔\nป.ร.ร.๕\nป.ร.ร.๖\nป.ล.\nป.ว.พ.\nป.วิ.อ.\nป.ส.ส.\nป.อ.\nป.อ.ร.ส.\nป.๑\nปม.วส.\nปอ.พ.\nผกก.ภ.\nผช.ผอ.\nผต.มท.\nผบ.ตร.\nผบ.ทบ.\nผบ.ทร.\nผบ.ทสส.\nผบ.ทอ.\nผบก.น.\nผบก.ป.\nผบก.ปค.\nผบก.ปม.\nผบก.ภ.\nผบช.ก.\nผบช.ตชด.\nผบช.น.\nผบช.ภ.\nผว.กทม.\nผอ.ปจ.\nพ.ก.ง.\nพ.กศ.\nพ.ข.ต.\nพ.ค.\nพ.ค.ช.\nพ.ค.ว.\nพ.ค.ศ.\nพ.จ.ต.\nพ.จ.ท.\nพ.จ.อ.\nพ.ช.\nพ.ช.ค.\nพ.ด.\nพ.ต.\nพ.ต.ต.\nพ.ต.ท.\n<EFBFBD>
|
|||
|
|
.split(/[\r\n]+/)
|
|||
|
|
.filter(function (w) {
|
|||
|
|
return w.length > 1;
|
|||
|
|
});
|
|||
|
|
this.addWords(words, false);
|
|||
|
|
}
|
|||
|
|
if (finalize) {
|
|||
|
|
this.finalizeDict();
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
dictSeek: function (l, r, ch, strOffset, pos) {
|
|||
|
|
var ans = null;
|
|||
|
|
while (l <= r) {
|
|||
|
|
var m = Math.floor((l + r) / 2),
|
|||
|
|
dict_item = this.dict[m],
|
|||
|
|
len = dict_item.length;
|
|||
|
|
if (len <= strOffset) {
|
|||
|
|
l = m + 1;
|
|||
|
|
} else {
|
|||
|
|
var ch_ = dict_item[strOffset];
|
|||
|
|
if (ch_ < ch) {
|
|||
|
|
l = m + 1;
|
|||
|
|
} else if (ch_ > ch) {
|
|||
|
|
r = m - 1;
|
|||
|
|
} else {
|
|||
|
|
ans = m;
|
|||
|
|
if (pos == LEFT) {
|
|||
|
|
r = m - 1;
|
|||
|
|
} else {
|
|||
|
|
l = m + 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return ans;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
isFinal: function (acceptor) {
|
|||
|
|
return this.dict[acceptor.l].length == acceptor.strOffset;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
createAcceptor: function () {
|
|||
|
|
return {
|
|||
|
|
l: 0,
|
|||
|
|
r: this.dict.length - 1,
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
dict: this,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
return this.dict.transit(this, ch);
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "DICT",
|
|||
|
|
w: 1,
|
|||
|
|
type: "DICT",
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
transit: function (acceptor, ch) {
|
|||
|
|
var l = this.dictSeek(
|
|||
|
|
acceptor.l,
|
|||
|
|
acceptor.r,
|
|||
|
|
ch,
|
|||
|
|
acceptor.strOffset,
|
|||
|
|
LEFT
|
|||
|
|
);
|
|||
|
|
if (l !== null) {
|
|||
|
|
var r = this.dictSeek(
|
|||
|
|
l,
|
|||
|
|
acceptor.r,
|
|||
|
|
ch,
|
|||
|
|
acceptor.strOffset,
|
|||
|
|
RIGHT
|
|||
|
|
);
|
|||
|
|
acceptor.l = l;
|
|||
|
|
acceptor.r = r;
|
|||
|
|
acceptor.strOffset++;
|
|||
|
|
acceptor.isFinal = this.isFinal(acceptor);
|
|||
|
|
} else {
|
|||
|
|
acceptor.isError = true;
|
|||
|
|
}
|
|||
|
|
return acceptor;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
sortuniq: function (a) {
|
|||
|
|
return a.sort().filter(function (item, pos, arr) {
|
|||
|
|
return !pos || item != arr[pos - 1];
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
flatten: function (a) {
|
|||
|
|
//[[1,2],[3]] -> [1,2,3]
|
|||
|
|
return [].concat.apply([], a);
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
module.exports = WordcutDict;
|
|||
|
|
}.call(this, "/dist/tmp"));
|
|||
|
|
},
|
|||
|
|
{ glob: 16, path: 22 },
|
|||
|
|
],
|
|||
|
|
3: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var WordRule = {
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
if (tag["WORD_RULE"]) return null;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
var lch = ch.toLowerCase();
|
|||
|
|
if (lch >= "a" && lch <= "z") {
|
|||
|
|
this.isFinal = true;
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "WORD_RULE",
|
|||
|
|
type: "WORD_RULE",
|
|||
|
|
w: 1,
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var NumberRule = {
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
if (tag["NUMBER_RULE"]) return null;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
if (ch >= "0" && ch <= "9") {
|
|||
|
|
this.isFinal = true;
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "NUMBER_RULE",
|
|||
|
|
type: "NUMBER_RULE",
|
|||
|
|
w: 1,
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var SpaceRule = {
|
|||
|
|
tag: "SPACE_RULE",
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
if (tag["SPACE_RULE"]) return null;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
if (
|
|||
|
|
ch == " " ||
|
|||
|
|
ch == "\t" ||
|
|||
|
|
ch == "\r" ||
|
|||
|
|
ch == "\n" ||
|
|||
|
|
ch == "\u00A0" ||
|
|||
|
|
ch == "\u2003" //nbsp and emsp
|
|||
|
|
) {
|
|||
|
|
this.isFinal = true;
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: SpaceRule.tag,
|
|||
|
|
w: 1,
|
|||
|
|
type: "SPACE_RULE",
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var SingleSymbolRule = {
|
|||
|
|
tag: "SINSYM",
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
if (this.strOffset == 0 && ch.match(/^[\@\(\)\/\,\-\."`]$/)) {
|
|||
|
|
this.isFinal = true;
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "SINSYM",
|
|||
|
|
w: 1,
|
|||
|
|
type: "SINSYM",
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var LatinRules = [WordRule, SpaceRule, SingleSymbolRule, NumberRule];
|
|||
|
|
|
|||
|
|
module.exports = LatinRules;
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
4: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var _ = require("underscore"),
|
|||
|
|
WordcutCore = require("./wordcut_core");
|
|||
|
|
var PathInfoBuilder = {
|
|||
|
|
/*
|
|||
|
|
buildByPartAcceptors: function(path, acceptors, i) {
|
|||
|
|
var
|
|||
|
|
var genInfos = partAcceptors.reduce(function(genInfos, acceptor) {
|
|||
|
|
|
|||
|
|
}, []);
|
|||
|
|
|
|||
|
|
return genInfos;
|
|||
|
|
}
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
buildByAcceptors: function (path, finalAcceptors, i) {
|
|||
|
|
var self = this;
|
|||
|
|
var infos = finalAcceptors.map(function (acceptor) {
|
|||
|
|
var p = i - acceptor.strOffset + 1,
|
|||
|
|
_info = path[p];
|
|||
|
|
|
|||
|
|
var info = {
|
|||
|
|
p: p,
|
|||
|
|
mw: _info.mw + (acceptor.mw === undefined ? 0 : acceptor.mw),
|
|||
|
|
w: acceptor.w + _info.w,
|
|||
|
|
unk: (acceptor.unk ? acceptor.unk : 0) + _info.unk,
|
|||
|
|
type: acceptor.type,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
if (acceptor.type == "PART") {
|
|||
|
|
for (var j = p + 1; j <= i; j++) {
|
|||
|
|
path[j].merge = p;
|
|||
|
|
}
|
|||
|
|
info.merge = p;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return info;
|
|||
|
|
});
|
|||
|
|
return infos.filter(function (info) {
|
|||
|
|
return info;
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
fallback: function (path, leftBoundary, text, i) {
|
|||
|
|
var _info = path[leftBoundary];
|
|||
|
|
if (text[i].match(/[\u0E48-\u0E4E]/)) {
|
|||
|
|
if (leftBoundary != 0) leftBoundary = path[leftBoundary].p;
|
|||
|
|
return {
|
|||
|
|
p: leftBoundary,
|
|||
|
|
mw: 0,
|
|||
|
|
w: 1 + _info.w,
|
|||
|
|
unk: 1 + _info.unk,
|
|||
|
|
type: "UNK",
|
|||
|
|
};
|
|||
|
|
/* } else if(leftBoundary > 0 && path[leftBoundary].type !== "UNK") {
|
|||
|
|
leftBoundary = path[leftBoundary].p;
|
|||
|
|
return {p: leftBoundary,
|
|||
|
|
w: 1 + _info.w,
|
|||
|
|
unk: 1 + _info.unk,
|
|||
|
|
type: "UNK"}; */
|
|||
|
|
} else {
|
|||
|
|
return {
|
|||
|
|
p: leftBoundary,
|
|||
|
|
mw: _info.mw,
|
|||
|
|
w: 1 + _info.w,
|
|||
|
|
unk: 1 + _info.unk,
|
|||
|
|
type: "UNK",
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
build: function (path, finalAcceptors, i, leftBoundary, text) {
|
|||
|
|
var basicPathInfos = this.buildByAcceptors(
|
|||
|
|
path,
|
|||
|
|
finalAcceptors,
|
|||
|
|
i
|
|||
|
|
);
|
|||
|
|
if (basicPathInfos.length > 0) {
|
|||
|
|
return basicPathInfos;
|
|||
|
|
} else {
|
|||
|
|
return [this.fallback(path, leftBoundary, text, i)];
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports = function () {
|
|||
|
|
return _.clone(PathInfoBuilder);
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{ "./wordcut_core": 8, underscore: 25 },
|
|||
|
|
],
|
|||
|
|
5: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var _ = require("underscore");
|
|||
|
|
|
|||
|
|
var PathSelector = {
|
|||
|
|
selectPath: function (paths) {
|
|||
|
|
var path = paths.reduce(function (selectedPath, path) {
|
|||
|
|
if (selectedPath == null) {
|
|||
|
|
return path;
|
|||
|
|
} else {
|
|||
|
|
if (path.unk < selectedPath.unk) return path;
|
|||
|
|
if (path.unk == selectedPath.unk) {
|
|||
|
|
if (path.mw < selectedPath.mw) return path;
|
|||
|
|
if (path.mw == selectedPath.mw) {
|
|||
|
|
if (path.w < selectedPath.w) return path;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return selectedPath;
|
|||
|
|
}
|
|||
|
|
}, null);
|
|||
|
|
return path;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
createPath: function () {
|
|||
|
|
return [{ p: null, w: 0, unk: 0, type: "INIT", mw: 0 }];
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports = function () {
|
|||
|
|
return _.clone(PathSelector);
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{ underscore: 25 },
|
|||
|
|
],
|
|||
|
|
6: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
function isMatch(pat, offset, ch) {
|
|||
|
|
if (pat.length <= offset) return false;
|
|||
|
|
var _ch = pat[offset];
|
|||
|
|
return (
|
|||
|
|
_ch == ch ||
|
|||
|
|
(_ch.match(/[กข]/) && ch.match(/[ก-ฮ]/)) ||
|
|||
|
|
(_ch.match(/[มบ]/) && ch.match(/[ก-ฮ]/)) ||
|
|||
|
|
(_ch.match(/\u0E49/) && ch.match(/[\u0E48-\u0E4B]/))
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var Rule0 = {
|
|||
|
|
pat: "เหก็ม",
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
if (isMatch(Rule0.pat, this.strOffset, ch)) {
|
|||
|
|
this.isFinal = this.strOffset + 1 == Rule0.pat.length;
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "THAI_RULE",
|
|||
|
|
type: "THAI_RULE",
|
|||
|
|
w: 1,
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var PartRule = {
|
|||
|
|
createAcceptor: function (tag) {
|
|||
|
|
return {
|
|||
|
|
strOffset: 0,
|
|||
|
|
patterns: ["แก", "เก", "ก้", "กก์", "กา", "กี", "กิ", "กืก"],
|
|||
|
|
isFinal: false,
|
|||
|
|
transit: function (ch) {
|
|||
|
|
var offset = this.strOffset;
|
|||
|
|
this.patterns = this.patterns.filter(function (pat) {
|
|||
|
|
return isMatch(pat, offset, ch);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
if (this.patterns.length > 0) {
|
|||
|
|
var len = 1 + offset;
|
|||
|
|
this.isFinal = this.patterns.some(function (pat) {
|
|||
|
|
return pat.length == len;
|
|||
|
|
});
|
|||
|
|
this.strOffset++;
|
|||
|
|
} else {
|
|||
|
|
this.isError = true;
|
|||
|
|
}
|
|||
|
|
return this;
|
|||
|
|
},
|
|||
|
|
isError: false,
|
|||
|
|
tag: "PART",
|
|||
|
|
type: "PART",
|
|||
|
|
unk: 1,
|
|||
|
|
w: 1,
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var ThaiRules = [Rule0, PartRule];
|
|||
|
|
|
|||
|
|
module.exports = ThaiRules;
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
7: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var sys = require("sys"),
|
|||
|
|
WordcutDict = require("./dict"),
|
|||
|
|
WordcutCore = require("./wordcut_core"),
|
|||
|
|
PathInfoBuilder = require("./path_info_builder"),
|
|||
|
|
PathSelector = require("./path_selector"),
|
|||
|
|
Acceptors = require("./acceptors"),
|
|||
|
|
latinRules = require("./latin_rules"),
|
|||
|
|
thaiRules = require("./thai_rules"),
|
|||
|
|
_ = require("underscore");
|
|||
|
|
|
|||
|
|
var Wordcut = Object.create(WordcutCore);
|
|||
|
|
Wordcut.defaultPathInfoBuilder = PathInfoBuilder;
|
|||
|
|
Wordcut.defaultPathSelector = PathSelector;
|
|||
|
|
Wordcut.defaultAcceptors = Acceptors;
|
|||
|
|
Wordcut.defaultLatinRules = latinRules;
|
|||
|
|
Wordcut.defaultThaiRules = thaiRules;
|
|||
|
|
Wordcut.defaultDict = WordcutDict;
|
|||
|
|
|
|||
|
|
Wordcut.initNoDict = function (dict_path) {
|
|||
|
|
var self = this;
|
|||
|
|
self.pathInfoBuilder = new self.defaultPathInfoBuilder();
|
|||
|
|
self.pathSelector = new self.defaultPathSelector();
|
|||
|
|
self.acceptors = new self.defaultAcceptors();
|
|||
|
|
self.defaultLatinRules.forEach(function (rule) {
|
|||
|
|
self.acceptors.creators.push(rule);
|
|||
|
|
});
|
|||
|
|
self.defaultThaiRules.forEach(function (rule) {
|
|||
|
|
self.acceptors.creators.push(rule);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Wordcut.init = function (dict_path, withDefault, additionalWords) {
|
|||
|
|
withDefault = withDefault || false;
|
|||
|
|
this.initNoDict();
|
|||
|
|
var dict = _.clone(this.defaultDict);
|
|||
|
|
dict.init(dict_path, withDefault, additionalWords);
|
|||
|
|
this.acceptors.creators.push(dict);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports = Wordcut;
|
|||
|
|
},
|
|||
|
|
{
|
|||
|
|
"./acceptors": 1,
|
|||
|
|
"./dict": 2,
|
|||
|
|
"./latin_rules": 3,
|
|||
|
|
"./path_info_builder": 4,
|
|||
|
|
"./path_selector": 5,
|
|||
|
|
"./thai_rules": 6,
|
|||
|
|
"./wordcut_core": 8,
|
|||
|
|
sys: 28,
|
|||
|
|
underscore: 25,
|
|||
|
|
},
|
|||
|
|
],
|
|||
|
|
8: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var WordcutCore = {
|
|||
|
|
buildPath: function (text) {
|
|||
|
|
var self = this,
|
|||
|
|
path = self.pathSelector.createPath(),
|
|||
|
|
leftBoundary = 0;
|
|||
|
|
self.acceptors.reset();
|
|||
|
|
for (var i = 0; i < text.length; i++) {
|
|||
|
|
var ch = text[i];
|
|||
|
|
self.acceptors.transit(ch);
|
|||
|
|
|
|||
|
|
var possiblePathInfos = self.pathInfoBuilder.build(
|
|||
|
|
path,
|
|||
|
|
self.acceptors.getFinalAcceptors(),
|
|||
|
|
i,
|
|||
|
|
leftBoundary,
|
|||
|
|
text
|
|||
|
|
);
|
|||
|
|
var selectedPath = self.pathSelector.selectPath(
|
|||
|
|
possiblePathInfos
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
path.push(selectedPath);
|
|||
|
|
if (selectedPath.type !== "UNK") {
|
|||
|
|
leftBoundary = i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return path;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
pathToRanges: function (path) {
|
|||
|
|
var e = path.length - 1,
|
|||
|
|
ranges = [];
|
|||
|
|
|
|||
|
|
while (e > 0) {
|
|||
|
|
var info = path[e],
|
|||
|
|
s = info.p;
|
|||
|
|
|
|||
|
|
if (info.merge !== undefined && ranges.length > 0) {
|
|||
|
|
var r = ranges[ranges.length - 1];
|
|||
|
|
r.s = info.merge;
|
|||
|
|
s = r.s;
|
|||
|
|
} else {
|
|||
|
|
ranges.push({ s: s, e: e });
|
|||
|
|
}
|
|||
|
|
e = s;
|
|||
|
|
}
|
|||
|
|
return ranges.reverse();
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
rangesToText: function (text, ranges, delimiter) {
|
|||
|
|
return ranges
|
|||
|
|
.map(function (r) {
|
|||
|
|
return text.substring(r.s, r.e);
|
|||
|
|
})
|
|||
|
|
.join(delimiter);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
cut: function (text, delimiter) {
|
|||
|
|
var path = this.buildPath(text),
|
|||
|
|
ranges = this.pathToRanges(path);
|
|||
|
|
return this.rangesToText(
|
|||
|
|
text,
|
|||
|
|
ranges,
|
|||
|
|
delimiter === undefined ? "|" : delimiter
|
|||
|
|
);
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
cutIntoRanges: function (text, noText) {
|
|||
|
|
var path = this.buildPath(text),
|
|||
|
|
ranges = this.pathToRanges(path);
|
|||
|
|
|
|||
|
|
if (!noText) {
|
|||
|
|
ranges.forEach(function (r) {
|
|||
|
|
r.text = text.substring(r.s, r.e);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
return ranges;
|
|||
|
|
},
|
|||
|
|
|
|||
|
|
cutIntoArray: function (text) {
|
|||
|
|
var path = this.buildPath(text),
|
|||
|
|
ranges = this.pathToRanges(path);
|
|||
|
|
|
|||
|
|
return ranges.map(function (r) {
|
|||
|
|
return text.substring(r.s, r.e);
|
|||
|
|
});
|
|||
|
|
},
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
module.exports = WordcutCore;
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
9: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
|
|||
|
|
//
|
|||
|
|
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
|
|||
|
|
//
|
|||
|
|
// Originally from narwhal.js (http://narwhaljs.org)
|
|||
|
|
// Copyright (c) 2009 Thomas Robinson <280north.com>
|
|||
|
|
//
|
|||
|
|
// 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 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.
|
|||
|
|
|
|||
|
|
// when used in node, this will actually load the util module we depend on
|
|||
|
|
// versus loading the builtin util module as happens otherwise
|
|||
|
|
// this is a bug in node module loading as far as I am concerned
|
|||
|
|
var util = require("util/");
|
|||
|
|
|
|||
|
|
var pSlice = Array.prototype.slice;
|
|||
|
|
var hasOwn = Object.prototype.hasOwnProperty;
|
|||
|
|
|
|||
|
|
// 1. The assert module provides functions that throw
|
|||
|
|
// AssertionError's when particular conditions are not met. The
|
|||
|
|
// assert module must conform to the following interface.
|
|||
|
|
|
|||
|
|
var assert = (module.exports = ok);
|
|||
|
|
|
|||
|
|
// 2. The AssertionError is defined in assert.
|
|||
|
|
// new assert.AssertionError({ message: message,
|
|||
|
|
// actual: actual,
|
|||
|
|
// expected: expected })
|
|||
|
|
|
|||
|
|
assert.AssertionError = function AssertionError(options) {
|
|||
|
|
this.name = "AssertionError";
|
|||
|
|
this.actual = options.actual;
|
|||
|
|
this.expected = options.expected;
|
|||
|
|
this.operator = options.operator;
|
|||
|
|
if (options.message) {
|
|||
|
|
this.message = options.message;
|
|||
|
|
this.generatedMessage = false;
|
|||
|
|
} else {
|
|||
|
|
this.message = getMessage(this);
|
|||
|
|
this.generatedMessage = true;
|
|||
|
|
}
|
|||
|
|
var stackStartFunction = options.stackStartFunction || fail;
|
|||
|
|
|
|||
|
|
if (Error.captureStackTrace) {
|
|||
|
|
Error.captureStackTrace(this, stackStartFunction);
|
|||
|
|
} else {
|
|||
|
|
// non v8 browsers so we can have a stacktrace
|
|||
|
|
var err = new Error();
|
|||
|
|
if (err.stack) {
|
|||
|
|
var out = err.stack;
|
|||
|
|
|
|||
|
|
// try to strip useless frames
|
|||
|
|
var fn_name = stackStartFunction.name;
|
|||
|
|
var idx = out.indexOf("\n" + fn_name);
|
|||
|
|
if (idx >= 0) {
|
|||
|
|
// once we have located the function frame
|
|||
|
|
// we need to strip out everything before it (and its line)
|
|||
|
|
var next_line = out.indexOf("\n", idx + 1);
|
|||
|
|
out = out.substring(next_line + 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.stack = out;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// assert.AssertionError instanceof Error
|
|||
|
|
util.inherits(assert.AssertionError, Error);
|
|||
|
|
|
|||
|
|
function replacer(key, value) {
|
|||
|
|
if (util.isUndefined(value)) {
|
|||
|
|
return "" + value;
|
|||
|
|
}
|
|||
|
|
if (util.isNumber(value) && !isFinite(value)) {
|
|||
|
|
return value.toString();
|
|||
|
|
}
|
|||
|
|
if (util.isFunction(value) || util.isRegExp(value)) {
|
|||
|
|
return value.toString();
|
|||
|
|
}
|
|||
|
|
return value;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function truncate(s, n) {
|
|||
|
|
if (util.isString(s)) {
|
|||
|
|
return s.length < n ? s : s.slice(0, n);
|
|||
|
|
} else {
|
|||
|
|
return s;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getMessage(self) {
|
|||
|
|
return (
|
|||
|
|
truncate(JSON.stringify(self.actual, replacer), 128) +
|
|||
|
|
" " +
|
|||
|
|
self.operator +
|
|||
|
|
" " +
|
|||
|
|
truncate(JSON.stringify(self.expected, replacer), 128)
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// At present only the three keys mentioned above are used and
|
|||
|
|
// understood by the spec. Implementations or sub modules can pass
|
|||
|
|
// other keys to the AssertionError's constructor - they will be
|
|||
|
|
// ignored.
|
|||
|
|
|
|||
|
|
// 3. All of the following functions must throw an AssertionError
|
|||
|
|
// when a corresponding condition is not met, with a message that
|
|||
|
|
// may be undefined if not provided. All assertion methods provide
|
|||
|
|
// both the actual and expected values to the assertion error for
|
|||
|
|
// display purposes.
|
|||
|
|
|
|||
|
|
function fail(
|
|||
|
|
actual,
|
|||
|
|
expected,
|
|||
|
|
message,
|
|||
|
|
operator,
|
|||
|
|
stackStartFunction
|
|||
|
|
) {
|
|||
|
|
throw new assert.AssertionError({
|
|||
|
|
message: message,
|
|||
|
|
actual: actual,
|
|||
|
|
expected: expected,
|
|||
|
|
operator: operator,
|
|||
|
|
stackStartFunction: stackStartFunction,
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// EXTENSION! allows for well behaved errors defined elsewhere.
|
|||
|
|
assert.fail = fail;
|
|||
|
|
|
|||
|
|
// 4. Pure assertion tests whether a value is truthy, as determined
|
|||
|
|
// by !!guard.
|
|||
|
|
// assert.ok(guard, message_opt);
|
|||
|
|
// This statement is equivalent to assert.equal(true, !!guard,
|
|||
|
|
// message_opt);. To test strictly for the value true, use
|
|||
|
|
// assert.strictEqual(true, guard, message_opt);.
|
|||
|
|
|
|||
|
|
function ok(value, message) {
|
|||
|
|
if (!value) fail(value, true, message, "==", assert.ok);
|
|||
|
|
}
|
|||
|
|
assert.ok = ok;
|
|||
|
|
|
|||
|
|
// 5. The equality assertion tests shallow, coercive equality with
|
|||
|
|
// ==.
|
|||
|
|
// assert.equal(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.equal = function equal(actual, expected, message) {
|
|||
|
|
if (actual != expected)
|
|||
|
|
fail(actual, expected, message, "==", assert.equal);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// 6. The non-equality assertion tests for whether two objects are not equal
|
|||
|
|
// with != assert.notEqual(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.notEqual = function notEqual(actual, expected, message) {
|
|||
|
|
if (actual == expected) {
|
|||
|
|
fail(actual, expected, message, "!=", assert.notEqual);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// 7. The equivalence assertion tests a deep equality relation.
|
|||
|
|
// assert.deepEqual(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.deepEqual = function deepEqual(actual, expected, message) {
|
|||
|
|
if (!_deepEqual(actual, expected)) {
|
|||
|
|
fail(actual, expected, message, "deepEqual", assert.deepEqual);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function _deepEqual(actual, expected) {
|
|||
|
|
// 7.1. All identical values are equivalent, as determined by ===.
|
|||
|
|
if (actual === expected) {
|
|||
|
|
return true;
|
|||
|
|
} else if (util.isBuffer(actual) && util.isBuffer(expected)) {
|
|||
|
|
if (actual.length != expected.length) return false;
|
|||
|
|
|
|||
|
|
for (var i = 0; i < actual.length; i++) {
|
|||
|
|
if (actual[i] !== expected[i]) return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
|
|||
|
|
// 7.2. If the expected value is a Date object, the actual value is
|
|||
|
|
// equivalent if it is also a Date object that refers to the same time.
|
|||
|
|
} else if (util.isDate(actual) && util.isDate(expected)) {
|
|||
|
|
return actual.getTime() === expected.getTime();
|
|||
|
|
|
|||
|
|
// 7.3 If the expected value is a RegExp object, the actual value is
|
|||
|
|
// equivalent if it is also a RegExp object with the same source and
|
|||
|
|
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
|
|||
|
|
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
|
|||
|
|
return (
|
|||
|
|
actual.source === expected.source &&
|
|||
|
|
actual.global === expected.global &&
|
|||
|
|
actual.multiline === expected.multiline &&
|
|||
|
|
actual.lastIndex === expected.lastIndex &&
|
|||
|
|
actual.ignoreCase === expected.ignoreCase
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// 7.4. Other pairs that do not both pass typeof value == 'object',
|
|||
|
|
// equivalence is determined by ==.
|
|||
|
|
} else if (!util.isObject(actual) && !util.isObject(expected)) {
|
|||
|
|
return actual == expected;
|
|||
|
|
|
|||
|
|
// 7.5 For all other Object pairs, including Array objects, equivalence is
|
|||
|
|
// determined by having the same number of owned properties (as verified
|
|||
|
|
// with Object.prototype.hasOwnProperty.call), the same set of keys
|
|||
|
|
// (although not necessarily the same order), equivalent values for every
|
|||
|
|
// corresponding key, and an identical 'prototype' property. Note: this
|
|||
|
|
// accounts for both named and indexed properties on Arrays.
|
|||
|
|
} else {
|
|||
|
|
return objEquiv(actual, expected);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isArguments(object) {
|
|||
|
|
return (
|
|||
|
|
Object.prototype.toString.call(object) == "[object Arguments]"
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function objEquiv(a, b) {
|
|||
|
|
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
|
|||
|
|
return false;
|
|||
|
|
// an identical 'prototype' property.
|
|||
|
|
if (a.prototype !== b.prototype) return false;
|
|||
|
|
// if one is a primitive, the other must be same
|
|||
|
|
if (util.isPrimitive(a) || util.isPrimitive(b)) {
|
|||
|
|
return a === b;
|
|||
|
|
}
|
|||
|
|
var aIsArgs = isArguments(a),
|
|||
|
|
bIsArgs = isArguments(b);
|
|||
|
|
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) return false;
|
|||
|
|
if (aIsArgs) {
|
|||
|
|
a = pSlice.call(a);
|
|||
|
|
b = pSlice.call(b);
|
|||
|
|
return _deepEqual(a, b);
|
|||
|
|
}
|
|||
|
|
var ka = objectKeys(a),
|
|||
|
|
kb = objectKeys(b),
|
|||
|
|
key,
|
|||
|
|
i;
|
|||
|
|
// having the same number of owned properties (keys incorporates
|
|||
|
|
// hasOwnProperty)
|
|||
|
|
if (ka.length != kb.length) return false;
|
|||
|
|
//the same set of keys (although not necessarily the same order),
|
|||
|
|
ka.sort();
|
|||
|
|
kb.sort();
|
|||
|
|
//~~~cheap key test
|
|||
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
|||
|
|
if (ka[i] != kb[i]) return false;
|
|||
|
|
}
|
|||
|
|
//equivalent values for every corresponding key, and
|
|||
|
|
//~~~possibly expensive deep test
|
|||
|
|
for (i = ka.length - 1; i >= 0; i--) {
|
|||
|
|
key = ka[i];
|
|||
|
|
if (!_deepEqual(a[key], b[key])) return false;
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 8. The non-equivalence assertion tests for any deep inequality.
|
|||
|
|
// assert.notDeepEqual(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.notDeepEqual = function notDeepEqual(
|
|||
|
|
actual,
|
|||
|
|
expected,
|
|||
|
|
message
|
|||
|
|
) {
|
|||
|
|
if (_deepEqual(actual, expected)) {
|
|||
|
|
fail(
|
|||
|
|
actual,
|
|||
|
|
expected,
|
|||
|
|
message,
|
|||
|
|
"notDeepEqual",
|
|||
|
|
assert.notDeepEqual
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// 9. The strict equality assertion tests strict equality, as determined by ===.
|
|||
|
|
// assert.strictEqual(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.strictEqual = function strictEqual(actual, expected, message) {
|
|||
|
|
if (actual !== expected) {
|
|||
|
|
fail(actual, expected, message, "===", assert.strictEqual);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// 10. The strict non-equality assertion tests for strict inequality, as
|
|||
|
|
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
|
|||
|
|
|
|||
|
|
assert.notStrictEqual = function notStrictEqual(
|
|||
|
|
actual,
|
|||
|
|
expected,
|
|||
|
|
message
|
|||
|
|
) {
|
|||
|
|
if (actual === expected) {
|
|||
|
|
fail(actual, expected, message, "!==", assert.notStrictEqual);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function expectedException(actual, expected) {
|
|||
|
|
if (!actual || !expected) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (Object.prototype.toString.call(expected) == "[object RegExp]") {
|
|||
|
|
return expected.test(actual);
|
|||
|
|
} else if (actual instanceof expected) {
|
|||
|
|
return true;
|
|||
|
|
} else if (expected.call({}, actual) === true) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function _throws(shouldThrow, block, expected, message) {
|
|||
|
|
var actual;
|
|||
|
|
|
|||
|
|
if (util.isString(expected)) {
|
|||
|
|
message = expected;
|
|||
|
|
expected = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
block();
|
|||
|
|
} catch (e) {
|
|||
|
|
actual = e;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
message =
|
|||
|
|
(expected && expected.name ? " (" + expected.name + ")." : ".") +
|
|||
|
|
(message ? " " + message : ".");
|
|||
|
|
|
|||
|
|
if (shouldThrow && !actual) {
|
|||
|
|
fail(actual, expected, "Missing expected exception" + message);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!shouldThrow && expectedException(actual, expected)) {
|
|||
|
|
fail(actual, expected, "Got unwanted exception" + message);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (
|
|||
|
|
(shouldThrow &&
|
|||
|
|
actual &&
|
|||
|
|
expected &&
|
|||
|
|
!expectedException(actual, expected)) ||
|
|||
|
|
(!shouldThrow && actual)
|
|||
|
|
) {
|
|||
|
|
throw actual;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 11. Expected to throw an error:
|
|||
|
|
// assert.throws(block, Error_opt, message_opt);
|
|||
|
|
|
|||
|
|
assert.throws = function (
|
|||
|
|
block,
|
|||
|
|
/*optional*/ error,
|
|||
|
|
/*optional*/ message
|
|||
|
|
) {
|
|||
|
|
_throws.apply(this, [true].concat(pSlice.call(arguments)));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// EXTENSION! This is annoying to write outside this module.
|
|||
|
|
assert.doesNotThrow = function (block, /*optional*/ message) {
|
|||
|
|
_throws.apply(this, [false].concat(pSlice.call(arguments)));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
assert.ifError = function (err) {
|
|||
|
|
if (err) {
|
|||
|
|
throw err;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var objectKeys =
|
|||
|
|
Object.keys ||
|
|||
|
|
function (obj) {
|
|||
|
|
var keys = [];
|
|||
|
|
for (var key in obj) {
|
|||
|
|
if (hasOwn.call(obj, key)) keys.push(key);
|
|||
|
|
}
|
|||
|
|
return keys;
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{ "util/": 28 },
|
|||
|
|
],
|
|||
|
|
10: [
|
|||
|
|
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;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
11: [
|
|||
|
|
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": 10, "concat-map": 13 },
|
|||
|
|
],
|
|||
|
|
12: [function (require, module, exports) {}, {}],
|
|||
|
|
13: [
|
|||
|
|
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]";
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
14: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|||
|
|
//
|
|||
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|||
|
|
// copy of this software and associated documentation files (the
|
|||
|
|
// "Software"), to deal in the Software without restriction, including
|
|||
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|||
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|||
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|||
|
|
// following conditions:
|
|||
|
|
//
|
|||
|
|
// The above copyright notice and this permission notice shall be included
|
|||
|
|
// in all copies or substantial portions of the Software.
|
|||
|
|
//
|
|||
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|||
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|||
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|||
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|||
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|||
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|||
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|
|
|||
|
|
function EventEmitter() {
|
|||
|
|
this._events = this._events || {};
|
|||
|
|
this._maxListeners = this._maxListeners || undefined;
|
|||
|
|
}
|
|||
|
|
module.exports = EventEmitter;
|
|||
|
|
|
|||
|
|
// Backwards-compat with node 0.10.x
|
|||
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|||
|
|
|
|||
|
|
EventEmitter.prototype._events = undefined;
|
|||
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|||
|
|
|
|||
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|||
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|||
|
|
EventEmitter.defaultMaxListeners = 10;
|
|||
|
|
|
|||
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|||
|
|
// that to be increased. Set to zero for unlimited.
|
|||
|
|
EventEmitter.prototype.setMaxListeners = function (n) {
|
|||
|
|
if (!isNumber(n) || n < 0 || isNaN(n))
|
|||
|
|
throw TypeError("n must be a positive number");
|
|||
|
|
this._maxListeners = n;
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.emit = function (type) {
|
|||
|
|
var er, handler, len, args, i, listeners;
|
|||
|
|
|
|||
|
|
if (!this._events) this._events = {};
|
|||
|
|
|
|||
|
|
// If there is no 'error' event listener then throw.
|
|||
|
|
if (type === "error") {
|
|||
|
|
if (
|
|||
|
|
!this._events.error ||
|
|||
|
|
(isObject(this._events.error) && !this._events.error.length)
|
|||
|
|
) {
|
|||
|
|
er = arguments[1];
|
|||
|
|
if (er instanceof Error) {
|
|||
|
|
throw er; // Unhandled 'error' event
|
|||
|
|
}
|
|||
|
|
throw TypeError('Uncaught, unspecified "error" event.');
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
handler = this._events[type];
|
|||
|
|
|
|||
|
|
if (isUndefined(handler)) return false;
|
|||
|
|
|
|||
|
|
if (isFunction(handler)) {
|
|||
|
|
switch (arguments.length) {
|
|||
|
|
// fast cases
|
|||
|
|
case 1:
|
|||
|
|
handler.call(this);
|
|||
|
|
break;
|
|||
|
|
case 2:
|
|||
|
|
handler.call(this, arguments[1]);
|
|||
|
|
break;
|
|||
|
|
case 3:
|
|||
|
|
handler.call(this, arguments[1], arguments[2]);
|
|||
|
|
break;
|
|||
|
|
// slower
|
|||
|
|
default:
|
|||
|
|
len = arguments.length;
|
|||
|
|
args = new Array(len - 1);
|
|||
|
|
for (i = 1; i < len; i++) args[i - 1] = arguments[i];
|
|||
|
|
handler.apply(this, args);
|
|||
|
|
}
|
|||
|
|
} else if (isObject(handler)) {
|
|||
|
|
len = arguments.length;
|
|||
|
|
args = new Array(len - 1);
|
|||
|
|
for (i = 1; i < len; i++) args[i - 1] = arguments[i];
|
|||
|
|
|
|||
|
|
listeners = handler.slice();
|
|||
|
|
len = listeners.length;
|
|||
|
|
for (i = 0; i < len; i++) listeners[i].apply(this, args);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.addListener = function (type, listener) {
|
|||
|
|
var m;
|
|||
|
|
|
|||
|
|
if (!isFunction(listener))
|
|||
|
|
throw TypeError("listener must be a function");
|
|||
|
|
|
|||
|
|
if (!this._events) this._events = {};
|
|||
|
|
|
|||
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|||
|
|
// adding it to the listeners, first emit "newListener".
|
|||
|
|
if (this._events.newListener)
|
|||
|
|
this.emit(
|
|||
|
|
"newListener",
|
|||
|
|
type,
|
|||
|
|
isFunction(listener.listener) ? listener.listener : listener
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
if (!this._events[type])
|
|||
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|||
|
|
this._events[type] = listener;
|
|||
|
|
else if (isObject(this._events[type]))
|
|||
|
|
// If we've already got an array, just append.
|
|||
|
|
this._events[type].push(listener);
|
|||
|
|
// Adding the second element, need to change to array.
|
|||
|
|
else this._events[type] = [this._events[type], listener];
|
|||
|
|
|
|||
|
|
// Check for listener leak
|
|||
|
|
if (isObject(this._events[type]) && !this._events[type].warned) {
|
|||
|
|
var m;
|
|||
|
|
if (!isUndefined(this._maxListeners)) {
|
|||
|
|
m = this._maxListeners;
|
|||
|
|
} else {
|
|||
|
|
m = EventEmitter.defaultMaxListeners;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (m && m > 0 && this._events[type].length > m) {
|
|||
|
|
this._events[type].warned = true;
|
|||
|
|
console.error(
|
|||
|
|
"(node) warning: possible EventEmitter memory " +
|
|||
|
|
"leak detected. %d listeners added. " +
|
|||
|
|
"Use emitter.setMaxListeners() to increase limit.",
|
|||
|
|
this._events[type].length
|
|||
|
|
);
|
|||
|
|
if (typeof console.trace === "function") {
|
|||
|
|
// not supported in IE 10
|
|||
|
|
console.trace();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.once = function (type, listener) {
|
|||
|
|
if (!isFunction(listener))
|
|||
|
|
throw TypeError("listener must be a function");
|
|||
|
|
|
|||
|
|
var fired = false;
|
|||
|
|
|
|||
|
|
function g() {
|
|||
|
|
this.removeListener(type, g);
|
|||
|
|
|
|||
|
|
if (!fired) {
|
|||
|
|
fired = true;
|
|||
|
|
listener.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
g.listener = listener;
|
|||
|
|
this.on(type, g);
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// emits a 'removeListener' event iff the listener was removed
|
|||
|
|
EventEmitter.prototype.removeListener = function (type, listener) {
|
|||
|
|
var list, position, length, i;
|
|||
|
|
|
|||
|
|
if (!isFunction(listener))
|
|||
|
|
throw TypeError("listener must be a function");
|
|||
|
|
|
|||
|
|
if (!this._events || !this._events[type]) return this;
|
|||
|
|
|
|||
|
|
list = this._events[type];
|
|||
|
|
length = list.length;
|
|||
|
|
position = -1;
|
|||
|
|
|
|||
|
|
if (
|
|||
|
|
list === listener ||
|
|||
|
|
(isFunction(list.listener) && list.listener === listener)
|
|||
|
|
) {
|
|||
|
|
delete this._events[type];
|
|||
|
|
if (this._events.removeListener)
|
|||
|
|
this.emit("removeListener", type, listener);
|
|||
|
|
} else if (isObject(list)) {
|
|||
|
|
for (i = length; i-- > 0; ) {
|
|||
|
|
if (
|
|||
|
|
list[i] === listener ||
|
|||
|
|
(list[i].listener && list[i].listener === listener)
|
|||
|
|
) {
|
|||
|
|
position = i;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (position < 0) return this;
|
|||
|
|
|
|||
|
|
if (list.length === 1) {
|
|||
|
|
list.length = 0;
|
|||
|
|
delete this._events[type];
|
|||
|
|
} else {
|
|||
|
|
list.splice(position, 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (this._events.removeListener)
|
|||
|
|
this.emit("removeListener", type, listener);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.removeAllListeners = function (type) {
|
|||
|
|
var key, listeners;
|
|||
|
|
|
|||
|
|
if (!this._events) return this;
|
|||
|
|
|
|||
|
|
// not listening for removeListener, no need to emit
|
|||
|
|
if (!this._events.removeListener) {
|
|||
|
|
if (arguments.length === 0) this._events = {};
|
|||
|
|
else if (this._events[type]) delete this._events[type];
|
|||
|
|
return this;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// emit removeListener for all listeners on all events
|
|||
|
|
if (arguments.length === 0) {
|
|||
|
|
for (key in this._events) {
|
|||
|
|
if (key === "removeListener") continue;
|
|||
|
|
this.removeAllListeners(key);
|
|||
|
|
}
|
|||
|
|
this.removeAllListeners("removeListener");
|
|||
|
|
this._events = {};
|
|||
|
|
return this;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
listeners = this._events[type];
|
|||
|
|
|
|||
|
|
if (isFunction(listeners)) {
|
|||
|
|
this.removeListener(type, listeners);
|
|||
|
|
} else {
|
|||
|
|
// LIFO order
|
|||
|
|
while (listeners.length)
|
|||
|
|
this.removeListener(type, listeners[listeners.length - 1]);
|
|||
|
|
}
|
|||
|
|
delete this._events[type];
|
|||
|
|
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.prototype.listeners = function (type) {
|
|||
|
|
var ret;
|
|||
|
|
if (!this._events || !this._events[type]) ret = [];
|
|||
|
|
else if (isFunction(this._events[type])) ret = [this._events[type]];
|
|||
|
|
else ret = this._events[type].slice();
|
|||
|
|
return ret;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
EventEmitter.listenerCount = function (emitter, type) {
|
|||
|
|
var ret;
|
|||
|
|
if (!emitter._events || !emitter._events[type]) ret = 0;
|
|||
|
|
else if (isFunction(emitter._events[type])) ret = 1;
|
|||
|
|
else ret = emitter._events[type].length;
|
|||
|
|
return ret;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function isFunction(arg) {
|
|||
|
|
return typeof arg === "function";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isNumber(arg) {
|
|||
|
|
return typeof arg === "number";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isObject(arg) {
|
|||
|
|
return typeof arg === "object" && arg !== null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isUndefined(arg) {
|
|||
|
|
return arg === void 0;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
15: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process) {
|
|||
|
|
exports.alphasort = alphasort;
|
|||
|
|
exports.alphasorti = alphasorti;
|
|||
|
|
exports.setopts = setopts;
|
|||
|
|
exports.ownProp = ownProp;
|
|||
|
|
exports.makeAbs = makeAbs;
|
|||
|
|
exports.finish = finish;
|
|||
|
|
exports.mark = mark;
|
|||
|
|
exports.isIgnored = isIgnored;
|
|||
|
|
exports.childrenIgnored = childrenIgnored;
|
|||
|
|
|
|||
|
|
function ownProp(obj, field) {
|
|||
|
|
return Object.prototype.hasOwnProperty.call(obj, field);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var path = require("path");
|
|||
|
|
var minimatch = require("minimatch");
|
|||
|
|
var isAbsolute = require("path-is-absolute");
|
|||
|
|
var Minimatch = minimatch.Minimatch;
|
|||
|
|
|
|||
|
|
function alphasorti(a, b) {
|
|||
|
|
return a.toLowerCase().localeCompare(b.toLowerCase());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function alphasort(a, b) {
|
|||
|
|
return a.localeCompare(b);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function setupIgnores(self, options) {
|
|||
|
|
self.ignore = options.ignore || [];
|
|||
|
|
|
|||
|
|
if (!Array.isArray(self.ignore)) self.ignore = [self.ignore];
|
|||
|
|
|
|||
|
|
if (self.ignore.length) {
|
|||
|
|
self.ignore = self.ignore.map(ignoreMap);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function ignoreMap(pattern) {
|
|||
|
|
var gmatcher = null;
|
|||
|
|
if (pattern.slice(-3) === "/**") {
|
|||
|
|
var gpattern = pattern.replace(/(\/\*\*)+$/, "");
|
|||
|
|
gmatcher = new Minimatch(gpattern);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
matcher: new Minimatch(pattern),
|
|||
|
|
gmatcher: gmatcher,
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function setopts(self, pattern, options) {
|
|||
|
|
if (!options) options = {};
|
|||
|
|
|
|||
|
|
// base-matching: just use globstar for that.
|
|||
|
|
if (options.matchBase && -1 === pattern.indexOf("/")) {
|
|||
|
|
if (options.noglobstar) {
|
|||
|
|
throw new Error("base matching requires globstar");
|
|||
|
|
}
|
|||
|
|
pattern = "**/" + pattern;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
self.silent = !!options.silent;
|
|||
|
|
self.pattern = pattern;
|
|||
|
|
self.strict = options.strict !== false;
|
|||
|
|
self.realpath = !!options.realpath;
|
|||
|
|
self.realpathCache = options.realpathCache || Object.create(null);
|
|||
|
|
self.follow = !!options.follow;
|
|||
|
|
self.dot = !!options.dot;
|
|||
|
|
self.mark = !!options.mark;
|
|||
|
|
self.nodir = !!options.nodir;
|
|||
|
|
if (self.nodir) self.mark = true;
|
|||
|
|
self.sync = !!options.sync;
|
|||
|
|
self.nounique = !!options.nounique;
|
|||
|
|
self.nonull = !!options.nonull;
|
|||
|
|
self.nosort = !!options.nosort;
|
|||
|
|
self.nocase = !!options.nocase;
|
|||
|
|
self.stat = !!options.stat;
|
|||
|
|
self.noprocess = !!options.noprocess;
|
|||
|
|
|
|||
|
|
self.maxLength = options.maxLength || Infinity;
|
|||
|
|
self.cache = options.cache || Object.create(null);
|
|||
|
|
self.statCache = options.statCache || Object.create(null);
|
|||
|
|
self.symlinks = options.symlinks || Object.create(null);
|
|||
|
|
|
|||
|
|
setupIgnores(self, options);
|
|||
|
|
|
|||
|
|
self.changedCwd = false;
|
|||
|
|
var cwd = process.cwd();
|
|||
|
|
if (!ownProp(options, "cwd")) self.cwd = cwd;
|
|||
|
|
else {
|
|||
|
|
self.cwd = options.cwd;
|
|||
|
|
self.changedCwd = path.resolve(options.cwd) !== cwd;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
self.root = options.root || path.resolve(self.cwd, "/");
|
|||
|
|
self.root = path.resolve(self.root);
|
|||
|
|
if (process.platform === "win32")
|
|||
|
|
self.root = self.root.replace(/\\/g, "/");
|
|||
|
|
|
|||
|
|
self.nomount = !!options.nomount;
|
|||
|
|
|
|||
|
|
// disable comments and negation unless the user explicitly
|
|||
|
|
// passes in false as the option.
|
|||
|
|
options.nonegate = options.nonegate === false ? false : true;
|
|||
|
|
options.nocomment = options.nocomment === false ? false : true;
|
|||
|
|
deprecationWarning(options);
|
|||
|
|
|
|||
|
|
self.minimatch = new Minimatch(pattern, options);
|
|||
|
|
self.options = self.minimatch.options;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// TODO(isaacs): remove entirely in v6
|
|||
|
|
// exported to reset in tests
|
|||
|
|
exports.deprecationWarned;
|
|||
|
|
function deprecationWarning(options) {
|
|||
|
|
if (!options.nonegate || !options.nocomment) {
|
|||
|
|
if (
|
|||
|
|
process.noDeprecation !== true &&
|
|||
|
|
!exports.deprecationWarned
|
|||
|
|
) {
|
|||
|
|
var msg =
|
|||
|
|
"glob WARNING: comments and negation will be disabled in v6";
|
|||
|
|
if (process.throwDeprecation) throw new Error(msg);
|
|||
|
|
else if (process.traceDeprecation) console.trace(msg);
|
|||
|
|
else console.error(msg);
|
|||
|
|
|
|||
|
|
exports.deprecationWarned = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function finish(self) {
|
|||
|
|
var nou = self.nounique;
|
|||
|
|
var all = nou ? [] : Object.create(null);
|
|||
|
|
|
|||
|
|
for (var i = 0, l = self.matches.length; i < l; i++) {
|
|||
|
|
var matches = self.matches[i];
|
|||
|
|
if (!matches || Object.keys(matches).length === 0) {
|
|||
|
|
if (self.nonull) {
|
|||
|
|
// do like the shell, and spit out the literal glob
|
|||
|
|
var literal = self.minimatch.globSet[i];
|
|||
|
|
if (nou) all.push(literal);
|
|||
|
|
else all[literal] = true;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// had matches
|
|||
|
|
var m = Object.keys(matches);
|
|||
|
|
if (nou) all.push.apply(all, m);
|
|||
|
|
else
|
|||
|
|
m.forEach(function (m) {
|
|||
|
|
all[m] = true;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!nou) all = Object.keys(all);
|
|||
|
|
|
|||
|
|
if (!self.nosort)
|
|||
|
|
all = all.sort(self.nocase ? alphasorti : alphasort);
|
|||
|
|
|
|||
|
|
// at *some* point we statted all of these
|
|||
|
|
if (self.mark) {
|
|||
|
|
for (var i = 0; i < all.length; i++) {
|
|||
|
|
all[i] = self._mark(all[i]);
|
|||
|
|
}
|
|||
|
|
if (self.nodir) {
|
|||
|
|
all = all.filter(function (e) {
|
|||
|
|
return !/\/$/.test(e);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (self.ignore.length)
|
|||
|
|
all = all.filter(function (m) {
|
|||
|
|
return !isIgnored(self, m);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
self.found = all;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function mark(self, p) {
|
|||
|
|
var abs = makeAbs(self, p);
|
|||
|
|
var c = self.cache[abs];
|
|||
|
|
var m = p;
|
|||
|
|
if (c) {
|
|||
|
|
var isDir = c === "DIR" || Array.isArray(c);
|
|||
|
|
var slash = p.slice(-1) === "/";
|
|||
|
|
|
|||
|
|
if (isDir && !slash) m += "/";
|
|||
|
|
else if (!isDir && slash) m = m.slice(0, -1);
|
|||
|
|
|
|||
|
|
if (m !== p) {
|
|||
|
|
var mabs = makeAbs(self, m);
|
|||
|
|
self.statCache[mabs] = self.statCache[abs];
|
|||
|
|
self.cache[mabs] = self.cache[abs];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return m;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// lotta situps...
|
|||
|
|
function makeAbs(self, f) {
|
|||
|
|
var abs = f;
|
|||
|
|
if (f.charAt(0) === "/") {
|
|||
|
|
abs = path.join(self.root, f);
|
|||
|
|
} else if (isAbsolute(f) || f === "") {
|
|||
|
|
abs = f;
|
|||
|
|
} else if (self.changedCwd) {
|
|||
|
|
abs = path.resolve(self.cwd, f);
|
|||
|
|
} else {
|
|||
|
|
abs = path.resolve(f);
|
|||
|
|
}
|
|||
|
|
return abs;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
|
|||
|
|
// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
|
|||
|
|
function isIgnored(self, path) {
|
|||
|
|
if (!self.ignore.length) return false;
|
|||
|
|
|
|||
|
|
return self.ignore.some(function (item) {
|
|||
|
|
return (
|
|||
|
|
item.matcher.match(path) ||
|
|||
|
|
!!(item.gmatcher && item.gmatcher.match(path))
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function childrenIgnored(self, path) {
|
|||
|
|
if (!self.ignore.length) return false;
|
|||
|
|
|
|||
|
|
return self.ignore.some(function (item) {
|
|||
|
|
return !!(item.gmatcher && item.gmatcher.match(path));
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
}.call(this, require("_process")));
|
|||
|
|
},
|
|||
|
|
{ _process: 24, minimatch: 20, path: 22, "path-is-absolute": 23 },
|
|||
|
|
],
|
|||
|
|
16: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process) {
|
|||
|
|
// Approach:
|
|||
|
|
//
|
|||
|
|
// 1. Get the minimatch set
|
|||
|
|
// 2. For each pattern in the set, PROCESS(pattern, false)
|
|||
|
|
// 3. Store matches per-set, then uniq them
|
|||
|
|
//
|
|||
|
|
// PROCESS(pattern, inGlobStar)
|
|||
|
|
// Get the first [n] items from pattern that are all strings
|
|||
|
|
// Join these together. This is PREFIX.
|
|||
|
|
// If there is no more remaining, then stat(PREFIX) and
|
|||
|
|
// add to matches if it succeeds. END.
|
|||
|
|
//
|
|||
|
|
// If inGlobStar and PREFIX is symlink and points to dir
|
|||
|
|
// set ENTRIES = []
|
|||
|
|
// else readdir(PREFIX) as ENTRIES
|
|||
|
|
// If fail, END
|
|||
|
|
//
|
|||
|
|
// with ENTRIES
|
|||
|
|
// If pattern[n] is GLOBSTAR
|
|||
|
|
// // handle the case where the globstar match is empty
|
|||
|
|
// // by pruning it out, and testing the resulting pattern
|
|||
|
|
// PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
|
|||
|
|
// // handle other cases.
|
|||
|
|
// for ENTRY in ENTRIES (not dotfiles)
|
|||
|
|
// // attach globstar + tail onto the entry
|
|||
|
|
// // Mark that this entry is a globstar match
|
|||
|
|
// PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
|
|||
|
|
//
|
|||
|
|
// else // not globstar
|
|||
|
|
// for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
|
|||
|
|
// Test ENTRY against pattern[n]
|
|||
|
|
// If fails, continue
|
|||
|
|
// If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
|
|||
|
|
//
|
|||
|
|
// Caveat:
|
|||
|
|
// Cache all stats and readdirs results to minimize syscall. Since all
|
|||
|
|
// we ever care about is existence and directory-ness, we can just keep
|
|||
|
|
// `true` for files, and [children,...] for directories, or `false` for
|
|||
|
|
// things that don't exist.
|
|||
|
|
|
|||
|
|
module.exports = glob;
|
|||
|
|
|
|||
|
|
var fs = require("fs");
|
|||
|
|
var minimatch = require("minimatch");
|
|||
|
|
var Minimatch = minimatch.Minimatch;
|
|||
|
|
var inherits = require("inherits");
|
|||
|
|
var EE = require("events").EventEmitter;
|
|||
|
|
var path = require("path");
|
|||
|
|
var assert = require("assert");
|
|||
|
|
var isAbsolute = require("path-is-absolute");
|
|||
|
|
var globSync = require("./sync.js");
|
|||
|
|
var common = require("./common.js");
|
|||
|
|
var alphasort = common.alphasort;
|
|||
|
|
var alphasorti = common.alphasorti;
|
|||
|
|
var setopts = common.setopts;
|
|||
|
|
var ownProp = common.ownProp;
|
|||
|
|
var inflight = require("inflight");
|
|||
|
|
var util = require("util");
|
|||
|
|
var childrenIgnored = common.childrenIgnored;
|
|||
|
|
var isIgnored = common.isIgnored;
|
|||
|
|
|
|||
|
|
var once = require("once");
|
|||
|
|
|
|||
|
|
function glob(pattern, options, cb) {
|
|||
|
|
if (typeof options === "function") (cb = options), (options = {});
|
|||
|
|
if (!options) options = {};
|
|||
|
|
|
|||
|
|
if (options.sync) {
|
|||
|
|
if (cb) throw new TypeError("callback provided to sync glob");
|
|||
|
|
return globSync(pattern, options);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return new Glob(pattern, options, cb);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
glob.sync = globSync;
|
|||
|
|
var GlobSync = (glob.GlobSync = globSync.GlobSync);
|
|||
|
|
|
|||
|
|
// old api surface
|
|||
|
|
glob.glob = glob;
|
|||
|
|
|
|||
|
|
glob.hasMagic = function (pattern, options_) {
|
|||
|
|
var options = util._extend({}, options_);
|
|||
|
|
options.noprocess = true;
|
|||
|
|
|
|||
|
|
var g = new Glob(pattern, options);
|
|||
|
|
var set = g.minimatch.set;
|
|||
|
|
if (set.length > 1) return true;
|
|||
|
|
|
|||
|
|
for (var j = 0; j < set[0].length; j++) {
|
|||
|
|
if (typeof set[0][j] !== "string") return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
glob.Glob = Glob;
|
|||
|
|
inherits(Glob, EE);
|
|||
|
|
function Glob(pattern, options, cb) {
|
|||
|
|
if (typeof options === "function") {
|
|||
|
|
cb = options;
|
|||
|
|
options = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (options && options.sync) {
|
|||
|
|
if (cb) throw new TypeError("callback provided to sync glob");
|
|||
|
|
return new GlobSync(pattern, options);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!(this instanceof Glob))
|
|||
|
|
return new Glob(pattern, options, cb);
|
|||
|
|
|
|||
|
|
setopts(this, pattern, options);
|
|||
|
|
this._didRealPath = false;
|
|||
|
|
|
|||
|
|
// process each pattern in the minimatch set
|
|||
|
|
var n = this.minimatch.set.length;
|
|||
|
|
|
|||
|
|
// The matches are stored as {<filename>: true,...} so that
|
|||
|
|
// duplicates are automagically pruned.
|
|||
|
|
// Later, we do an Object.keys() on these.
|
|||
|
|
// Keep them as a list so we can fill in when nonull is set.
|
|||
|
|
this.matches = new Array(n);
|
|||
|
|
|
|||
|
|
if (typeof cb === "function") {
|
|||
|
|
cb = once(cb);
|
|||
|
|
this.on("error", cb);
|
|||
|
|
this.on("end", function (matches) {
|
|||
|
|
cb(null, matches);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var self = this;
|
|||
|
|
var n = this.minimatch.set.length;
|
|||
|
|
this._processing = 0;
|
|||
|
|
this.matches = new Array(n);
|
|||
|
|
|
|||
|
|
this._emitQueue = [];
|
|||
|
|
this._processQueue = [];
|
|||
|
|
this.paused = false;
|
|||
|
|
|
|||
|
|
if (this.noprocess) return this;
|
|||
|
|
|
|||
|
|
if (n === 0) return done();
|
|||
|
|
|
|||
|
|
for (var i = 0; i < n; i++) {
|
|||
|
|
this._process(this.minimatch.set[i], i, false, done);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function done() {
|
|||
|
|
--self._processing;
|
|||
|
|
if (self._processing <= 0) self._finish();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Glob.prototype._finish = function () {
|
|||
|
|
assert(this instanceof Glob);
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
if (this.realpath && !this._didRealpath) return this._realpath();
|
|||
|
|
|
|||
|
|
common.finish(this);
|
|||
|
|
this.emit("end", this.found);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._realpath = function () {
|
|||
|
|
if (this._didRealpath) return;
|
|||
|
|
|
|||
|
|
this._didRealpath = true;
|
|||
|
|
|
|||
|
|
var n = this.matches.length;
|
|||
|
|
if (n === 0) return this._finish();
|
|||
|
|
|
|||
|
|
var self = this;
|
|||
|
|
for (var i = 0; i < this.matches.length; i++)
|
|||
|
|
this._realpathSet(i, next);
|
|||
|
|
|
|||
|
|
function next() {
|
|||
|
|
if (--n === 0) self._finish();
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._realpathSet = function (index, cb) {
|
|||
|
|
var matchset = this.matches[index];
|
|||
|
|
if (!matchset) return cb();
|
|||
|
|
|
|||
|
|
var found = Object.keys(matchset);
|
|||
|
|
var self = this;
|
|||
|
|
var n = found.length;
|
|||
|
|
|
|||
|
|
if (n === 0) return cb();
|
|||
|
|
|
|||
|
|
var set = (this.matches[index] = Object.create(null));
|
|||
|
|
found.forEach(function (p, i) {
|
|||
|
|
// If there's a problem with the stat, then it means that
|
|||
|
|
// one or more of the links in the realpath couldn't be
|
|||
|
|
// resolved. just return the abs value in that case.
|
|||
|
|
p = self._makeAbs(p);
|
|||
|
|
fs.realpath(p, self.realpathCache, function (er, real) {
|
|||
|
|
if (!er) set[real] = true;
|
|||
|
|
else if (er.syscall === "stat") set[p] = true;
|
|||
|
|
else self.emit("error", er); // srsly wtf right here
|
|||
|
|
|
|||
|
|
if (--n === 0) {
|
|||
|
|
self.matches[index] = set;
|
|||
|
|
cb();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._mark = function (p) {
|
|||
|
|
return common.mark(this, p);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._makeAbs = function (f) {
|
|||
|
|
return common.makeAbs(this, f);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype.abort = function () {
|
|||
|
|
this.aborted = true;
|
|||
|
|
this.emit("abort");
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype.pause = function () {
|
|||
|
|
if (!this.paused) {
|
|||
|
|
this.paused = true;
|
|||
|
|
this.emit("pause");
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype.resume = function () {
|
|||
|
|
if (this.paused) {
|
|||
|
|
this.emit("resume");
|
|||
|
|
this.paused = false;
|
|||
|
|
if (this._emitQueue.length) {
|
|||
|
|
var eq = this._emitQueue.slice(0);
|
|||
|
|
this._emitQueue.length = 0;
|
|||
|
|
for (var i = 0; i < eq.length; i++) {
|
|||
|
|
var e = eq[i];
|
|||
|
|
this._emitMatch(e[0], e[1]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (this._processQueue.length) {
|
|||
|
|
var pq = this._processQueue.slice(0);
|
|||
|
|
this._processQueue.length = 0;
|
|||
|
|
for (var i = 0; i < pq.length; i++) {
|
|||
|
|
var p = pq[i];
|
|||
|
|
this._processing--;
|
|||
|
|
this._process(p[0], p[1], p[2], p[3]);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._process = function (
|
|||
|
|
pattern,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
assert(this instanceof Glob);
|
|||
|
|
assert(typeof cb === "function");
|
|||
|
|
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
this._processing++;
|
|||
|
|
if (this.paused) {
|
|||
|
|
this._processQueue.push([pattern, index, inGlobStar, cb]);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//console.error('PROCESS %d', this._processing, pattern)
|
|||
|
|
|
|||
|
|
// Get the first [n] parts of pattern that are all strings.
|
|||
|
|
var n = 0;
|
|||
|
|
while (typeof pattern[n] === "string") {
|
|||
|
|
n++;
|
|||
|
|
}
|
|||
|
|
// now n is the index of the first one that is *not* a string.
|
|||
|
|
|
|||
|
|
// see if there's anything else
|
|||
|
|
var prefix;
|
|||
|
|
switch (n) {
|
|||
|
|
// if not, then this is rather simple
|
|||
|
|
case pattern.length:
|
|||
|
|
this._processSimple(pattern.join("/"), index, cb);
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
case 0:
|
|||
|
|
// pattern *starts* with some non-trivial item.
|
|||
|
|
// going to readdir(cwd), but not include the prefix in matches.
|
|||
|
|
prefix = null;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
// pattern has some string bits in the front.
|
|||
|
|
// whatever it starts with, whether that's 'absolute' like /foo/bar,
|
|||
|
|
// or 'relative' like '../baz'
|
|||
|
|
prefix = pattern.slice(0, n).join("/");
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var remain = pattern.slice(n);
|
|||
|
|
|
|||
|
|
// get the list of entries.
|
|||
|
|
var read;
|
|||
|
|
if (prefix === null) read = ".";
|
|||
|
|
else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
|
|||
|
|
if (!prefix || !isAbsolute(prefix)) prefix = "/" + prefix;
|
|||
|
|
read = prefix;
|
|||
|
|
} else read = prefix;
|
|||
|
|
|
|||
|
|
var abs = this._makeAbs(read);
|
|||
|
|
|
|||
|
|
//if ignored, skip _processing
|
|||
|
|
if (childrenIgnored(this, read)) return cb();
|
|||
|
|
|
|||
|
|
var isGlobStar = remain[0] === minimatch.GLOBSTAR;
|
|||
|
|
if (isGlobStar)
|
|||
|
|
this._processGlobStar(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
cb
|
|||
|
|
);
|
|||
|
|
else
|
|||
|
|
this._processReaddir(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
cb
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._processReaddir = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
var self = this;
|
|||
|
|
this._readdir(abs, inGlobStar, function (er, entries) {
|
|||
|
|
return self._processReaddir2(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
entries,
|
|||
|
|
cb
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._processReaddir2 = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
entries,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
// if the abs isn't a dir, then nothing can match!
|
|||
|
|
if (!entries) return cb();
|
|||
|
|
|
|||
|
|
// It will only match dot entries if it starts with a dot, or if
|
|||
|
|
// dot is set. Stuff like @(.foo|.bar) isn't allowed.
|
|||
|
|
var pn = remain[0];
|
|||
|
|
var negate = !!this.minimatch.negate;
|
|||
|
|
var rawGlob = pn._glob;
|
|||
|
|
var dotOk = this.dot || rawGlob.charAt(0) === ".";
|
|||
|
|
|
|||
|
|
var matchedEntries = [];
|
|||
|
|
for (var i = 0; i < entries.length; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (e.charAt(0) !== "." || dotOk) {
|
|||
|
|
var m;
|
|||
|
|
if (negate && !prefix) {
|
|||
|
|
m = !e.match(pn);
|
|||
|
|
} else {
|
|||
|
|
m = e.match(pn);
|
|||
|
|
}
|
|||
|
|
if (m) matchedEntries.push(e);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
|
|||
|
|
|
|||
|
|
var len = matchedEntries.length;
|
|||
|
|
// If there are no matched entries, then nothing matches.
|
|||
|
|
if (len === 0) return cb();
|
|||
|
|
|
|||
|
|
// if this is the last remaining pattern bit, then no need for
|
|||
|
|
// an additional stat *unless* the user has specified mark or
|
|||
|
|
// stat explicitly. We know they exist, since readdir returned
|
|||
|
|
// them.
|
|||
|
|
|
|||
|
|
if (remain.length === 1 && !this.mark && !this.stat) {
|
|||
|
|
if (!this.matches[index])
|
|||
|
|
this.matches[index] = Object.create(null);
|
|||
|
|
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = matchedEntries[i];
|
|||
|
|
if (prefix) {
|
|||
|
|
if (prefix !== "/") e = prefix + "/" + e;
|
|||
|
|
else e = prefix + e;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (e.charAt(0) === "/" && !this.nomount) {
|
|||
|
|
e = path.join(this.root, e);
|
|||
|
|
}
|
|||
|
|
this._emitMatch(index, e);
|
|||
|
|
}
|
|||
|
|
// This was the last one, and no stats were needed
|
|||
|
|
return cb();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// now test all matched entries as stand-ins for that part
|
|||
|
|
// of the pattern.
|
|||
|
|
remain.shift();
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = matchedEntries[i];
|
|||
|
|
var newPattern;
|
|||
|
|
if (prefix) {
|
|||
|
|
if (prefix !== "/") e = prefix + "/" + e;
|
|||
|
|
else e = prefix + e;
|
|||
|
|
}
|
|||
|
|
this._process([e].concat(remain), index, inGlobStar, cb);
|
|||
|
|
}
|
|||
|
|
cb();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._emitMatch = function (index, e) {
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
if (this.matches[index][e]) return;
|
|||
|
|
|
|||
|
|
if (isIgnored(this, e)) return;
|
|||
|
|
|
|||
|
|
if (this.paused) {
|
|||
|
|
this._emitQueue.push([index, e]);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var abs = this._makeAbs(e);
|
|||
|
|
|
|||
|
|
if (this.nodir) {
|
|||
|
|
var c = this.cache[abs];
|
|||
|
|
if (c === "DIR" || Array.isArray(c)) return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (this.mark) e = this._mark(e);
|
|||
|
|
|
|||
|
|
this.matches[index][e] = true;
|
|||
|
|
|
|||
|
|
var st = this.statCache[abs];
|
|||
|
|
if (st) this.emit("stat", e, st);
|
|||
|
|
|
|||
|
|
this.emit("match", e);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._readdirInGlobStar = function (abs, cb) {
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
// follow all symlinked directories forever
|
|||
|
|
// just proceed as if this is a non-globstar situation
|
|||
|
|
if (this.follow) return this._readdir(abs, false, cb);
|
|||
|
|
|
|||
|
|
var lstatkey = "lstat\0" + abs;
|
|||
|
|
var self = this;
|
|||
|
|
var lstatcb = inflight(lstatkey, lstatcb_);
|
|||
|
|
|
|||
|
|
if (lstatcb) fs.lstat(abs, lstatcb);
|
|||
|
|
|
|||
|
|
function lstatcb_(er, lstat) {
|
|||
|
|
if (er) return cb();
|
|||
|
|
|
|||
|
|
var isSym = lstat.isSymbolicLink();
|
|||
|
|
self.symlinks[abs] = isSym;
|
|||
|
|
|
|||
|
|
// If it's not a symlink or a dir, then it's definitely a regular file.
|
|||
|
|
// don't bother doing a readdir in that case.
|
|||
|
|
if (!isSym && !lstat.isDirectory()) {
|
|||
|
|
self.cache[abs] = "FILE";
|
|||
|
|
cb();
|
|||
|
|
} else self._readdir(abs, false, cb);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._readdir = function (abs, inGlobStar, cb) {
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
|
|||
|
|
if (!cb) return;
|
|||
|
|
|
|||
|
|
//console.error('RD %j %j', +inGlobStar, abs)
|
|||
|
|
if (inGlobStar && !ownProp(this.symlinks, abs))
|
|||
|
|
return this._readdirInGlobStar(abs, cb);
|
|||
|
|
|
|||
|
|
if (ownProp(this.cache, abs)) {
|
|||
|
|
var c = this.cache[abs];
|
|||
|
|
if (!c || c === "FILE") return cb();
|
|||
|
|
|
|||
|
|
if (Array.isArray(c)) return cb(null, c);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var self = this;
|
|||
|
|
fs.readdir(abs, readdirCb(this, abs, cb));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function readdirCb(self, abs, cb) {
|
|||
|
|
return function (er, entries) {
|
|||
|
|
if (er) self._readdirError(abs, er, cb);
|
|||
|
|
else self._readdirEntries(abs, entries, cb);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
Glob.prototype._readdirEntries = function (abs, entries, cb) {
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
// if we haven't asked to stat everything, then just
|
|||
|
|
// assume that everything in there exists, so we can avoid
|
|||
|
|
// having to stat it a second time.
|
|||
|
|
if (!this.mark && !this.stat) {
|
|||
|
|
for (var i = 0; i < entries.length; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (abs === "/") e = abs + e;
|
|||
|
|
else e = abs + "/" + e;
|
|||
|
|
this.cache[e] = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.cache[abs] = entries;
|
|||
|
|
return cb(null, entries);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._readdirError = function (f, er, cb) {
|
|||
|
|
if (this.aborted) return;
|
|||
|
|
|
|||
|
|
// handle errors, and cache the information
|
|||
|
|
switch (er.code) {
|
|||
|
|
case "ENOTSUP": // https://github.com/isaacs/node-glob/issues/205
|
|||
|
|
case "ENOTDIR": // totally normal. means it *does* exist.
|
|||
|
|
this.cache[this._makeAbs(f)] = "FILE";
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case "ENOENT": // not terribly unusual
|
|||
|
|
case "ELOOP":
|
|||
|
|
case "ENAMETOOLONG":
|
|||
|
|
case "UNKNOWN":
|
|||
|
|
this.cache[this._makeAbs(f)] = false;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
// some unusual error. Treat as failure.
|
|||
|
|
this.cache[this._makeAbs(f)] = false;
|
|||
|
|
if (this.strict) {
|
|||
|
|
this.emit("error", er);
|
|||
|
|
// If the error is handled, then we abort
|
|||
|
|
// if not, we threw out of here
|
|||
|
|
this.abort();
|
|||
|
|
}
|
|||
|
|
if (!this.silent) console.error("glob error", er);
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cb();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._processGlobStar = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
var self = this;
|
|||
|
|
this._readdir(abs, inGlobStar, function (er, entries) {
|
|||
|
|
self._processGlobStar2(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
entries,
|
|||
|
|
cb
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._processGlobStar2 = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar,
|
|||
|
|
entries,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
//console.error('pgs2', prefix, remain[0], entries)
|
|||
|
|
|
|||
|
|
// no entries means not a dir, so it can never have matches
|
|||
|
|
// foo.txt/** doesn't match foo.txt
|
|||
|
|
if (!entries) return cb();
|
|||
|
|
|
|||
|
|
// test without the globstar, and with every child both below
|
|||
|
|
// and replacing the globstar.
|
|||
|
|
var remainWithoutGlobStar = remain.slice(1);
|
|||
|
|
var gspref = prefix ? [prefix] : [];
|
|||
|
|
var noGlobStar = gspref.concat(remainWithoutGlobStar);
|
|||
|
|
|
|||
|
|
// the noGlobStar pattern exits the inGlobStar state
|
|||
|
|
this._process(noGlobStar, index, false, cb);
|
|||
|
|
|
|||
|
|
var isSym = this.symlinks[abs];
|
|||
|
|
var len = entries.length;
|
|||
|
|
|
|||
|
|
// If it's a symlink, and we're in a globstar, then stop
|
|||
|
|
if (isSym && inGlobStar) return cb();
|
|||
|
|
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (e.charAt(0) === "." && !this.dot) continue;
|
|||
|
|
|
|||
|
|
// these two cases enter the inGlobStar state
|
|||
|
|
var instead = gspref.concat(entries[i], remainWithoutGlobStar);
|
|||
|
|
this._process(instead, index, true, cb);
|
|||
|
|
|
|||
|
|
var below = gspref.concat(entries[i], remain);
|
|||
|
|
this._process(below, index, true, cb);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cb();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._processSimple = function (prefix, index, cb) {
|
|||
|
|
// XXX review this. Shouldn't it be doing the mounting etc
|
|||
|
|
// before doing stat? kinda weird?
|
|||
|
|
var self = this;
|
|||
|
|
this._stat(prefix, function (er, exists) {
|
|||
|
|
self._processSimple2(prefix, index, er, exists, cb);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
Glob.prototype._processSimple2 = function (
|
|||
|
|
prefix,
|
|||
|
|
index,
|
|||
|
|
er,
|
|||
|
|
exists,
|
|||
|
|
cb
|
|||
|
|
) {
|
|||
|
|
//console.error('ps2', prefix, exists)
|
|||
|
|
|
|||
|
|
if (!this.matches[index])
|
|||
|
|
this.matches[index] = Object.create(null);
|
|||
|
|
|
|||
|
|
// If it doesn't exist, then just mark the lack of results
|
|||
|
|
if (!exists) return cb();
|
|||
|
|
|
|||
|
|
if (prefix && isAbsolute(prefix) && !this.nomount) {
|
|||
|
|
var trail = /[\/\\]$/.test(prefix);
|
|||
|
|
if (prefix.charAt(0) === "/") {
|
|||
|
|
prefix = path.join(this.root, prefix);
|
|||
|
|
} else {
|
|||
|
|
prefix = path.resolve(this.root, prefix);
|
|||
|
|
if (trail) prefix += "/";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (process.platform === "win32")
|
|||
|
|
prefix = prefix.replace(/\\/g, "/");
|
|||
|
|
|
|||
|
|
// Mark this as a match
|
|||
|
|
this._emitMatch(index, prefix);
|
|||
|
|
cb();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns either 'DIR', 'FILE', or false
|
|||
|
|
Glob.prototype._stat = function (f, cb) {
|
|||
|
|
var abs = this._makeAbs(f);
|
|||
|
|
var needDir = f.slice(-1) === "/";
|
|||
|
|
|
|||
|
|
if (f.length > this.maxLength) return cb();
|
|||
|
|
|
|||
|
|
if (!this.stat && ownProp(this.cache, abs)) {
|
|||
|
|
var c = this.cache[abs];
|
|||
|
|
|
|||
|
|
if (Array.isArray(c)) c = "DIR";
|
|||
|
|
|
|||
|
|
// It exists, but maybe not how we need it
|
|||
|
|
if (!needDir || c === "DIR") return cb(null, c);
|
|||
|
|
|
|||
|
|
if (needDir && c === "FILE") return cb();
|
|||
|
|
|
|||
|
|
// otherwise we have to stat, because maybe c=true
|
|||
|
|
// if we know it exists, but not what it is.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var exists;
|
|||
|
|
var stat = this.statCache[abs];
|
|||
|
|
if (stat !== undefined) {
|
|||
|
|
if (stat === false) return cb(null, stat);
|
|||
|
|
else {
|
|||
|
|
var type = stat.isDirectory() ? "DIR" : "FILE";
|
|||
|
|
if (needDir && type === "FILE") return cb();
|
|||
|
|
else return cb(null, type, stat);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var self = this;
|
|||
|
|
var statcb = inflight("stat\0" + abs, lstatcb_);
|
|||
|
|
if (statcb) fs.lstat(abs, statcb);
|
|||
|
|
|
|||
|
|
function lstatcb_(er, lstat) {
|
|||
|
|
if (lstat && lstat.isSymbolicLink()) {
|
|||
|
|
// If it's a symlink, then treat it as the target, unless
|
|||
|
|
// the target does not exist, then treat it as a file.
|
|||
|
|
return fs.stat(abs, function (er, stat) {
|
|||
|
|
if (er) self._stat2(f, abs, null, lstat, cb);
|
|||
|
|
else self._stat2(f, abs, er, stat, cb);
|
|||
|
|
});
|
|||
|
|
} else {
|
|||
|
|
self._stat2(f, abs, er, lstat, cb);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
|
|||
|
|
if (er) {
|
|||
|
|
this.statCache[abs] = false;
|
|||
|
|
return cb();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var needDir = f.slice(-1) === "/";
|
|||
|
|
this.statCache[abs] = stat;
|
|||
|
|
|
|||
|
|
if (abs.slice(-1) === "/" && !stat.isDirectory())
|
|||
|
|
return cb(null, false, stat);
|
|||
|
|
|
|||
|
|
var c = stat.isDirectory() ? "DIR" : "FILE";
|
|||
|
|
this.cache[abs] = this.cache[abs] || c;
|
|||
|
|
|
|||
|
|
if (needDir && c !== "DIR") return cb();
|
|||
|
|
|
|||
|
|
return cb(null, c, stat);
|
|||
|
|
};
|
|||
|
|
}.call(this, require("_process")));
|
|||
|
|
},
|
|||
|
|
{
|
|||
|
|
"./common.js": 15,
|
|||
|
|
"./sync.js": 17,
|
|||
|
|
_process: 24,
|
|||
|
|
assert: 9,
|
|||
|
|
events: 14,
|
|||
|
|
fs: 12,
|
|||
|
|
inflight: 18,
|
|||
|
|
inherits: 19,
|
|||
|
|
minimatch: 20,
|
|||
|
|
once: 21,
|
|||
|
|
path: 22,
|
|||
|
|
"path-is-absolute": 23,
|
|||
|
|
util: 28,
|
|||
|
|
},
|
|||
|
|
],
|
|||
|
|
17: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process) {
|
|||
|
|
module.exports = globSync;
|
|||
|
|
globSync.GlobSync = GlobSync;
|
|||
|
|
|
|||
|
|
var fs = require("fs");
|
|||
|
|
var minimatch = require("minimatch");
|
|||
|
|
var Minimatch = minimatch.Minimatch;
|
|||
|
|
var Glob = require("./glob.js").Glob;
|
|||
|
|
var util = require("util");
|
|||
|
|
var path = require("path");
|
|||
|
|
var assert = require("assert");
|
|||
|
|
var isAbsolute = require("path-is-absolute");
|
|||
|
|
var common = require("./common.js");
|
|||
|
|
var alphasort = common.alphasort;
|
|||
|
|
var alphasorti = common.alphasorti;
|
|||
|
|
var setopts = common.setopts;
|
|||
|
|
var ownProp = common.ownProp;
|
|||
|
|
var childrenIgnored = common.childrenIgnored;
|
|||
|
|
|
|||
|
|
function globSync(pattern, options) {
|
|||
|
|
if (typeof options === "function" || arguments.length === 3)
|
|||
|
|
throw new TypeError(
|
|||
|
|
"callback provided to sync glob\n" +
|
|||
|
|
"See: https://github.com/isaacs/node-glob/issues/167"
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
return new GlobSync(pattern, options).found;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function GlobSync(pattern, options) {
|
|||
|
|
if (!pattern) throw new Error("must provide pattern");
|
|||
|
|
|
|||
|
|
if (typeof options === "function" || arguments.length === 3)
|
|||
|
|
throw new TypeError(
|
|||
|
|
"callback provided to sync glob\n" +
|
|||
|
|
"See: https://github.com/isaacs/node-glob/issues/167"
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
if (!(this instanceof GlobSync))
|
|||
|
|
return new GlobSync(pattern, options);
|
|||
|
|
|
|||
|
|
setopts(this, pattern, options);
|
|||
|
|
|
|||
|
|
if (this.noprocess) return this;
|
|||
|
|
|
|||
|
|
var n = this.minimatch.set.length;
|
|||
|
|
this.matches = new Array(n);
|
|||
|
|
for (var i = 0; i < n; i++) {
|
|||
|
|
this._process(this.minimatch.set[i], i, false);
|
|||
|
|
}
|
|||
|
|
this._finish();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
GlobSync.prototype._finish = function () {
|
|||
|
|
assert(this instanceof GlobSync);
|
|||
|
|
if (this.realpath) {
|
|||
|
|
var self = this;
|
|||
|
|
this.matches.forEach(function (matchset, index) {
|
|||
|
|
var set = (self.matches[index] = Object.create(null));
|
|||
|
|
for (var p in matchset) {
|
|||
|
|
try {
|
|||
|
|
p = self._makeAbs(p);
|
|||
|
|
var real = fs.realpathSync(p, self.realpathCache);
|
|||
|
|
set[real] = true;
|
|||
|
|
} catch (er) {
|
|||
|
|
if (er.syscall === "stat") set[self._makeAbs(p)] = true;
|
|||
|
|
else throw er;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
common.finish(this);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._process = function (
|
|||
|
|
pattern,
|
|||
|
|
index,
|
|||
|
|
inGlobStar
|
|||
|
|
) {
|
|||
|
|
assert(this instanceof GlobSync);
|
|||
|
|
|
|||
|
|
// Get the first [n] parts of pattern that are all strings.
|
|||
|
|
var n = 0;
|
|||
|
|
while (typeof pattern[n] === "string") {
|
|||
|
|
n++;
|
|||
|
|
}
|
|||
|
|
// now n is the index of the first one that is *not* a string.
|
|||
|
|
|
|||
|
|
// See if there's anything else
|
|||
|
|
var prefix;
|
|||
|
|
switch (n) {
|
|||
|
|
// if not, then this is rather simple
|
|||
|
|
case pattern.length:
|
|||
|
|
this._processSimple(pattern.join("/"), index);
|
|||
|
|
return;
|
|||
|
|
|
|||
|
|
case 0:
|
|||
|
|
// pattern *starts* with some non-trivial item.
|
|||
|
|
// going to readdir(cwd), but not include the prefix in matches.
|
|||
|
|
prefix = null;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
// pattern has some string bits in the front.
|
|||
|
|
// whatever it starts with, whether that's 'absolute' like /foo/bar,
|
|||
|
|
// or 'relative' like '../baz'
|
|||
|
|
prefix = pattern.slice(0, n).join("/");
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var remain = pattern.slice(n);
|
|||
|
|
|
|||
|
|
// get the list of entries.
|
|||
|
|
var read;
|
|||
|
|
if (prefix === null) read = ".";
|
|||
|
|
else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
|
|||
|
|
if (!prefix || !isAbsolute(prefix)) prefix = "/" + prefix;
|
|||
|
|
read = prefix;
|
|||
|
|
} else read = prefix;
|
|||
|
|
|
|||
|
|
var abs = this._makeAbs(read);
|
|||
|
|
|
|||
|
|
//if ignored, skip processing
|
|||
|
|
if (childrenIgnored(this, read)) return;
|
|||
|
|
|
|||
|
|
var isGlobStar = remain[0] === minimatch.GLOBSTAR;
|
|||
|
|
if (isGlobStar)
|
|||
|
|
this._processGlobStar(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar
|
|||
|
|
);
|
|||
|
|
else
|
|||
|
|
this._processReaddir(
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._processReaddir = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar
|
|||
|
|
) {
|
|||
|
|
var entries = this._readdir(abs, inGlobStar);
|
|||
|
|
|
|||
|
|
// if the abs isn't a dir, then nothing can match!
|
|||
|
|
if (!entries) return;
|
|||
|
|
|
|||
|
|
// It will only match dot entries if it starts with a dot, or if
|
|||
|
|
// dot is set. Stuff like @(.foo|.bar) isn't allowed.
|
|||
|
|
var pn = remain[0];
|
|||
|
|
var negate = !!this.minimatch.negate;
|
|||
|
|
var rawGlob = pn._glob;
|
|||
|
|
var dotOk = this.dot || rawGlob.charAt(0) === ".";
|
|||
|
|
|
|||
|
|
var matchedEntries = [];
|
|||
|
|
for (var i = 0; i < entries.length; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (e.charAt(0) !== "." || dotOk) {
|
|||
|
|
var m;
|
|||
|
|
if (negate && !prefix) {
|
|||
|
|
m = !e.match(pn);
|
|||
|
|
} else {
|
|||
|
|
m = e.match(pn);
|
|||
|
|
}
|
|||
|
|
if (m) matchedEntries.push(e);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var len = matchedEntries.length;
|
|||
|
|
// If there are no matched entries, then nothing matches.
|
|||
|
|
if (len === 0) return;
|
|||
|
|
|
|||
|
|
// if this is the last remaining pattern bit, then no need for
|
|||
|
|
// an additional stat *unless* the user has specified mark or
|
|||
|
|
// stat explicitly. We know they exist, since readdir returned
|
|||
|
|
// them.
|
|||
|
|
|
|||
|
|
if (remain.length === 1 && !this.mark && !this.stat) {
|
|||
|
|
if (!this.matches[index])
|
|||
|
|
this.matches[index] = Object.create(null);
|
|||
|
|
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = matchedEntries[i];
|
|||
|
|
if (prefix) {
|
|||
|
|
if (prefix.slice(-1) !== "/") e = prefix + "/" + e;
|
|||
|
|
else e = prefix + e;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (e.charAt(0) === "/" && !this.nomount) {
|
|||
|
|
e = path.join(this.root, e);
|
|||
|
|
}
|
|||
|
|
this.matches[index][e] = true;
|
|||
|
|
}
|
|||
|
|
// This was the last one, and no stats were needed
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// now test all matched entries as stand-ins for that part
|
|||
|
|
// of the pattern.
|
|||
|
|
remain.shift();
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = matchedEntries[i];
|
|||
|
|
var newPattern;
|
|||
|
|
if (prefix) newPattern = [prefix, e];
|
|||
|
|
else newPattern = [e];
|
|||
|
|
this._process(newPattern.concat(remain), index, inGlobStar);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._emitMatch = function (index, e) {
|
|||
|
|
var abs = this._makeAbs(e);
|
|||
|
|
if (this.mark) e = this._mark(e);
|
|||
|
|
|
|||
|
|
if (this.matches[index][e]) return;
|
|||
|
|
|
|||
|
|
if (this.nodir) {
|
|||
|
|
var c = this.cache[this._makeAbs(e)];
|
|||
|
|
if (c === "DIR" || Array.isArray(c)) return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.matches[index][e] = true;
|
|||
|
|
if (this.stat) this._stat(e);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._readdirInGlobStar = function (abs) {
|
|||
|
|
// follow all symlinked directories forever
|
|||
|
|
// just proceed as if this is a non-globstar situation
|
|||
|
|
if (this.follow) return this._readdir(abs, false);
|
|||
|
|
|
|||
|
|
var entries;
|
|||
|
|
var lstat;
|
|||
|
|
var stat;
|
|||
|
|
try {
|
|||
|
|
lstat = fs.lstatSync(abs);
|
|||
|
|
} catch (er) {
|
|||
|
|
// lstat failed, doesn't exist
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var isSym = lstat.isSymbolicLink();
|
|||
|
|
this.symlinks[abs] = isSym;
|
|||
|
|
|
|||
|
|
// If it's not a symlink or a dir, then it's definitely a regular file.
|
|||
|
|
// don't bother doing a readdir in that case.
|
|||
|
|
if (!isSym && !lstat.isDirectory()) this.cache[abs] = "FILE";
|
|||
|
|
else entries = this._readdir(abs, false);
|
|||
|
|
|
|||
|
|
return entries;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._readdir = function (abs, inGlobStar) {
|
|||
|
|
var entries;
|
|||
|
|
|
|||
|
|
if (inGlobStar && !ownProp(this.symlinks, abs))
|
|||
|
|
return this._readdirInGlobStar(abs);
|
|||
|
|
|
|||
|
|
if (ownProp(this.cache, abs)) {
|
|||
|
|
var c = this.cache[abs];
|
|||
|
|
if (!c || c === "FILE") return null;
|
|||
|
|
|
|||
|
|
if (Array.isArray(c)) return c;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
return this._readdirEntries(abs, fs.readdirSync(abs));
|
|||
|
|
} catch (er) {
|
|||
|
|
this._readdirError(abs, er);
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._readdirEntries = function (abs, entries) {
|
|||
|
|
// if we haven't asked to stat everything, then just
|
|||
|
|
// assume that everything in there exists, so we can avoid
|
|||
|
|
// having to stat it a second time.
|
|||
|
|
if (!this.mark && !this.stat) {
|
|||
|
|
for (var i = 0; i < entries.length; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (abs === "/") e = abs + e;
|
|||
|
|
else e = abs + "/" + e;
|
|||
|
|
this.cache[e] = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.cache[abs] = entries;
|
|||
|
|
|
|||
|
|
// mark and cache dir-ness
|
|||
|
|
return entries;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._readdirError = function (f, er) {
|
|||
|
|
// handle errors, and cache the information
|
|||
|
|
switch (er.code) {
|
|||
|
|
case "ENOTSUP": // https://github.com/isaacs/node-glob/issues/205
|
|||
|
|
case "ENOTDIR": // totally normal. means it *does* exist.
|
|||
|
|
this.cache[this._makeAbs(f)] = "FILE";
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
case "ENOENT": // not terribly unusual
|
|||
|
|
case "ELOOP":
|
|||
|
|
case "ENAMETOOLONG":
|
|||
|
|
case "UNKNOWN":
|
|||
|
|
this.cache[this._makeAbs(f)] = false;
|
|||
|
|
break;
|
|||
|
|
|
|||
|
|
default:
|
|||
|
|
// some unusual error. Treat as failure.
|
|||
|
|
this.cache[this._makeAbs(f)] = false;
|
|||
|
|
if (this.strict) throw er;
|
|||
|
|
if (!this.silent) console.error("glob error", er);
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._processGlobStar = function (
|
|||
|
|
prefix,
|
|||
|
|
read,
|
|||
|
|
abs,
|
|||
|
|
remain,
|
|||
|
|
index,
|
|||
|
|
inGlobStar
|
|||
|
|
) {
|
|||
|
|
var entries = this._readdir(abs, inGlobStar);
|
|||
|
|
|
|||
|
|
// no entries means not a dir, so it can never have matches
|
|||
|
|
// foo.txt/** doesn't match foo.txt
|
|||
|
|
if (!entries) return;
|
|||
|
|
|
|||
|
|
// test without the globstar, and with every child both below
|
|||
|
|
// and replacing the globstar.
|
|||
|
|
var remainWithoutGlobStar = remain.slice(1);
|
|||
|
|
var gspref = prefix ? [prefix] : [];
|
|||
|
|
var noGlobStar = gspref.concat(remainWithoutGlobStar);
|
|||
|
|
|
|||
|
|
// the noGlobStar pattern exits the inGlobStar state
|
|||
|
|
this._process(noGlobStar, index, false);
|
|||
|
|
|
|||
|
|
var len = entries.length;
|
|||
|
|
var isSym = this.symlinks[abs];
|
|||
|
|
|
|||
|
|
// If it's a symlink, and we're in a globstar, then stop
|
|||
|
|
if (isSym && inGlobStar) return;
|
|||
|
|
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
var e = entries[i];
|
|||
|
|
if (e.charAt(0) === "." && !this.dot) continue;
|
|||
|
|
|
|||
|
|
// these two cases enter the inGlobStar state
|
|||
|
|
var instead = gspref.concat(entries[i], remainWithoutGlobStar);
|
|||
|
|
this._process(instead, index, true);
|
|||
|
|
|
|||
|
|
var below = gspref.concat(entries[i], remain);
|
|||
|
|
this._process(below, index, true);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._processSimple = function (prefix, index) {
|
|||
|
|
// XXX review this. Shouldn't it be doing the mounting etc
|
|||
|
|
// before doing stat? kinda weird?
|
|||
|
|
var exists = this._stat(prefix);
|
|||
|
|
|
|||
|
|
if (!this.matches[index])
|
|||
|
|
this.matches[index] = Object.create(null);
|
|||
|
|
|
|||
|
|
// If it doesn't exist, then just mark the lack of results
|
|||
|
|
if (!exists) return;
|
|||
|
|
|
|||
|
|
if (prefix && isAbsolute(prefix) && !this.nomount) {
|
|||
|
|
var trail = /[\/\\]$/.test(prefix);
|
|||
|
|
if (prefix.charAt(0) === "/") {
|
|||
|
|
prefix = path.join(this.root, prefix);
|
|||
|
|
} else {
|
|||
|
|
prefix = path.resolve(this.root, prefix);
|
|||
|
|
if (trail) prefix += "/";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (process.platform === "win32")
|
|||
|
|
prefix = prefix.replace(/\\/g, "/");
|
|||
|
|
|
|||
|
|
// Mark this as a match
|
|||
|
|
this.matches[index][prefix] = true;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns either 'DIR', 'FILE', or false
|
|||
|
|
GlobSync.prototype._stat = function (f) {
|
|||
|
|
var abs = this._makeAbs(f);
|
|||
|
|
var needDir = f.slice(-1) === "/";
|
|||
|
|
|
|||
|
|
if (f.length > this.maxLength) return false;
|
|||
|
|
|
|||
|
|
if (!this.stat && ownProp(this.cache, abs)) {
|
|||
|
|
var c = this.cache[abs];
|
|||
|
|
|
|||
|
|
if (Array.isArray(c)) c = "DIR";
|
|||
|
|
|
|||
|
|
// It exists, but maybe not how we need it
|
|||
|
|
if (!needDir || c === "DIR") return c;
|
|||
|
|
|
|||
|
|
if (needDir && c === "FILE") return false;
|
|||
|
|
|
|||
|
|
// otherwise we have to stat, because maybe c=true
|
|||
|
|
// if we know it exists, but not what it is.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var exists;
|
|||
|
|
var stat = this.statCache[abs];
|
|||
|
|
if (!stat) {
|
|||
|
|
var lstat;
|
|||
|
|
try {
|
|||
|
|
lstat = fs.lstatSync(abs);
|
|||
|
|
} catch (er) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (lstat.isSymbolicLink()) {
|
|||
|
|
try {
|
|||
|
|
stat = fs.statSync(abs);
|
|||
|
|
} catch (er) {
|
|||
|
|
stat = lstat;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
stat = lstat;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
this.statCache[abs] = stat;
|
|||
|
|
|
|||
|
|
var c = stat.isDirectory() ? "DIR" : "FILE";
|
|||
|
|
this.cache[abs] = this.cache[abs] || c;
|
|||
|
|
|
|||
|
|
if (needDir && c !== "DIR") return false;
|
|||
|
|
|
|||
|
|
return c;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._mark = function (p) {
|
|||
|
|
return common.mark(this, p);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
GlobSync.prototype._makeAbs = function (f) {
|
|||
|
|
return common.makeAbs(this, f);
|
|||
|
|
};
|
|||
|
|
}.call(this, require("_process")));
|
|||
|
|
},
|
|||
|
|
{
|
|||
|
|
"./common.js": 15,
|
|||
|
|
"./glob.js": 16,
|
|||
|
|
_process: 24,
|
|||
|
|
assert: 9,
|
|||
|
|
fs: 12,
|
|||
|
|
minimatch: 20,
|
|||
|
|
path: 22,
|
|||
|
|
"path-is-absolute": 23,
|
|||
|
|
util: 28,
|
|||
|
|
},
|
|||
|
|
],
|
|||
|
|
18: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process) {
|
|||
|
|
var wrappy = require("wrappy");
|
|||
|
|
var reqs = Object.create(null);
|
|||
|
|
var once = require("once");
|
|||
|
|
|
|||
|
|
module.exports = wrappy(inflight);
|
|||
|
|
|
|||
|
|
function inflight(key, cb) {
|
|||
|
|
if (reqs[key]) {
|
|||
|
|
reqs[key].push(cb);
|
|||
|
|
return null;
|
|||
|
|
} else {
|
|||
|
|
reqs[key] = [cb];
|
|||
|
|
return makeres(key);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function makeres(key) {
|
|||
|
|
return once(function RES() {
|
|||
|
|
var cbs = reqs[key];
|
|||
|
|
var len = cbs.length;
|
|||
|
|
var args = slice(arguments);
|
|||
|
|
|
|||
|
|
// XXX It's somewhat ambiguous whether a new callback added in this
|
|||
|
|
// pass should be queued for later execution if something in the
|
|||
|
|
// list of callbacks throws, or if it should just be discarded.
|
|||
|
|
// However, it's such an edge case that it hardly matters, and either
|
|||
|
|
// choice is likely as surprising as the other.
|
|||
|
|
// As it happens, we do go ahead and schedule it for later execution.
|
|||
|
|
try {
|
|||
|
|
for (var i = 0; i < len; i++) {
|
|||
|
|
cbs[i].apply(null, args);
|
|||
|
|
}
|
|||
|
|
} finally {
|
|||
|
|
if (cbs.length > len) {
|
|||
|
|
// added more in the interim.
|
|||
|
|
// de-zalgo, just in case, but don't call again.
|
|||
|
|
cbs.splice(0, len);
|
|||
|
|
process.nextTick(function () {
|
|||
|
|
RES.apply(null, args);
|
|||
|
|
});
|
|||
|
|
} else {
|
|||
|
|
delete reqs[key];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function slice(args) {
|
|||
|
|
var length = args.length;
|
|||
|
|
var array = [];
|
|||
|
|
|
|||
|
|
for (var i = 0; i < length; i++) array[i] = args[i];
|
|||
|
|
return array;
|
|||
|
|
}
|
|||
|
|
}.call(this, require("_process")));
|
|||
|
|
},
|
|||
|
|
{ _process: 24, once: 21, wrappy: 29 },
|
|||
|
|
],
|
|||
|
|
19: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
if (typeof Object.create === "function") {
|
|||
|
|
// implementation from standard node.js 'util' module
|
|||
|
|
module.exports = function inherits(ctor, superCtor) {
|
|||
|
|
ctor.super_ = superCtor;
|
|||
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|||
|
|
constructor: {
|
|||
|
|
value: ctor,
|
|||
|
|
enumerable: false,
|
|||
|
|
writable: true,
|
|||
|
|
configurable: true,
|
|||
|
|
},
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
} else {
|
|||
|
|
// old school shim for old browsers
|
|||
|
|
module.exports = function inherits(ctor, superCtor) {
|
|||
|
|
ctor.super_ = superCtor;
|
|||
|
|
var TempCtor = function () {};
|
|||
|
|
TempCtor.prototype = superCtor.prototype;
|
|||
|
|
ctor.prototype = new TempCtor();
|
|||
|
|
ctor.prototype.constructor = ctor;
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
20: [
|
|||
|
|
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": 11, path: 22 },
|
|||
|
|
],
|
|||
|
|
21: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
var wrappy = require("wrappy");
|
|||
|
|
module.exports = wrappy(once);
|
|||
|
|
module.exports.strict = wrappy(onceStrict);
|
|||
|
|
|
|||
|
|
once.proto = once(function () {
|
|||
|
|
Object.defineProperty(Function.prototype, "once", {
|
|||
|
|
value: function () {
|
|||
|
|
return once(this);
|
|||
|
|
},
|
|||
|
|
configurable: true,
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
Object.defineProperty(Function.prototype, "onceStrict", {
|
|||
|
|
value: function () {
|
|||
|
|
return onceStrict(this);
|
|||
|
|
},
|
|||
|
|
configurable: true,
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
function once(fn) {
|
|||
|
|
var f = function () {
|
|||
|
|
if (f.called) return f.value;
|
|||
|
|
f.called = true;
|
|||
|
|
return (f.value = fn.apply(this, arguments));
|
|||
|
|
};
|
|||
|
|
f.called = false;
|
|||
|
|
return f;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function onceStrict(fn) {
|
|||
|
|
var f = function () {
|
|||
|
|
if (f.called) throw new Error(f.onceError);
|
|||
|
|
f.called = true;
|
|||
|
|
return (f.value = fn.apply(this, arguments));
|
|||
|
|
};
|
|||
|
|
var name = fn.name || "Function wrapped with `once`";
|
|||
|
|
f.onceError = name + " shouldn't be called more than once";
|
|||
|
|
f.called = false;
|
|||
|
|
return f;
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
{ wrappy: 29 },
|
|||
|
|
],
|
|||
|
|
22: [
|
|||
|
|
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: 24 },
|
|||
|
|
],
|
|||
|
|
23: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process) {
|
|||
|
|
"use strict";
|
|||
|
|
|
|||
|
|
function posix(path) {
|
|||
|
|
return path.charAt(0) === "/";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function win32(path) {
|
|||
|
|
// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
|
|||
|
|
var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
|
|||
|
|
var result = splitDeviceRe.exec(path);
|
|||
|
|
var device = result[1] || "";
|
|||
|
|
var isUnc = Boolean(device && device.charAt(1) !== ":");
|
|||
|
|
|
|||
|
|
// UNC paths are always absolute
|
|||
|
|
return Boolean(result[2] || isUnc);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
module.exports = process.platform === "win32" ? win32 : posix;
|
|||
|
|
module.exports.posix = posix;
|
|||
|
|
module.exports.win32 = win32;
|
|||
|
|
}.call(this, require("_process")));
|
|||
|
|
},
|
|||
|
|
{ _process: 24 },
|
|||
|
|
],
|
|||
|
|
24: [
|
|||
|
|
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;
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
25: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
// Underscore.js 1.8.3
|
|||
|
|
// http://underscorejs.org
|
|||
|
|
// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
|||
|
|
// Underscore may be freely distributed under the MIT license.
|
|||
|
|
|
|||
|
|
(function () {
|
|||
|
|
// Baseline setup
|
|||
|
|
// --------------
|
|||
|
|
|
|||
|
|
// Establish the root object, `window` in the browser, or `exports` on the server.
|
|||
|
|
var root = this;
|
|||
|
|
|
|||
|
|
// Save the previous value of the `_` variable.
|
|||
|
|
var previousUnderscore = root._;
|
|||
|
|
|
|||
|
|
// Save bytes in the minified (but not gzipped) version:
|
|||
|
|
var ArrayProto = Array.prototype,
|
|||
|
|
ObjProto = Object.prototype,
|
|||
|
|
FuncProto = Function.prototype;
|
|||
|
|
|
|||
|
|
// Create quick reference variables for speed access to core prototypes.
|
|||
|
|
var push = ArrayProto.push,
|
|||
|
|
slice = ArrayProto.slice,
|
|||
|
|
toString = ObjProto.toString,
|
|||
|
|
hasOwnProperty = ObjProto.hasOwnProperty;
|
|||
|
|
|
|||
|
|
// All **ECMAScript 5** native function implementations that we hope to use
|
|||
|
|
// are declared here.
|
|||
|
|
var nativeIsArray = Array.isArray,
|
|||
|
|
nativeKeys = Object.keys,
|
|||
|
|
nativeBind = FuncProto.bind,
|
|||
|
|
nativeCreate = Object.create;
|
|||
|
|
|
|||
|
|
// Naked function reference for surrogate-prototype-swapping.
|
|||
|
|
var Ctor = function () {};
|
|||
|
|
|
|||
|
|
// Create a safe reference to the Underscore object for use below.
|
|||
|
|
var _ = function (obj) {
|
|||
|
|
if (obj instanceof _) return obj;
|
|||
|
|
if (!(this instanceof _)) return new _(obj);
|
|||
|
|
this._wrapped = obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Export the Underscore object for **Node.js**, with
|
|||
|
|
// backwards-compatibility for the old `require()` API. If we're in
|
|||
|
|
// the browser, add `_` as a global object.
|
|||
|
|
if (typeof exports !== "undefined") {
|
|||
|
|
if (typeof module !== "undefined" && module.exports) {
|
|||
|
|
exports = module.exports = _;
|
|||
|
|
}
|
|||
|
|
exports._ = _;
|
|||
|
|
} else {
|
|||
|
|
root._ = _;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Current version.
|
|||
|
|
_.VERSION = "1.8.3";
|
|||
|
|
|
|||
|
|
// Internal function that returns an efficient (for current engines) version
|
|||
|
|
// of the passed-in callback, to be repeatedly applied in other Underscore
|
|||
|
|
// functions.
|
|||
|
|
var optimizeCb = function (func, context, argCount) {
|
|||
|
|
if (context === void 0) return func;
|
|||
|
|
switch (argCount == null ? 3 : argCount) {
|
|||
|
|
case 1:
|
|||
|
|
return function (value) {
|
|||
|
|
return func.call(context, value);
|
|||
|
|
};
|
|||
|
|
case 2:
|
|||
|
|
return function (value, other) {
|
|||
|
|
return func.call(context, value, other);
|
|||
|
|
};
|
|||
|
|
case 3:
|
|||
|
|
return function (value, index, collection) {
|
|||
|
|
return func.call(context, value, index, collection);
|
|||
|
|
};
|
|||
|
|
case 4:
|
|||
|
|
return function (accumulator, value, index, collection) {
|
|||
|
|
return func.call(
|
|||
|
|
context,
|
|||
|
|
accumulator,
|
|||
|
|
value,
|
|||
|
|
index,
|
|||
|
|
collection
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
return function () {
|
|||
|
|
return func.apply(context, arguments);
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// A mostly-internal function to generate callbacks that can be applied
|
|||
|
|
// to each element in a collection, returning the desired result — either
|
|||
|
|
// identity, an arbitrary callback, a property matcher, or a property accessor.
|
|||
|
|
var cb = function (value, context, argCount) {
|
|||
|
|
if (value == null) return _.identity;
|
|||
|
|
if (_.isFunction(value))
|
|||
|
|
return optimizeCb(value, context, argCount);
|
|||
|
|
if (_.isObject(value)) return _.matcher(value);
|
|||
|
|
return _.property(value);
|
|||
|
|
};
|
|||
|
|
_.iteratee = function (value, context) {
|
|||
|
|
return cb(value, context, Infinity);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// An internal function for creating assigner functions.
|
|||
|
|
var createAssigner = function (keysFunc, undefinedOnly) {
|
|||
|
|
return function (obj) {
|
|||
|
|
var length = arguments.length;
|
|||
|
|
if (length < 2 || obj == null) return obj;
|
|||
|
|
for (var index = 1; index < length; index++) {
|
|||
|
|
var source = arguments[index],
|
|||
|
|
keys = keysFunc(source),
|
|||
|
|
l = keys.length;
|
|||
|
|
for (var i = 0; i < l; i++) {
|
|||
|
|
var key = keys[i];
|
|||
|
|
if (!undefinedOnly || obj[key] === void 0)
|
|||
|
|
obj[key] = source[key];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return obj;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// An internal function for creating a new object that inherits from another.
|
|||
|
|
var baseCreate = function (prototype) {
|
|||
|
|
if (!_.isObject(prototype)) return {};
|
|||
|
|
if (nativeCreate) return nativeCreate(prototype);
|
|||
|
|
Ctor.prototype = prototype;
|
|||
|
|
var result = new Ctor();
|
|||
|
|
Ctor.prototype = null;
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var property = function (key) {
|
|||
|
|
return function (obj) {
|
|||
|
|
return obj == null ? void 0 : obj[key];
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Helper for collection methods to determine whether a collection
|
|||
|
|
// should be iterated as an array or as an object
|
|||
|
|
// Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
|
|||
|
|
// Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
|
|||
|
|
var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
|
|||
|
|
var getLength = property("length");
|
|||
|
|
var isArrayLike = function (collection) {
|
|||
|
|
var length = getLength(collection);
|
|||
|
|
return (
|
|||
|
|
typeof length == "number" &&
|
|||
|
|
length >= 0 &&
|
|||
|
|
length <= MAX_ARRAY_INDEX
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Collection Functions
|
|||
|
|
// --------------------
|
|||
|
|
|
|||
|
|
// The cornerstone, an `each` implementation, aka `forEach`.
|
|||
|
|
// Handles raw objects in addition to array-likes. Treats all
|
|||
|
|
// sparse array-likes as if they were dense.
|
|||
|
|
_.each = _.forEach = function (obj, iteratee, context) {
|
|||
|
|
iteratee = optimizeCb(iteratee, context);
|
|||
|
|
var i, length;
|
|||
|
|
if (isArrayLike(obj)) {
|
|||
|
|
for (i = 0, length = obj.length; i < length; i++) {
|
|||
|
|
iteratee(obj[i], i, obj);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
var keys = _.keys(obj);
|
|||
|
|
for (i = 0, length = keys.length; i < length; i++) {
|
|||
|
|
iteratee(obj[keys[i]], keys[i], obj);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return the results of applying the iteratee to each element.
|
|||
|
|
_.map = _.collect = function (obj, iteratee, context) {
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
var keys = !isArrayLike(obj) && _.keys(obj),
|
|||
|
|
length = (keys || obj).length,
|
|||
|
|
results = Array(length);
|
|||
|
|
for (var index = 0; index < length; index++) {
|
|||
|
|
var currentKey = keys ? keys[index] : index;
|
|||
|
|
results[index] = iteratee(obj[currentKey], currentKey, obj);
|
|||
|
|
}
|
|||
|
|
return results;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Create a reducing function iterating left or right.
|
|||
|
|
function createReduce(dir) {
|
|||
|
|
// Optimized iterator function as using arguments.length
|
|||
|
|
// in the main function will deoptimize the, see #1991.
|
|||
|
|
function iterator(obj, iteratee, memo, keys, index, length) {
|
|||
|
|
for (; index >= 0 && index < length; index += dir) {
|
|||
|
|
var currentKey = keys ? keys[index] : index;
|
|||
|
|
memo = iteratee(memo, obj[currentKey], currentKey, obj);
|
|||
|
|
}
|
|||
|
|
return memo;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return function (obj, iteratee, memo, context) {
|
|||
|
|
iteratee = optimizeCb(iteratee, context, 4);
|
|||
|
|
var keys = !isArrayLike(obj) && _.keys(obj),
|
|||
|
|
length = (keys || obj).length,
|
|||
|
|
index = dir > 0 ? 0 : length - 1;
|
|||
|
|
// Determine the initial value if none is provided.
|
|||
|
|
if (arguments.length < 3) {
|
|||
|
|
memo = obj[keys ? keys[index] : index];
|
|||
|
|
index += dir;
|
|||
|
|
}
|
|||
|
|
return iterator(obj, iteratee, memo, keys, index, length);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// **Reduce** builds up a single result from a list of values, aka `inject`,
|
|||
|
|
// or `foldl`.
|
|||
|
|
_.reduce = _.foldl = _.inject = createReduce(1);
|
|||
|
|
|
|||
|
|
// The right-associative version of reduce, also known as `foldr`.
|
|||
|
|
_.reduceRight = _.foldr = createReduce(-1);
|
|||
|
|
|
|||
|
|
// Return the first value which passes a truth test. Aliased as `detect`.
|
|||
|
|
_.find = _.detect = function (obj, predicate, context) {
|
|||
|
|
var key;
|
|||
|
|
if (isArrayLike(obj)) {
|
|||
|
|
key = _.findIndex(obj, predicate, context);
|
|||
|
|
} else {
|
|||
|
|
key = _.findKey(obj, predicate, context);
|
|||
|
|
}
|
|||
|
|
if (key !== void 0 && key !== -1) return obj[key];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return all the elements that pass a truth test.
|
|||
|
|
// Aliased as `select`.
|
|||
|
|
_.filter = _.select = function (obj, predicate, context) {
|
|||
|
|
var results = [];
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
_.each(obj, function (value, index, list) {
|
|||
|
|
if (predicate(value, index, list)) results.push(value);
|
|||
|
|
});
|
|||
|
|
return results;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return all the elements for which a truth test fails.
|
|||
|
|
_.reject = function (obj, predicate, context) {
|
|||
|
|
return _.filter(obj, _.negate(cb(predicate)), context);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Determine whether all of the elements match a truth test.
|
|||
|
|
// Aliased as `all`.
|
|||
|
|
_.every = _.all = function (obj, predicate, context) {
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
var keys = !isArrayLike(obj) && _.keys(obj),
|
|||
|
|
length = (keys || obj).length;
|
|||
|
|
for (var index = 0; index < length; index++) {
|
|||
|
|
var currentKey = keys ? keys[index] : index;
|
|||
|
|
if (!predicate(obj[currentKey], currentKey, obj)) return false;
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Determine if at least one element in the object matches a truth test.
|
|||
|
|
// Aliased as `any`.
|
|||
|
|
_.some = _.any = function (obj, predicate, context) {
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
var keys = !isArrayLike(obj) && _.keys(obj),
|
|||
|
|
length = (keys || obj).length;
|
|||
|
|
for (var index = 0; index < length; index++) {
|
|||
|
|
var currentKey = keys ? keys[index] : index;
|
|||
|
|
if (predicate(obj[currentKey], currentKey, obj)) return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Determine if the array or object contains a given item (using `===`).
|
|||
|
|
// Aliased as `includes` and `include`.
|
|||
|
|
_.contains = _.includes = _.include = function (
|
|||
|
|
obj,
|
|||
|
|
item,
|
|||
|
|
fromIndex,
|
|||
|
|
guard
|
|||
|
|
) {
|
|||
|
|
if (!isArrayLike(obj)) obj = _.values(obj);
|
|||
|
|
if (typeof fromIndex != "number" || guard) fromIndex = 0;
|
|||
|
|
return _.indexOf(obj, item, fromIndex) >= 0;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Invoke a method (with arguments) on every item in a collection.
|
|||
|
|
_.invoke = function (obj, method) {
|
|||
|
|
var args = slice.call(arguments, 2);
|
|||
|
|
var isFunc = _.isFunction(method);
|
|||
|
|
return _.map(obj, function (value) {
|
|||
|
|
var func = isFunc ? method : value[method];
|
|||
|
|
return func == null ? func : func.apply(value, args);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Convenience version of a common use case of `map`: fetching a property.
|
|||
|
|
_.pluck = function (obj, key) {
|
|||
|
|
return _.map(obj, _.property(key));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Convenience version of a common use case of `filter`: selecting only objects
|
|||
|
|
// containing specific `key:value` pairs.
|
|||
|
|
_.where = function (obj, attrs) {
|
|||
|
|
return _.filter(obj, _.matcher(attrs));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Convenience version of a common use case of `find`: getting the first object
|
|||
|
|
// containing specific `key:value` pairs.
|
|||
|
|
_.findWhere = function (obj, attrs) {
|
|||
|
|
return _.find(obj, _.matcher(attrs));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return the maximum element (or element-based computation).
|
|||
|
|
_.max = function (obj, iteratee, context) {
|
|||
|
|
var result = -Infinity,
|
|||
|
|
lastComputed = -Infinity,
|
|||
|
|
value,
|
|||
|
|
computed;
|
|||
|
|
if (iteratee == null && obj != null) {
|
|||
|
|
obj = isArrayLike(obj) ? obj : _.values(obj);
|
|||
|
|
for (var i = 0, length = obj.length; i < length; i++) {
|
|||
|
|
value = obj[i];
|
|||
|
|
if (value > result) {
|
|||
|
|
result = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
_.each(obj, function (value, index, list) {
|
|||
|
|
computed = iteratee(value, index, list);
|
|||
|
|
if (
|
|||
|
|
computed > lastComputed ||
|
|||
|
|
(computed === -Infinity && result === -Infinity)
|
|||
|
|
) {
|
|||
|
|
result = value;
|
|||
|
|
lastComputed = computed;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return the minimum element (or element-based computation).
|
|||
|
|
_.min = function (obj, iteratee, context) {
|
|||
|
|
var result = Infinity,
|
|||
|
|
lastComputed = Infinity,
|
|||
|
|
value,
|
|||
|
|
computed;
|
|||
|
|
if (iteratee == null && obj != null) {
|
|||
|
|
obj = isArrayLike(obj) ? obj : _.values(obj);
|
|||
|
|
for (var i = 0, length = obj.length; i < length; i++) {
|
|||
|
|
value = obj[i];
|
|||
|
|
if (value < result) {
|
|||
|
|
result = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
_.each(obj, function (value, index, list) {
|
|||
|
|
computed = iteratee(value, index, list);
|
|||
|
|
if (
|
|||
|
|
computed < lastComputed ||
|
|||
|
|
(computed === Infinity && result === Infinity)
|
|||
|
|
) {
|
|||
|
|
result = value;
|
|||
|
|
lastComputed = computed;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Shuffle a collection, using the modern version of the
|
|||
|
|
// [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
|
|||
|
|
_.shuffle = function (obj) {
|
|||
|
|
var set = isArrayLike(obj) ? obj : _.values(obj);
|
|||
|
|
var length = set.length;
|
|||
|
|
var shuffled = Array(length);
|
|||
|
|
for (var index = 0, rand; index < length; index++) {
|
|||
|
|
rand = _.random(0, index);
|
|||
|
|
if (rand !== index) shuffled[index] = shuffled[rand];
|
|||
|
|
shuffled[rand] = set[index];
|
|||
|
|
}
|
|||
|
|
return shuffled;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Sample **n** random values from a collection.
|
|||
|
|
// If **n** is not specified, returns a single random element.
|
|||
|
|
// The internal `guard` argument allows it to work with `map`.
|
|||
|
|
_.sample = function (obj, n, guard) {
|
|||
|
|
if (n == null || guard) {
|
|||
|
|
if (!isArrayLike(obj)) obj = _.values(obj);
|
|||
|
|
return obj[_.random(obj.length - 1)];
|
|||
|
|
}
|
|||
|
|
return _.shuffle(obj).slice(0, Math.max(0, n));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Sort the object's values by a criterion produced by an iteratee.
|
|||
|
|
_.sortBy = function (obj, iteratee, context) {
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
return _.pluck(
|
|||
|
|
_.map(obj, function (value, index, list) {
|
|||
|
|
return {
|
|||
|
|
value: value,
|
|||
|
|
index: index,
|
|||
|
|
criteria: iteratee(value, index, list),
|
|||
|
|
};
|
|||
|
|
}).sort(function (left, right) {
|
|||
|
|
var a = left.criteria;
|
|||
|
|
var b = right.criteria;
|
|||
|
|
if (a !== b) {
|
|||
|
|
if (a > b || a === void 0) return 1;
|
|||
|
|
if (a < b || b === void 0) return -1;
|
|||
|
|
}
|
|||
|
|
return left.index - right.index;
|
|||
|
|
}),
|
|||
|
|
"value"
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// An internal function used for aggregate "group by" operations.
|
|||
|
|
var group = function (behavior) {
|
|||
|
|
return function (obj, iteratee, context) {
|
|||
|
|
var result = {};
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
_.each(obj, function (value, index) {
|
|||
|
|
var key = iteratee(value, index, obj);
|
|||
|
|
behavior(result, value, key);
|
|||
|
|
});
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Groups the object's values by a criterion. Pass either a string attribute
|
|||
|
|
// to group by, or a function that returns the criterion.
|
|||
|
|
_.groupBy = group(function (result, value, key) {
|
|||
|
|
if (_.has(result, key)) result[key].push(value);
|
|||
|
|
else result[key] = [value];
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
// Indexes the object's values by a criterion, similar to `groupBy`, but for
|
|||
|
|
// when you know that your index values will be unique.
|
|||
|
|
_.indexBy = group(function (result, value, key) {
|
|||
|
|
result[key] = value;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
// Counts instances of an object that group by a certain criterion. Pass
|
|||
|
|
// either a string attribute to count by, or a function that returns the
|
|||
|
|
// criterion.
|
|||
|
|
_.countBy = group(function (result, value, key) {
|
|||
|
|
if (_.has(result, key)) result[key]++;
|
|||
|
|
else result[key] = 1;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
// Safely create a real, live array from anything iterable.
|
|||
|
|
_.toArray = function (obj) {
|
|||
|
|
if (!obj) return [];
|
|||
|
|
if (_.isArray(obj)) return slice.call(obj);
|
|||
|
|
if (isArrayLike(obj)) return _.map(obj, _.identity);
|
|||
|
|
return _.values(obj);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return the number of elements in an object.
|
|||
|
|
_.size = function (obj) {
|
|||
|
|
if (obj == null) return 0;
|
|||
|
|
return isArrayLike(obj) ? obj.length : _.keys(obj).length;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Split a collection into two arrays: one whose elements all satisfy the given
|
|||
|
|
// predicate, and one whose elements all do not satisfy the predicate.
|
|||
|
|
_.partition = function (obj, predicate, context) {
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
var pass = [],
|
|||
|
|
fail = [];
|
|||
|
|
_.each(obj, function (value, key, obj) {
|
|||
|
|
(predicate(value, key, obj) ? pass : fail).push(value);
|
|||
|
|
});
|
|||
|
|
return [pass, fail];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Array Functions
|
|||
|
|
// ---------------
|
|||
|
|
|
|||
|
|
// Get the first element of an array. Passing **n** will return the first N
|
|||
|
|
// values in the array. Aliased as `head` and `take`. The **guard** check
|
|||
|
|
// allows it to work with `_.map`.
|
|||
|
|
_.first = _.head = _.take = function (array, n, guard) {
|
|||
|
|
if (array == null) return void 0;
|
|||
|
|
if (n == null || guard) return array[0];
|
|||
|
|
return _.initial(array, array.length - n);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns everything but the last entry of the array. Especially useful on
|
|||
|
|
// the arguments object. Passing **n** will return all the values in
|
|||
|
|
// the array, excluding the last N.
|
|||
|
|
_.initial = function (array, n, guard) {
|
|||
|
|
return slice.call(
|
|||
|
|
array,
|
|||
|
|
0,
|
|||
|
|
Math.max(0, array.length - (n == null || guard ? 1 : n))
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Get the last element of an array. Passing **n** will return the last N
|
|||
|
|
// values in the array.
|
|||
|
|
_.last = function (array, n, guard) {
|
|||
|
|
if (array == null) return void 0;
|
|||
|
|
if (n == null || guard) return array[array.length - 1];
|
|||
|
|
return _.rest(array, Math.max(0, array.length - n));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
|
|||
|
|
// Especially useful on the arguments object. Passing an **n** will return
|
|||
|
|
// the rest N values in the array.
|
|||
|
|
_.rest = _.tail = _.drop = function (array, n, guard) {
|
|||
|
|
return slice.call(array, n == null || guard ? 1 : n);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Trim out all falsy values from an array.
|
|||
|
|
_.compact = function (array) {
|
|||
|
|
return _.filter(array, _.identity);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Internal implementation of a recursive `flatten` function.
|
|||
|
|
var flatten = function (input, shallow, strict, startIndex) {
|
|||
|
|
var output = [],
|
|||
|
|
idx = 0;
|
|||
|
|
for (
|
|||
|
|
var i = startIndex || 0, length = getLength(input);
|
|||
|
|
i < length;
|
|||
|
|
i++
|
|||
|
|
) {
|
|||
|
|
var value = input[i];
|
|||
|
|
if (
|
|||
|
|
isArrayLike(value) &&
|
|||
|
|
(_.isArray(value) || _.isArguments(value))
|
|||
|
|
) {
|
|||
|
|
//flatten current level of array or arguments object
|
|||
|
|
if (!shallow) value = flatten(value, shallow, strict);
|
|||
|
|
var j = 0,
|
|||
|
|
len = value.length;
|
|||
|
|
output.length += len;
|
|||
|
|
while (j < len) {
|
|||
|
|
output[idx++] = value[j++];
|
|||
|
|
}
|
|||
|
|
} else if (!strict) {
|
|||
|
|
output[idx++] = value;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return output;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Flatten out an array, either recursively (by default), or just one level.
|
|||
|
|
_.flatten = function (array, shallow) {
|
|||
|
|
return flatten(array, shallow, false);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return a version of the array that does not contain the specified value(s).
|
|||
|
|
_.without = function (array) {
|
|||
|
|
return _.difference(array, slice.call(arguments, 1));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Produce a duplicate-free version of the array. If the array has already
|
|||
|
|
// been sorted, you have the option of using a faster algorithm.
|
|||
|
|
// Aliased as `unique`.
|
|||
|
|
_.uniq = _.unique = function (array, isSorted, iteratee, context) {
|
|||
|
|
if (!_.isBoolean(isSorted)) {
|
|||
|
|
context = iteratee;
|
|||
|
|
iteratee = isSorted;
|
|||
|
|
isSorted = false;
|
|||
|
|
}
|
|||
|
|
if (iteratee != null) iteratee = cb(iteratee, context);
|
|||
|
|
var result = [];
|
|||
|
|
var seen = [];
|
|||
|
|
for (var i = 0, length = getLength(array); i < length; i++) {
|
|||
|
|
var value = array[i],
|
|||
|
|
computed = iteratee ? iteratee(value, i, array) : value;
|
|||
|
|
if (isSorted) {
|
|||
|
|
if (!i || seen !== computed) result.push(value);
|
|||
|
|
seen = computed;
|
|||
|
|
} else if (iteratee) {
|
|||
|
|
if (!_.contains(seen, computed)) {
|
|||
|
|
seen.push(computed);
|
|||
|
|
result.push(value);
|
|||
|
|
}
|
|||
|
|
} else if (!_.contains(result, value)) {
|
|||
|
|
result.push(value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Produce an array that contains the union: each distinct element from all of
|
|||
|
|
// the passed-in arrays.
|
|||
|
|
_.union = function () {
|
|||
|
|
return _.uniq(flatten(arguments, true, true));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Produce an array that contains every item shared between all the
|
|||
|
|
// passed-in arrays.
|
|||
|
|
_.intersection = function (array) {
|
|||
|
|
var result = [];
|
|||
|
|
var argsLength = arguments.length;
|
|||
|
|
for (var i = 0, length = getLength(array); i < length; i++) {
|
|||
|
|
var item = array[i];
|
|||
|
|
if (_.contains(result, item)) continue;
|
|||
|
|
for (var j = 1; j < argsLength; j++) {
|
|||
|
|
if (!_.contains(arguments[j], item)) break;
|
|||
|
|
}
|
|||
|
|
if (j === argsLength) result.push(item);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Take the difference between one array and a number of other arrays.
|
|||
|
|
// Only the elements present in just the first array will remain.
|
|||
|
|
_.difference = function (array) {
|
|||
|
|
var rest = flatten(arguments, true, true, 1);
|
|||
|
|
return _.filter(array, function (value) {
|
|||
|
|
return !_.contains(rest, value);
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Zip together multiple lists into a single array -- elements that share
|
|||
|
|
// an index go together.
|
|||
|
|
_.zip = function () {
|
|||
|
|
return _.unzip(arguments);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Complement of _.zip. Unzip accepts an array of arrays and groups
|
|||
|
|
// each array's elements on shared indices
|
|||
|
|
_.unzip = function (array) {
|
|||
|
|
var length = (array && _.max(array, getLength).length) || 0;
|
|||
|
|
var result = Array(length);
|
|||
|
|
|
|||
|
|
for (var index = 0; index < length; index++) {
|
|||
|
|
result[index] = _.pluck(array, index);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Converts lists into objects. Pass either a single array of `[key, value]`
|
|||
|
|
// pairs, or two parallel arrays of the same length -- one of keys, and one of
|
|||
|
|
// the corresponding values.
|
|||
|
|
_.object = function (list, values) {
|
|||
|
|
var result = {};
|
|||
|
|
for (var i = 0, length = getLength(list); i < length; i++) {
|
|||
|
|
if (values) {
|
|||
|
|
result[list[i]] = values[i];
|
|||
|
|
} else {
|
|||
|
|
result[list[i][0]] = list[i][1];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Generator function to create the findIndex and findLastIndex functions
|
|||
|
|
function createPredicateIndexFinder(dir) {
|
|||
|
|
return function (array, predicate, context) {
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
var length = getLength(array);
|
|||
|
|
var index = dir > 0 ? 0 : length - 1;
|
|||
|
|
for (; index >= 0 && index < length; index += dir) {
|
|||
|
|
if (predicate(array[index], index, array)) return index;
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Returns the first index on an array-like that passes a predicate test
|
|||
|
|
_.findIndex = createPredicateIndexFinder(1);
|
|||
|
|
_.findLastIndex = createPredicateIndexFinder(-1);
|
|||
|
|
|
|||
|
|
// Use a comparator function to figure out the smallest index at which
|
|||
|
|
// an object should be inserted so as to maintain order. Uses binary search.
|
|||
|
|
_.sortedIndex = function (array, obj, iteratee, context) {
|
|||
|
|
iteratee = cb(iteratee, context, 1);
|
|||
|
|
var value = iteratee(obj);
|
|||
|
|
var low = 0,
|
|||
|
|
high = getLength(array);
|
|||
|
|
while (low < high) {
|
|||
|
|
var mid = Math.floor((low + high) / 2);
|
|||
|
|
if (iteratee(array[mid]) < value) low = mid + 1;
|
|||
|
|
else high = mid;
|
|||
|
|
}
|
|||
|
|
return low;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Generator function to create the indexOf and lastIndexOf functions
|
|||
|
|
function createIndexFinder(dir, predicateFind, sortedIndex) {
|
|||
|
|
return function (array, item, idx) {
|
|||
|
|
var i = 0,
|
|||
|
|
length = getLength(array);
|
|||
|
|
if (typeof idx == "number") {
|
|||
|
|
if (dir > 0) {
|
|||
|
|
i = idx >= 0 ? idx : Math.max(idx + length, i);
|
|||
|
|
} else {
|
|||
|
|
length =
|
|||
|
|
idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
|
|||
|
|
}
|
|||
|
|
} else if (sortedIndex && idx && length) {
|
|||
|
|
idx = sortedIndex(array, item);
|
|||
|
|
return array[idx] === item ? idx : -1;
|
|||
|
|
}
|
|||
|
|
if (item !== item) {
|
|||
|
|
idx = predicateFind(slice.call(array, i, length), _.isNaN);
|
|||
|
|
return idx >= 0 ? idx + i : -1;
|
|||
|
|
}
|
|||
|
|
for (
|
|||
|
|
idx = dir > 0 ? i : length - 1;
|
|||
|
|
idx >= 0 && idx < length;
|
|||
|
|
idx += dir
|
|||
|
|
) {
|
|||
|
|
if (array[idx] === item) return idx;
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Return the position of the first occurrence of an item in an array,
|
|||
|
|
// or -1 if the item is not included in the array.
|
|||
|
|
// If the array is large and already in sort order, pass `true`
|
|||
|
|
// for **isSorted** to use binary search.
|
|||
|
|
_.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
|
|||
|
|
_.lastIndexOf = createIndexFinder(-1, _.findLastIndex);
|
|||
|
|
|
|||
|
|
// Generate an integer Array containing an arithmetic progression. A port of
|
|||
|
|
// the native Python `range()` function. See
|
|||
|
|
// [the Python documentation](http://docs.python.org/library/functions.html#range).
|
|||
|
|
_.range = function (start, stop, step) {
|
|||
|
|
if (stop == null) {
|
|||
|
|
stop = start || 0;
|
|||
|
|
start = 0;
|
|||
|
|
}
|
|||
|
|
step = step || 1;
|
|||
|
|
|
|||
|
|
var length = Math.max(Math.ceil((stop - start) / step), 0);
|
|||
|
|
var range = Array(length);
|
|||
|
|
|
|||
|
|
for (var idx = 0; idx < length; idx++, start += step) {
|
|||
|
|
range[idx] = start;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return range;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Function (ahem) Functions
|
|||
|
|
// ------------------
|
|||
|
|
|
|||
|
|
// Determines whether to execute a function as a constructor
|
|||
|
|
// or a normal function with the provided arguments
|
|||
|
|
var executeBound = function (
|
|||
|
|
sourceFunc,
|
|||
|
|
boundFunc,
|
|||
|
|
context,
|
|||
|
|
callingContext,
|
|||
|
|
args
|
|||
|
|
) {
|
|||
|
|
if (!(callingContext instanceof boundFunc))
|
|||
|
|
return sourceFunc.apply(context, args);
|
|||
|
|
var self = baseCreate(sourceFunc.prototype);
|
|||
|
|
var result = sourceFunc.apply(self, args);
|
|||
|
|
if (_.isObject(result)) return result;
|
|||
|
|
return self;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Create a function bound to a given object (assigning `this`, and arguments,
|
|||
|
|
// optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
|
|||
|
|
// available.
|
|||
|
|
_.bind = function (func, context) {
|
|||
|
|
if (nativeBind && func.bind === nativeBind)
|
|||
|
|
return nativeBind.apply(func, slice.call(arguments, 1));
|
|||
|
|
if (!_.isFunction(func))
|
|||
|
|
throw new TypeError("Bind must be called on a function");
|
|||
|
|
var args = slice.call(arguments, 2);
|
|||
|
|
var bound = function () {
|
|||
|
|
return executeBound(
|
|||
|
|
func,
|
|||
|
|
bound,
|
|||
|
|
context,
|
|||
|
|
this,
|
|||
|
|
args.concat(slice.call(arguments))
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
return bound;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Partially apply a function by creating a version that has had some of its
|
|||
|
|
// arguments pre-filled, without changing its dynamic `this` context. _ acts
|
|||
|
|
// as a placeholder, allowing any combination of arguments to be pre-filled.
|
|||
|
|
_.partial = function (func) {
|
|||
|
|
var boundArgs = slice.call(arguments, 1);
|
|||
|
|
var bound = function () {
|
|||
|
|
var position = 0,
|
|||
|
|
length = boundArgs.length;
|
|||
|
|
var args = Array(length);
|
|||
|
|
for (var i = 0; i < length; i++) {
|
|||
|
|
args[i] =
|
|||
|
|
boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
|
|||
|
|
}
|
|||
|
|
while (position < arguments.length)
|
|||
|
|
args.push(arguments[position++]);
|
|||
|
|
return executeBound(func, bound, this, this, args);
|
|||
|
|
};
|
|||
|
|
return bound;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Bind a number of an object's methods to that object. Remaining arguments
|
|||
|
|
// are the method names to be bound. Useful for ensuring that all callbacks
|
|||
|
|
// defined on an object belong to it.
|
|||
|
|
_.bindAll = function (obj) {
|
|||
|
|
var i,
|
|||
|
|
length = arguments.length,
|
|||
|
|
key;
|
|||
|
|
if (length <= 1)
|
|||
|
|
throw new Error("bindAll must be passed function names");
|
|||
|
|
for (i = 1; i < length; i++) {
|
|||
|
|
key = arguments[i];
|
|||
|
|
obj[key] = _.bind(obj[key], obj);
|
|||
|
|
}
|
|||
|
|
return obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Memoize an expensive function by storing its results.
|
|||
|
|
_.memoize = function (func, hasher) {
|
|||
|
|
var memoize = function (key) {
|
|||
|
|
var cache = memoize.cache;
|
|||
|
|
var address =
|
|||
|
|
"" + (hasher ? hasher.apply(this, arguments) : key);
|
|||
|
|
if (!_.has(cache, address))
|
|||
|
|
cache[address] = func.apply(this, arguments);
|
|||
|
|
return cache[address];
|
|||
|
|
};
|
|||
|
|
memoize.cache = {};
|
|||
|
|
return memoize;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Delays a function for the given number of milliseconds, and then calls
|
|||
|
|
// it with the arguments supplied.
|
|||
|
|
_.delay = function (func, wait) {
|
|||
|
|
var args = slice.call(arguments, 2);
|
|||
|
|
return setTimeout(function () {
|
|||
|
|
return func.apply(null, args);
|
|||
|
|
}, wait);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Defers a function, scheduling it to run after the current call stack has
|
|||
|
|
// cleared.
|
|||
|
|
_.defer = _.partial(_.delay, _, 1);
|
|||
|
|
|
|||
|
|
// Returns a function, that, when invoked, will only be triggered at most once
|
|||
|
|
// during a given window of time. Normally, the throttled function will run
|
|||
|
|
// as much as it can, without ever going more than once per `wait` duration;
|
|||
|
|
// but if you'd like to disable the execution on the leading edge, pass
|
|||
|
|
// `{leading: false}`. To disable execution on the trailing edge, ditto.
|
|||
|
|
_.throttle = function (func, wait, options) {
|
|||
|
|
var context, args, result;
|
|||
|
|
var timeout = null;
|
|||
|
|
var previous = 0;
|
|||
|
|
if (!options) options = {};
|
|||
|
|
var later = function () {
|
|||
|
|
previous = options.leading === false ? 0 : _.now();
|
|||
|
|
timeout = null;
|
|||
|
|
result = func.apply(context, args);
|
|||
|
|
if (!timeout) context = args = null;
|
|||
|
|
};
|
|||
|
|
return function () {
|
|||
|
|
var now = _.now();
|
|||
|
|
if (!previous && options.leading === false) previous = now;
|
|||
|
|
var remaining = wait - (now - previous);
|
|||
|
|
context = this;
|
|||
|
|
args = arguments;
|
|||
|
|
if (remaining <= 0 || remaining > wait) {
|
|||
|
|
if (timeout) {
|
|||
|
|
clearTimeout(timeout);
|
|||
|
|
timeout = null;
|
|||
|
|
}
|
|||
|
|
previous = now;
|
|||
|
|
result = func.apply(context, args);
|
|||
|
|
if (!timeout) context = args = null;
|
|||
|
|
} else if (!timeout && options.trailing !== false) {
|
|||
|
|
timeout = setTimeout(later, remaining);
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a function, that, as long as it continues to be invoked, will not
|
|||
|
|
// be triggered. The function will be called after it stops being called for
|
|||
|
|
// N milliseconds. If `immediate` is passed, trigger the function on the
|
|||
|
|
// leading edge, instead of the trailing.
|
|||
|
|
_.debounce = function (func, wait, immediate) {
|
|||
|
|
var timeout, args, context, timestamp, result;
|
|||
|
|
|
|||
|
|
var later = function () {
|
|||
|
|
var last = _.now() - timestamp;
|
|||
|
|
|
|||
|
|
if (last < wait && last >= 0) {
|
|||
|
|
timeout = setTimeout(later, wait - last);
|
|||
|
|
} else {
|
|||
|
|
timeout = null;
|
|||
|
|
if (!immediate) {
|
|||
|
|
result = func.apply(context, args);
|
|||
|
|
if (!timeout) context = args = null;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
return function () {
|
|||
|
|
context = this;
|
|||
|
|
args = arguments;
|
|||
|
|
timestamp = _.now();
|
|||
|
|
var callNow = immediate && !timeout;
|
|||
|
|
if (!timeout) timeout = setTimeout(later, wait);
|
|||
|
|
if (callNow) {
|
|||
|
|
result = func.apply(context, args);
|
|||
|
|
context = args = null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns the first function passed as an argument to the second,
|
|||
|
|
// allowing you to adjust arguments, run code before and after, and
|
|||
|
|
// conditionally execute the original function.
|
|||
|
|
_.wrap = function (func, wrapper) {
|
|||
|
|
return _.partial(wrapper, func);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a negated version of the passed-in predicate.
|
|||
|
|
_.negate = function (predicate) {
|
|||
|
|
return function () {
|
|||
|
|
return !predicate.apply(this, arguments);
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a function that is the composition of a list of functions, each
|
|||
|
|
// consuming the return value of the function that follows.
|
|||
|
|
_.compose = function () {
|
|||
|
|
var args = arguments;
|
|||
|
|
var start = args.length - 1;
|
|||
|
|
return function () {
|
|||
|
|
var i = start;
|
|||
|
|
var result = args[start].apply(this, arguments);
|
|||
|
|
while (i--) result = args[i].call(this, result);
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a function that will only be executed on and after the Nth call.
|
|||
|
|
_.after = function (times, func) {
|
|||
|
|
return function () {
|
|||
|
|
if (--times < 1) {
|
|||
|
|
return func.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a function that will only be executed up to (but not including) the Nth call.
|
|||
|
|
_.before = function (times, func) {
|
|||
|
|
var memo;
|
|||
|
|
return function () {
|
|||
|
|
if (--times > 0) {
|
|||
|
|
memo = func.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
if (times <= 1) func = null;
|
|||
|
|
return memo;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a function that will be executed at most one time, no matter how
|
|||
|
|
// often you call it. Useful for lazy initialization.
|
|||
|
|
_.once = _.partial(_.before, 2);
|
|||
|
|
|
|||
|
|
// Object Functions
|
|||
|
|
// ----------------
|
|||
|
|
|
|||
|
|
// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
|
|||
|
|
var hasEnumBug = !{ toString: null }.propertyIsEnumerable(
|
|||
|
|
"toString"
|
|||
|
|
);
|
|||
|
|
var nonEnumerableProps = [
|
|||
|
|
"valueOf",
|
|||
|
|
"isPrototypeOf",
|
|||
|
|
"toString",
|
|||
|
|
"propertyIsEnumerable",
|
|||
|
|
"hasOwnProperty",
|
|||
|
|
"toLocaleString",
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
function collectNonEnumProps(obj, keys) {
|
|||
|
|
var nonEnumIdx = nonEnumerableProps.length;
|
|||
|
|
var constructor = obj.constructor;
|
|||
|
|
var proto =
|
|||
|
|
(_.isFunction(constructor) && constructor.prototype) ||
|
|||
|
|
ObjProto;
|
|||
|
|
|
|||
|
|
// Constructor is a special case.
|
|||
|
|
var prop = "constructor";
|
|||
|
|
if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);
|
|||
|
|
|
|||
|
|
while (nonEnumIdx--) {
|
|||
|
|
prop = nonEnumerableProps[nonEnumIdx];
|
|||
|
|
if (
|
|||
|
|
prop in obj &&
|
|||
|
|
obj[prop] !== proto[prop] &&
|
|||
|
|
!_.contains(keys, prop)
|
|||
|
|
) {
|
|||
|
|
keys.push(prop);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Retrieve the names of an object's own properties.
|
|||
|
|
// Delegates to **ECMAScript 5**'s native `Object.keys`
|
|||
|
|
_.keys = function (obj) {
|
|||
|
|
if (!_.isObject(obj)) return [];
|
|||
|
|
if (nativeKeys) return nativeKeys(obj);
|
|||
|
|
var keys = [];
|
|||
|
|
for (var key in obj) if (_.has(obj, key)) keys.push(key);
|
|||
|
|
// Ahem, IE < 9.
|
|||
|
|
if (hasEnumBug) collectNonEnumProps(obj, keys);
|
|||
|
|
return keys;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Retrieve all the property names of an object.
|
|||
|
|
_.allKeys = function (obj) {
|
|||
|
|
if (!_.isObject(obj)) return [];
|
|||
|
|
var keys = [];
|
|||
|
|
for (var key in obj) keys.push(key);
|
|||
|
|
// Ahem, IE < 9.
|
|||
|
|
if (hasEnumBug) collectNonEnumProps(obj, keys);
|
|||
|
|
return keys;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Retrieve the values of an object's properties.
|
|||
|
|
_.values = function (obj) {
|
|||
|
|
var keys = _.keys(obj);
|
|||
|
|
var length = keys.length;
|
|||
|
|
var values = Array(length);
|
|||
|
|
for (var i = 0; i < length; i++) {
|
|||
|
|
values[i] = obj[keys[i]];
|
|||
|
|
}
|
|||
|
|
return values;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns the results of applying the iteratee to each element of the object
|
|||
|
|
// In contrast to _.map it returns an object
|
|||
|
|
_.mapObject = function (obj, iteratee, context) {
|
|||
|
|
iteratee = cb(iteratee, context);
|
|||
|
|
var keys = _.keys(obj),
|
|||
|
|
length = keys.length,
|
|||
|
|
results = {},
|
|||
|
|
currentKey;
|
|||
|
|
for (var index = 0; index < length; index++) {
|
|||
|
|
currentKey = keys[index];
|
|||
|
|
results[currentKey] = iteratee(
|
|||
|
|
obj[currentKey],
|
|||
|
|
currentKey,
|
|||
|
|
obj
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
return results;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Convert an object into a list of `[key, value]` pairs.
|
|||
|
|
_.pairs = function (obj) {
|
|||
|
|
var keys = _.keys(obj);
|
|||
|
|
var length = keys.length;
|
|||
|
|
var pairs = Array(length);
|
|||
|
|
for (var i = 0; i < length; i++) {
|
|||
|
|
pairs[i] = [keys[i], obj[keys[i]]];
|
|||
|
|
}
|
|||
|
|
return pairs;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Invert the keys and values of an object. The values must be serializable.
|
|||
|
|
_.invert = function (obj) {
|
|||
|
|
var result = {};
|
|||
|
|
var keys = _.keys(obj);
|
|||
|
|
for (var i = 0, length = keys.length; i < length; i++) {
|
|||
|
|
result[obj[keys[i]]] = keys[i];
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return a sorted list of the function names available on the object.
|
|||
|
|
// Aliased as `methods`
|
|||
|
|
_.functions = _.methods = function (obj) {
|
|||
|
|
var names = [];
|
|||
|
|
for (var key in obj) {
|
|||
|
|
if (_.isFunction(obj[key])) names.push(key);
|
|||
|
|
}
|
|||
|
|
return names.sort();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Extend a given object with all the properties in passed-in object(s).
|
|||
|
|
_.extend = createAssigner(_.allKeys);
|
|||
|
|
|
|||
|
|
// Assigns a given object with all the own properties in the passed-in object(s)
|
|||
|
|
// (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
|
|||
|
|
_.extendOwn = _.assign = createAssigner(_.keys);
|
|||
|
|
|
|||
|
|
// Returns the first key on an object that passes a predicate test
|
|||
|
|
_.findKey = function (obj, predicate, context) {
|
|||
|
|
predicate = cb(predicate, context);
|
|||
|
|
var keys = _.keys(obj),
|
|||
|
|
key;
|
|||
|
|
for (var i = 0, length = keys.length; i < length; i++) {
|
|||
|
|
key = keys[i];
|
|||
|
|
if (predicate(obj[key], key, obj)) return key;
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return a copy of the object only containing the whitelisted properties.
|
|||
|
|
_.pick = function (object, oiteratee, context) {
|
|||
|
|
var result = {},
|
|||
|
|
obj = object,
|
|||
|
|
iteratee,
|
|||
|
|
keys;
|
|||
|
|
if (obj == null) return result;
|
|||
|
|
if (_.isFunction(oiteratee)) {
|
|||
|
|
keys = _.allKeys(obj);
|
|||
|
|
iteratee = optimizeCb(oiteratee, context);
|
|||
|
|
} else {
|
|||
|
|
keys = flatten(arguments, false, false, 1);
|
|||
|
|
iteratee = function (value, key, obj) {
|
|||
|
|
return key in obj;
|
|||
|
|
};
|
|||
|
|
obj = Object(obj);
|
|||
|
|
}
|
|||
|
|
for (var i = 0, length = keys.length; i < length; i++) {
|
|||
|
|
var key = keys[i];
|
|||
|
|
var value = obj[key];
|
|||
|
|
if (iteratee(value, key, obj)) result[key] = value;
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return a copy of the object without the blacklisted properties.
|
|||
|
|
_.omit = function (obj, iteratee, context) {
|
|||
|
|
if (_.isFunction(iteratee)) {
|
|||
|
|
iteratee = _.negate(iteratee);
|
|||
|
|
} else {
|
|||
|
|
var keys = _.map(flatten(arguments, false, false, 1), String);
|
|||
|
|
iteratee = function (value, key) {
|
|||
|
|
return !_.contains(keys, key);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
return _.pick(obj, iteratee, context);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Fill in a given object with default properties.
|
|||
|
|
_.defaults = createAssigner(_.allKeys, true);
|
|||
|
|
|
|||
|
|
// Creates an object that inherits from the given prototype object.
|
|||
|
|
// If additional properties are provided then they will be added to the
|
|||
|
|
// created object.
|
|||
|
|
_.create = function (prototype, props) {
|
|||
|
|
var result = baseCreate(prototype);
|
|||
|
|
if (props) _.extendOwn(result, props);
|
|||
|
|
return result;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Create a (shallow-cloned) duplicate of an object.
|
|||
|
|
_.clone = function (obj) {
|
|||
|
|
if (!_.isObject(obj)) return obj;
|
|||
|
|
return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Invokes interceptor with the obj, and then returns obj.
|
|||
|
|
// The primary purpose of this method is to "tap into" a method chain, in
|
|||
|
|
// order to perform operations on intermediate results within the chain.
|
|||
|
|
_.tap = function (obj, interceptor) {
|
|||
|
|
interceptor(obj);
|
|||
|
|
return obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns whether an object has a given set of `key:value` pairs.
|
|||
|
|
_.isMatch = function (object, attrs) {
|
|||
|
|
var keys = _.keys(attrs),
|
|||
|
|
length = keys.length;
|
|||
|
|
if (object == null) return !length;
|
|||
|
|
var obj = Object(object);
|
|||
|
|
for (var i = 0; i < length; i++) {
|
|||
|
|
var key = keys[i];
|
|||
|
|
if (attrs[key] !== obj[key] || !(key in obj)) return false;
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Internal recursive comparison function for `isEqual`.
|
|||
|
|
var eq = function (a, b, aStack, bStack) {
|
|||
|
|
// Identical objects are equal. `0 === -0`, but they aren't identical.
|
|||
|
|
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
|
|||
|
|
if (a === b) return a !== 0 || 1 / a === 1 / b;
|
|||
|
|
// A strict comparison is necessary because `null == undefined`.
|
|||
|
|
if (a == null || b == null) return a === b;
|
|||
|
|
// Unwrap any wrapped objects.
|
|||
|
|
if (a instanceof _) a = a._wrapped;
|
|||
|
|
if (b instanceof _) b = b._wrapped;
|
|||
|
|
// Compare `[[Class]]` names.
|
|||
|
|
var className = toString.call(a);
|
|||
|
|
if (className !== toString.call(b)) return false;
|
|||
|
|
switch (className) {
|
|||
|
|
// Strings, numbers, regular expressions, dates, and booleans are compared by value.
|
|||
|
|
case "[object RegExp]":
|
|||
|
|
// RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
|
|||
|
|
case "[object String]":
|
|||
|
|
// Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
|
|||
|
|
// equivalent to `new String("5")`.
|
|||
|
|
return "" + a === "" + b;
|
|||
|
|
case "[object Number]":
|
|||
|
|
// `NaN`s are equivalent, but non-reflexive.
|
|||
|
|
// Object(NaN) is equivalent to NaN
|
|||
|
|
if (+a !== +a) return +b !== +b;
|
|||
|
|
// An `egal` comparison is performed for other numeric values.
|
|||
|
|
return +a === 0 ? 1 / +a === 1 / b : +a === +b;
|
|||
|
|
case "[object Date]":
|
|||
|
|
case "[object Boolean]":
|
|||
|
|
// Coerce dates and booleans to numeric primitive values. Dates are compared by their
|
|||
|
|
// millisecond representations. Note that invalid dates with millisecond representations
|
|||
|
|
// of `NaN` are not equivalent.
|
|||
|
|
return +a === +b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var areArrays = className === "[object Array]";
|
|||
|
|
if (!areArrays) {
|
|||
|
|
if (typeof a != "object" || typeof b != "object") return false;
|
|||
|
|
|
|||
|
|
// Objects with different constructors are not equivalent, but `Object`s or `Array`s
|
|||
|
|
// from different frames are.
|
|||
|
|
var aCtor = a.constructor,
|
|||
|
|
bCtor = b.constructor;
|
|||
|
|
if (
|
|||
|
|
aCtor !== bCtor &&
|
|||
|
|
!(
|
|||
|
|
_.isFunction(aCtor) &&
|
|||
|
|
aCtor instanceof aCtor &&
|
|||
|
|
_.isFunction(bCtor) &&
|
|||
|
|
bCtor instanceof bCtor
|
|||
|
|
) &&
|
|||
|
|
"constructor" in a &&
|
|||
|
|
"constructor" in b
|
|||
|
|
) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// Assume equality for cyclic structures. The algorithm for detecting cyclic
|
|||
|
|
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
|
|||
|
|
|
|||
|
|
// Initializing stack of traversed objects.
|
|||
|
|
// It's done here since we only need them for objects and arrays comparison.
|
|||
|
|
aStack = aStack || [];
|
|||
|
|
bStack = bStack || [];
|
|||
|
|
var length = aStack.length;
|
|||
|
|
while (length--) {
|
|||
|
|
// Linear search. Performance is inversely proportional to the number of
|
|||
|
|
// unique nested structures.
|
|||
|
|
if (aStack[length] === a) return bStack[length] === b;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Add the first object to the stack of traversed objects.
|
|||
|
|
aStack.push(a);
|
|||
|
|
bStack.push(b);
|
|||
|
|
|
|||
|
|
// Recursively compare objects and arrays.
|
|||
|
|
if (areArrays) {
|
|||
|
|
// Compare array lengths to determine if a deep comparison is necessary.
|
|||
|
|
length = a.length;
|
|||
|
|
if (length !== b.length) return false;
|
|||
|
|
// Deep compare the contents, ignoring non-numeric properties.
|
|||
|
|
while (length--) {
|
|||
|
|
if (!eq(a[length], b[length], aStack, bStack)) return false;
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
// Deep compare objects.
|
|||
|
|
var keys = _.keys(a),
|
|||
|
|
key;
|
|||
|
|
length = keys.length;
|
|||
|
|
// Ensure that both objects contain the same number of properties before comparing deep equality.
|
|||
|
|
if (_.keys(b).length !== length) return false;
|
|||
|
|
while (length--) {
|
|||
|
|
// Deep compare each member
|
|||
|
|
key = keys[length];
|
|||
|
|
if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack)))
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// Remove the first object from the stack of traversed objects.
|
|||
|
|
aStack.pop();
|
|||
|
|
bStack.pop();
|
|||
|
|
return true;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Perform a deep comparison to check if two objects are equal.
|
|||
|
|
_.isEqual = function (a, b) {
|
|||
|
|
return eq(a, b);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given array, string, or object empty?
|
|||
|
|
// An "empty" object has no enumerable own-properties.
|
|||
|
|
_.isEmpty = function (obj) {
|
|||
|
|
if (obj == null) return true;
|
|||
|
|
if (
|
|||
|
|
isArrayLike(obj) &&
|
|||
|
|
(_.isArray(obj) || _.isString(obj) || _.isArguments(obj))
|
|||
|
|
)
|
|||
|
|
return obj.length === 0;
|
|||
|
|
return _.keys(obj).length === 0;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given value a DOM element?
|
|||
|
|
_.isElement = function (obj) {
|
|||
|
|
return !!(obj && obj.nodeType === 1);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given value an array?
|
|||
|
|
// Delegates to ECMA5's native Array.isArray
|
|||
|
|
_.isArray =
|
|||
|
|
nativeIsArray ||
|
|||
|
|
function (obj) {
|
|||
|
|
return toString.call(obj) === "[object Array]";
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given variable an object?
|
|||
|
|
_.isObject = function (obj) {
|
|||
|
|
var type = typeof obj;
|
|||
|
|
return type === "function" || (type === "object" && !!obj);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.
|
|||
|
|
_.each(
|
|||
|
|
[
|
|||
|
|
"Arguments",
|
|||
|
|
"Function",
|
|||
|
|
"String",
|
|||
|
|
"Number",
|
|||
|
|
"Date",
|
|||
|
|
"RegExp",
|
|||
|
|
"Error",
|
|||
|
|
],
|
|||
|
|
function (name) {
|
|||
|
|
_["is" + name] = function (obj) {
|
|||
|
|
return toString.call(obj) === "[object " + name + "]";
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// Define a fallback version of the method in browsers (ahem, IE < 9), where
|
|||
|
|
// there isn't any inspectable "Arguments" type.
|
|||
|
|
if (!_.isArguments(arguments)) {
|
|||
|
|
_.isArguments = function (obj) {
|
|||
|
|
return _.has(obj, "callee");
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
|
|||
|
|
// IE 11 (#1621), and in Safari 8 (#1929).
|
|||
|
|
if (typeof /./ != "function" && typeof Int8Array != "object") {
|
|||
|
|
_.isFunction = function (obj) {
|
|||
|
|
return typeof obj == "function" || false;
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Is a given object a finite number?
|
|||
|
|
_.isFinite = function (obj) {
|
|||
|
|
return isFinite(obj) && !isNaN(parseFloat(obj));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is the given value `NaN`? (NaN is the only number which does not equal itself).
|
|||
|
|
_.isNaN = function (obj) {
|
|||
|
|
return _.isNumber(obj) && obj !== +obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given value a boolean?
|
|||
|
|
_.isBoolean = function (obj) {
|
|||
|
|
return (
|
|||
|
|
obj === true ||
|
|||
|
|
obj === false ||
|
|||
|
|
toString.call(obj) === "[object Boolean]"
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given value equal to null?
|
|||
|
|
_.isNull = function (obj) {
|
|||
|
|
return obj === null;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Is a given variable undefined?
|
|||
|
|
_.isUndefined = function (obj) {
|
|||
|
|
return obj === void 0;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Shortcut function for checking if an object has a given property directly
|
|||
|
|
// on itself (in other words, not on a prototype).
|
|||
|
|
_.has = function (obj, key) {
|
|||
|
|
return obj != null && hasOwnProperty.call(obj, key);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Utility Functions
|
|||
|
|
// -----------------
|
|||
|
|
|
|||
|
|
// Run Underscore.js in *noConflict* mode, returning the `_` variable to its
|
|||
|
|
// previous owner. Returns a reference to the Underscore object.
|
|||
|
|
_.noConflict = function () {
|
|||
|
|
root._ = previousUnderscore;
|
|||
|
|
return this;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Keep the identity function around for default iteratees.
|
|||
|
|
_.identity = function (value) {
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Predicate-generating functions. Often useful outside of Underscore.
|
|||
|
|
_.constant = function (value) {
|
|||
|
|
return function () {
|
|||
|
|
return value;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
_.noop = function () {};
|
|||
|
|
|
|||
|
|
_.property = property;
|
|||
|
|
|
|||
|
|
// Generates a function for a given object that returns a given property.
|
|||
|
|
_.propertyOf = function (obj) {
|
|||
|
|
return obj == null
|
|||
|
|
? function () {}
|
|||
|
|
: function (key) {
|
|||
|
|
return obj[key];
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Returns a predicate for checking whether an object has a given set of
|
|||
|
|
// `key:value` pairs.
|
|||
|
|
_.matcher = _.matches = function (attrs) {
|
|||
|
|
attrs = _.extendOwn({}, attrs);
|
|||
|
|
return function (obj) {
|
|||
|
|
return _.isMatch(obj, attrs);
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Run a function **n** times.
|
|||
|
|
_.times = function (n, iteratee, context) {
|
|||
|
|
var accum = Array(Math.max(0, n));
|
|||
|
|
iteratee = optimizeCb(iteratee, context, 1);
|
|||
|
|
for (var i = 0; i < n; i++) accum[i] = iteratee(i);
|
|||
|
|
return accum;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Return a random integer between min and max (inclusive).
|
|||
|
|
_.random = function (min, max) {
|
|||
|
|
if (max == null) {
|
|||
|
|
max = min;
|
|||
|
|
min = 0;
|
|||
|
|
}
|
|||
|
|
return min + Math.floor(Math.random() * (max - min + 1));
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// A (possibly faster) way to get the current timestamp as an integer.
|
|||
|
|
_.now =
|
|||
|
|
Date.now ||
|
|||
|
|
function () {
|
|||
|
|
return new Date().getTime();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// List of HTML entities for escaping.
|
|||
|
|
var escapeMap = {
|
|||
|
|
"&": "&",
|
|||
|
|
"<": "<",
|
|||
|
|
">": ">",
|
|||
|
|
'"': """,
|
|||
|
|
"'": "'",
|
|||
|
|
"`": "`",
|
|||
|
|
};
|
|||
|
|
var unescapeMap = _.invert(escapeMap);
|
|||
|
|
|
|||
|
|
// Functions for escaping and unescaping strings to/from HTML interpolation.
|
|||
|
|
var createEscaper = function (map) {
|
|||
|
|
var escaper = function (match) {
|
|||
|
|
return map[match];
|
|||
|
|
};
|
|||
|
|
// Regexes for identifying a key that needs to be escaped
|
|||
|
|
var source = "(?:" + _.keys(map).join("|") + ")";
|
|||
|
|
var testRegexp = RegExp(source);
|
|||
|
|
var replaceRegexp = RegExp(source, "g");
|
|||
|
|
return function (string) {
|
|||
|
|
string = string == null ? "" : "" + string;
|
|||
|
|
return testRegexp.test(string)
|
|||
|
|
? string.replace(replaceRegexp, escaper)
|
|||
|
|
: string;
|
|||
|
|
};
|
|||
|
|
};
|
|||
|
|
_.escape = createEscaper(escapeMap);
|
|||
|
|
_.unescape = createEscaper(unescapeMap);
|
|||
|
|
|
|||
|
|
// If the value of the named `property` is a function then invoke it with the
|
|||
|
|
// `object` as context; otherwise, return it.
|
|||
|
|
_.result = function (object, property, fallback) {
|
|||
|
|
var value = object == null ? void 0 : object[property];
|
|||
|
|
if (value === void 0) {
|
|||
|
|
value = fallback;
|
|||
|
|
}
|
|||
|
|
return _.isFunction(value) ? value.call(object) : value;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Generate a unique integer id (unique within the entire client session).
|
|||
|
|
// Useful for temporary DOM ids.
|
|||
|
|
var idCounter = 0;
|
|||
|
|
_.uniqueId = function (prefix) {
|
|||
|
|
var id = ++idCounter + "";
|
|||
|
|
return prefix ? prefix + id : id;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// By default, Underscore uses ERB-style template delimiters, change the
|
|||
|
|
// following template settings to use alternative delimiters.
|
|||
|
|
_.templateSettings = {
|
|||
|
|
evaluate: /<%([\s\S]+?)%>/g,
|
|||
|
|
interpolate: /<%=([\s\S]+?)%>/g,
|
|||
|
|
escape: /<%-([\s\S]+?)%>/g,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// When customizing `templateSettings`, if you don't want to define an
|
|||
|
|
// interpolation, evaluation or escaping regex, we need one that is
|
|||
|
|
// guaranteed not to match.
|
|||
|
|
var noMatch = /(.)^/;
|
|||
|
|
|
|||
|
|
// Certain characters need to be escaped so that they can be put into a
|
|||
|
|
// string literal.
|
|||
|
|
var escapes = {
|
|||
|
|
"'": "'",
|
|||
|
|
"\\": "\\",
|
|||
|
|
"\r": "r",
|
|||
|
|
"\n": "n",
|
|||
|
|
"\u2028": "u2028",
|
|||
|
|
"\u2029": "u2029",
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
|
|||
|
|
|
|||
|
|
var escapeChar = function (match) {
|
|||
|
|
return "\\" + escapes[match];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// JavaScript micro-templating, similar to John Resig's implementation.
|
|||
|
|
// Underscore templating handles arbitrary delimiters, preserves whitespace,
|
|||
|
|
// and correctly escapes quotes within interpolated code.
|
|||
|
|
// NB: `oldSettings` only exists for backwards compatibility.
|
|||
|
|
_.template = function (text, settings, oldSettings) {
|
|||
|
|
if (!settings && oldSettings) settings = oldSettings;
|
|||
|
|
settings = _.defaults({}, settings, _.templateSettings);
|
|||
|
|
|
|||
|
|
// Combine delimiters into one regular expression via alternation.
|
|||
|
|
var matcher = RegExp(
|
|||
|
|
[
|
|||
|
|
(settings.escape || noMatch).source,
|
|||
|
|
(settings.interpolate || noMatch).source,
|
|||
|
|
(settings.evaluate || noMatch).source,
|
|||
|
|
].join("|") + "|$",
|
|||
|
|
"g"
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// Compile the template source, escaping string literals appropriately.
|
|||
|
|
var index = 0;
|
|||
|
|
var source = "__p+='";
|
|||
|
|
text.replace(
|
|||
|
|
matcher,
|
|||
|
|
function (match, escape, interpolate, evaluate, offset) {
|
|||
|
|
source += text
|
|||
|
|
.slice(index, offset)
|
|||
|
|
.replace(escaper, escapeChar);
|
|||
|
|
index = offset + match.length;
|
|||
|
|
|
|||
|
|
if (escape) {
|
|||
|
|
source +=
|
|||
|
|
"'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
|
|||
|
|
} else if (interpolate) {
|
|||
|
|
source +=
|
|||
|
|
"'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
|
|||
|
|
} else if (evaluate) {
|
|||
|
|
source += "';\n" + evaluate + "\n__p+='";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Adobe VMs need the match returned to produce the correct offest.
|
|||
|
|
return match;
|
|||
|
|
}
|
|||
|
|
);
|
|||
|
|
source += "';\n";
|
|||
|
|
|
|||
|
|
// If a variable is not specified, place data values in local scope.
|
|||
|
|
if (!settings.variable)
|
|||
|
|
source = "with(obj||{}){\n" + source + "}\n";
|
|||
|
|
|
|||
|
|
source =
|
|||
|
|
"var __t,__p='',__j=Array.prototype.join," +
|
|||
|
|
"print=function(){__p+=__j.call(arguments,'');};\n" +
|
|||
|
|
source +
|
|||
|
|
"return __p;\n";
|
|||
|
|
|
|||
|
|
try {
|
|||
|
|
var render = new Function(
|
|||
|
|
settings.variable || "obj",
|
|||
|
|
"_",
|
|||
|
|
source
|
|||
|
|
);
|
|||
|
|
} catch (e) {
|
|||
|
|
e.source = source;
|
|||
|
|
throw e;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var template = function (data) {
|
|||
|
|
return render.call(this, data, _);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Provide the compiled source as a convenience for precompilation.
|
|||
|
|
var argument = settings.variable || "obj";
|
|||
|
|
template.source = "function(" + argument + "){\n" + source + "}";
|
|||
|
|
|
|||
|
|
return template;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Add a "chain" function. Start chaining a wrapped Underscore object.
|
|||
|
|
_.chain = function (obj) {
|
|||
|
|
var instance = _(obj);
|
|||
|
|
instance._chain = true;
|
|||
|
|
return instance;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// OOP
|
|||
|
|
// ---------------
|
|||
|
|
// If Underscore is called as a function, it returns a wrapped object that
|
|||
|
|
// can be used OO-style. This wrapper holds altered versions of all the
|
|||
|
|
// underscore functions. Wrapped objects may be chained.
|
|||
|
|
|
|||
|
|
// Helper function to continue chaining intermediate results.
|
|||
|
|
var result = function (instance, obj) {
|
|||
|
|
return instance._chain ? _(obj).chain() : obj;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Add your own custom functions to the Underscore object.
|
|||
|
|
_.mixin = function (obj) {
|
|||
|
|
_.each(_.functions(obj), function (name) {
|
|||
|
|
var func = (_[name] = obj[name]);
|
|||
|
|
_.prototype[name] = function () {
|
|||
|
|
var args = [this._wrapped];
|
|||
|
|
push.apply(args, arguments);
|
|||
|
|
return result(this, func.apply(_, args));
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Add all of the Underscore functions to the wrapper object.
|
|||
|
|
_.mixin(_);
|
|||
|
|
|
|||
|
|
// Add all mutator Array functions to the wrapper.
|
|||
|
|
_.each(
|
|||
|
|
["pop", "push", "reverse", "shift", "sort", "splice", "unshift"],
|
|||
|
|
function (name) {
|
|||
|
|
var method = ArrayProto[name];
|
|||
|
|
_.prototype[name] = function () {
|
|||
|
|
var obj = this._wrapped;
|
|||
|
|
method.apply(obj, arguments);
|
|||
|
|
if (
|
|||
|
|
(name === "shift" || name === "splice") &&
|
|||
|
|
obj.length === 0
|
|||
|
|
)
|
|||
|
|
delete obj[0];
|
|||
|
|
return result(this, obj);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
// Add all accessor Array functions to the wrapper.
|
|||
|
|
_.each(["concat", "join", "slice"], function (name) {
|
|||
|
|
var method = ArrayProto[name];
|
|||
|
|
_.prototype[name] = function () {
|
|||
|
|
return result(this, method.apply(this._wrapped, arguments));
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
// Extracts the result from a wrapped and chained object.
|
|||
|
|
_.prototype.value = function () {
|
|||
|
|
return this._wrapped;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Provide unwrapping proxy for some methods used in engine operations
|
|||
|
|
// such as arithmetic and JSON stringification.
|
|||
|
|
_.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
|
|||
|
|
|
|||
|
|
_.prototype.toString = function () {
|
|||
|
|
return "" + this._wrapped;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// AMD registration happens at the end for compatibility with AMD loaders
|
|||
|
|
// that may not enforce next-turn semantics on modules. Even though general
|
|||
|
|
// practice for AMD registration is to be anonymous, underscore registers
|
|||
|
|
// as a named module because, like jQuery, it is a base library that is
|
|||
|
|
// popular enough to be bundled in a third party lib, but not be part of
|
|||
|
|
// an AMD load request. Those cases could generate an error when an
|
|||
|
|
// anonymous define() is called outside of a loader request.
|
|||
|
|
if (typeof define === "function" && define.amd) {
|
|||
|
|
define("underscore", [], function () {
|
|||
|
|
return _;
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
}.call(this));
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
26: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
arguments[4][19][0].apply(exports, arguments);
|
|||
|
|
},
|
|||
|
|
{ dup: 19 },
|
|||
|
|
],
|
|||
|
|
27: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
module.exports = function isBuffer(arg) {
|
|||
|
|
return (
|
|||
|
|
arg &&
|
|||
|
|
typeof arg === "object" &&
|
|||
|
|
typeof arg.copy === "function" &&
|
|||
|
|
typeof arg.fill === "function" &&
|
|||
|
|
typeof arg.readUInt8 === "function"
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
28: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
(function (process, global) {
|
|||
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|||
|
|
//
|
|||
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|||
|
|
// copy of this software and associated documentation files (the
|
|||
|
|
// "Software"), to deal in the Software without restriction, including
|
|||
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|||
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|||
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|||
|
|
// following conditions:
|
|||
|
|
//
|
|||
|
|
// The above copyright notice and this permission notice shall be included
|
|||
|
|
// in all copies or substantial portions of the Software.
|
|||
|
|
//
|
|||
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|||
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|||
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|||
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|||
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|||
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|||
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|
|
|||
|
|
var formatRegExp = /%[sdj%]/g;
|
|||
|
|
exports.format = function (f) {
|
|||
|
|
if (!isString(f)) {
|
|||
|
|
var objects = [];
|
|||
|
|
for (var i = 0; i < arguments.length; i++) {
|
|||
|
|
objects.push(inspect(arguments[i]));
|
|||
|
|
}
|
|||
|
|
return objects.join(" ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var i = 1;
|
|||
|
|
var args = arguments;
|
|||
|
|
var len = args.length;
|
|||
|
|
var str = String(f).replace(formatRegExp, function (x) {
|
|||
|
|
if (x === "%%") return "%";
|
|||
|
|
if (i >= len) return x;
|
|||
|
|
switch (x) {
|
|||
|
|
case "%s":
|
|||
|
|
return String(args[i++]);
|
|||
|
|
case "%d":
|
|||
|
|
return Number(args[i++]);
|
|||
|
|
case "%j":
|
|||
|
|
try {
|
|||
|
|
return JSON.stringify(args[i++]);
|
|||
|
|
} catch (_) {
|
|||
|
|
return "[Circular]";
|
|||
|
|
}
|
|||
|
|
default:
|
|||
|
|
return x;
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|||
|
|
if (isNull(x) || !isObject(x)) {
|
|||
|
|
str += " " + x;
|
|||
|
|
} else {
|
|||
|
|
str += " " + inspect(x);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return str;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Mark that a method should not be used.
|
|||
|
|
// Returns a modified function which warns once by default.
|
|||
|
|
// If --no-deprecation is set, then it is a no-op.
|
|||
|
|
exports.deprecate = function (fn, msg) {
|
|||
|
|
// Allow for deprecating things in the process of starting up.
|
|||
|
|
if (isUndefined(global.process)) {
|
|||
|
|
return function () {
|
|||
|
|
return exports.deprecate(fn, msg).apply(this, arguments);
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (process.noDeprecation === true) {
|
|||
|
|
return fn;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var warned = false;
|
|||
|
|
function deprecated() {
|
|||
|
|
if (!warned) {
|
|||
|
|
if (process.throwDeprecation) {
|
|||
|
|
throw new Error(msg);
|
|||
|
|
} else if (process.traceDeprecation) {
|
|||
|
|
console.trace(msg);
|
|||
|
|
} else {
|
|||
|
|
console.error(msg);
|
|||
|
|
}
|
|||
|
|
warned = true;
|
|||
|
|
}
|
|||
|
|
return fn.apply(this, arguments);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return deprecated;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
var debugs = {};
|
|||
|
|
var debugEnviron;
|
|||
|
|
exports.debuglog = function (set) {
|
|||
|
|
if (isUndefined(debugEnviron))
|
|||
|
|
debugEnviron = process.env.NODE_DEBUG || "";
|
|||
|
|
set = set.toUpperCase();
|
|||
|
|
if (!debugs[set]) {
|
|||
|
|
if (new RegExp("\\b" + set + "\\b", "i").test(debugEnviron)) {
|
|||
|
|
var pid = process.pid;
|
|||
|
|
debugs[set] = function () {
|
|||
|
|
var msg = exports.format.apply(exports, arguments);
|
|||
|
|
console.error("%s %d: %s", set, pid, msg);
|
|||
|
|
};
|
|||
|
|
} else {
|
|||
|
|
debugs[set] = function () {};
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return debugs[set];
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Echos the value of a value. Trys to print the value out
|
|||
|
|
* in the best way possible given the different types.
|
|||
|
|
*
|
|||
|
|
* @param {Object} obj The object to print out.
|
|||
|
|
* @param {Object} opts Optional options object that alters the output.
|
|||
|
|
*/
|
|||
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|||
|
|
function inspect(obj, opts) {
|
|||
|
|
// default options
|
|||
|
|
var ctx = {
|
|||
|
|
seen: [],
|
|||
|
|
stylize: stylizeNoColor,
|
|||
|
|
};
|
|||
|
|
// legacy...
|
|||
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|||
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|||
|
|
if (isBoolean(opts)) {
|
|||
|
|
// legacy...
|
|||
|
|
ctx.showHidden = opts;
|
|||
|
|
} else if (opts) {
|
|||
|
|
// got an "options" object
|
|||
|
|
exports._extend(ctx, opts);
|
|||
|
|
}
|
|||
|
|
// set default options
|
|||
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|||
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|||
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|||
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|||
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|||
|
|
return formatValue(ctx, obj, ctx.depth);
|
|||
|
|
}
|
|||
|
|
exports.inspect = inspect;
|
|||
|
|
|
|||
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|||
|
|
inspect.colors = {
|
|||
|
|
bold: [1, 22],
|
|||
|
|
italic: [3, 23],
|
|||
|
|
underline: [4, 24],
|
|||
|
|
inverse: [7, 27],
|
|||
|
|
white: [37, 39],
|
|||
|
|
grey: [90, 39],
|
|||
|
|
black: [30, 39],
|
|||
|
|
blue: [34, 39],
|
|||
|
|
cyan: [36, 39],
|
|||
|
|
green: [32, 39],
|
|||
|
|
magenta: [35, 39],
|
|||
|
|
red: [31, 39],
|
|||
|
|
yellow: [33, 39],
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
// Don't use 'blue' not visible on cmd.exe
|
|||
|
|
inspect.styles = {
|
|||
|
|
special: "cyan",
|
|||
|
|
number: "yellow",
|
|||
|
|
boolean: "yellow",
|
|||
|
|
undefined: "grey",
|
|||
|
|
null: "bold",
|
|||
|
|
string: "green",
|
|||
|
|
date: "magenta",
|
|||
|
|
// "name": intentionally not styling
|
|||
|
|
regexp: "red",
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function stylizeWithColor(str, styleType) {
|
|||
|
|
var style = inspect.styles[styleType];
|
|||
|
|
|
|||
|
|
if (style) {
|
|||
|
|
return (
|
|||
|
|
"\u001b[" +
|
|||
|
|
inspect.colors[style][0] +
|
|||
|
|
"m" +
|
|||
|
|
str +
|
|||
|
|
"\u001b[" +
|
|||
|
|
inspect.colors[style][1] +
|
|||
|
|
"m"
|
|||
|
|
);
|
|||
|
|
} else {
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function stylizeNoColor(str, styleType) {
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function arrayToHash(array) {
|
|||
|
|
var hash = {};
|
|||
|
|
|
|||
|
|
array.forEach(function (val, idx) {
|
|||
|
|
hash[val] = true;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return hash;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatValue(ctx, value, recurseTimes) {
|
|||
|
|
// Provide a hook for user-specified inspect functions.
|
|||
|
|
// Check that value is an object with an inspect function on it
|
|||
|
|
if (
|
|||
|
|
ctx.customInspect &&
|
|||
|
|
value &&
|
|||
|
|
isFunction(value.inspect) &&
|
|||
|
|
// Filter out the util module, it's inspect function is special
|
|||
|
|
value.inspect !== exports.inspect &&
|
|||
|
|
// Also filter out any prototype objects using the circular check.
|
|||
|
|
!(value.constructor && value.constructor.prototype === value)
|
|||
|
|
) {
|
|||
|
|
var ret = value.inspect(recurseTimes, ctx);
|
|||
|
|
if (!isString(ret)) {
|
|||
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Primitive types cannot have properties
|
|||
|
|
var primitive = formatPrimitive(ctx, value);
|
|||
|
|
if (primitive) {
|
|||
|
|
return primitive;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Look up the keys of the object.
|
|||
|
|
var keys = Object.keys(value);
|
|||
|
|
var visibleKeys = arrayToHash(keys);
|
|||
|
|
|
|||
|
|
if (ctx.showHidden) {
|
|||
|
|
keys = Object.getOwnPropertyNames(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// IE doesn't make error fields non-enumerable
|
|||
|
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|||
|
|
if (
|
|||
|
|
isError(value) &&
|
|||
|
|
(keys.indexOf("message") >= 0 ||
|
|||
|
|
keys.indexOf("description") >= 0)
|
|||
|
|
) {
|
|||
|
|
return formatError(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Some type of object without properties can be shortcutted.
|
|||
|
|
if (keys.length === 0) {
|
|||
|
|
if (isFunction(value)) {
|
|||
|
|
var name = value.name ? ": " + value.name : "";
|
|||
|
|
return ctx.stylize("[Function" + name + "]", "special");
|
|||
|
|
}
|
|||
|
|
if (isRegExp(value)) {
|
|||
|
|
return ctx.stylize(
|
|||
|
|
RegExp.prototype.toString.call(value),
|
|||
|
|
"regexp"
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
if (isDate(value)) {
|
|||
|
|
return ctx.stylize(
|
|||
|
|
Date.prototype.toString.call(value),
|
|||
|
|
"date"
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
if (isError(value)) {
|
|||
|
|
return formatError(value);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var base = "",
|
|||
|
|
array = false,
|
|||
|
|
braces = ["{", "}"];
|
|||
|
|
|
|||
|
|
// Make Array say that they are Array
|
|||
|
|
if (isArray(value)) {
|
|||
|
|
array = true;
|
|||
|
|
braces = ["[", "]"];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Make functions say that they are functions
|
|||
|
|
if (isFunction(value)) {
|
|||
|
|
var n = value.name ? ": " + value.name : "";
|
|||
|
|
base = " [Function" + n + "]";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Make RegExps say that they are RegExps
|
|||
|
|
if (isRegExp(value)) {
|
|||
|
|
base = " " + RegExp.prototype.toString.call(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Make dates with properties first say the date
|
|||
|
|
if (isDate(value)) {
|
|||
|
|
base = " " + Date.prototype.toUTCString.call(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Make error with message first say the error
|
|||
|
|
if (isError(value)) {
|
|||
|
|
base = " " + formatError(value);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|||
|
|
return braces[0] + base + braces[1];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (recurseTimes < 0) {
|
|||
|
|
if (isRegExp(value)) {
|
|||
|
|
return ctx.stylize(
|
|||
|
|
RegExp.prototype.toString.call(value),
|
|||
|
|
"regexp"
|
|||
|
|
);
|
|||
|
|
} else {
|
|||
|
|
return ctx.stylize("[Object]", "special");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ctx.seen.push(value);
|
|||
|
|
|
|||
|
|
var output;
|
|||
|
|
if (array) {
|
|||
|
|
output = formatArray(
|
|||
|
|
ctx,
|
|||
|
|
value,
|
|||
|
|
recurseTimes,
|
|||
|
|
visibleKeys,
|
|||
|
|
keys
|
|||
|
|
);
|
|||
|
|
} else {
|
|||
|
|
output = keys.map(function (key) {
|
|||
|
|
return formatProperty(
|
|||
|
|
ctx,
|
|||
|
|
value,
|
|||
|
|
recurseTimes,
|
|||
|
|
visibleKeys,
|
|||
|
|
key,
|
|||
|
|
array
|
|||
|
|
);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ctx.seen.pop();
|
|||
|
|
|
|||
|
|
return reduceToSingleString(output, base, braces);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatPrimitive(ctx, value) {
|
|||
|
|
if (isUndefined(value))
|
|||
|
|
return ctx.stylize("undefined", "undefined");
|
|||
|
|
if (isString(value)) {
|
|||
|
|
var simple =
|
|||
|
|
"'" +
|
|||
|
|
JSON.stringify(value)
|
|||
|
|
.replace(/^"|"$/g, "")
|
|||
|
|
.replace(/'/g, "\\'")
|
|||
|
|
.replace(/\\"/g, '"') +
|
|||
|
|
"'";
|
|||
|
|
return ctx.stylize(simple, "string");
|
|||
|
|
}
|
|||
|
|
if (isNumber(value)) return ctx.stylize("" + value, "number");
|
|||
|
|
if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
|
|||
|
|
// For some reason typeof null is "object", so special case here.
|
|||
|
|
if (isNull(value)) return ctx.stylize("null", "null");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatError(value) {
|
|||
|
|
return "[" + Error.prototype.toString.call(value) + "]";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|||
|
|
var output = [];
|
|||
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|||
|
|
if (hasOwnProperty(value, String(i))) {
|
|||
|
|
output.push(
|
|||
|
|
formatProperty(
|
|||
|
|
ctx,
|
|||
|
|
value,
|
|||
|
|
recurseTimes,
|
|||
|
|
visibleKeys,
|
|||
|
|
String(i),
|
|||
|
|
true
|
|||
|
|
)
|
|||
|
|
);
|
|||
|
|
} else {
|
|||
|
|
output.push("");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
keys.forEach(function (key) {
|
|||
|
|
if (!key.match(/^\d+$/)) {
|
|||
|
|
output.push(
|
|||
|
|
formatProperty(
|
|||
|
|
ctx,
|
|||
|
|
value,
|
|||
|
|
recurseTimes,
|
|||
|
|
visibleKeys,
|
|||
|
|
key,
|
|||
|
|
true
|
|||
|
|
)
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
return output;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatProperty(
|
|||
|
|
ctx,
|
|||
|
|
value,
|
|||
|
|
recurseTimes,
|
|||
|
|
visibleKeys,
|
|||
|
|
key,
|
|||
|
|
array
|
|||
|
|
) {
|
|||
|
|
var name, str, desc;
|
|||
|
|
desc = Object.getOwnPropertyDescriptor(value, key) || {
|
|||
|
|
value: value[key],
|
|||
|
|
};
|
|||
|
|
if (desc.get) {
|
|||
|
|
if (desc.set) {
|
|||
|
|
str = ctx.stylize("[Getter/Setter]", "special");
|
|||
|
|
} else {
|
|||
|
|
str = ctx.stylize("[Getter]", "special");
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
if (desc.set) {
|
|||
|
|
str = ctx.stylize("[Setter]", "special");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|||
|
|
name = "[" + key + "]";
|
|||
|
|
}
|
|||
|
|
if (!str) {
|
|||
|
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
|||
|
|
if (isNull(recurseTimes)) {
|
|||
|
|
str = formatValue(ctx, desc.value, null);
|
|||
|
|
} else {
|
|||
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|||
|
|
}
|
|||
|
|
if (str.indexOf("\n") > -1) {
|
|||
|
|
if (array) {
|
|||
|
|
str = str
|
|||
|
|
.split("\n")
|
|||
|
|
.map(function (line) {
|
|||
|
|
return " " + line;
|
|||
|
|
})
|
|||
|
|
.join("\n")
|
|||
|
|
.substr(2);
|
|||
|
|
} else {
|
|||
|
|
str =
|
|||
|
|
"\n" +
|
|||
|
|
str
|
|||
|
|
.split("\n")
|
|||
|
|
.map(function (line) {
|
|||
|
|
return " " + line;
|
|||
|
|
})
|
|||
|
|
.join("\n");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
str = ctx.stylize("[Circular]", "special");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (isUndefined(name)) {
|
|||
|
|
if (array && key.match(/^\d+$/)) {
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
name = JSON.stringify("" + key);
|
|||
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|||
|
|
name = name.substr(1, name.length - 2);
|
|||
|
|
name = ctx.stylize(name, "name");
|
|||
|
|
} else {
|
|||
|
|
name = name
|
|||
|
|
.replace(/'/g, "\\'")
|
|||
|
|
.replace(/\\"/g, '"')
|
|||
|
|
.replace(/(^"|"$)/g, "'");
|
|||
|
|
name = ctx.stylize(name, "string");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return name + ": " + str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function reduceToSingleString(output, base, braces) {
|
|||
|
|
var numLinesEst = 0;
|
|||
|
|
var length = output.reduce(function (prev, cur) {
|
|||
|
|
numLinesEst++;
|
|||
|
|
if (cur.indexOf("\n") >= 0) numLinesEst++;
|
|||
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
|
|||
|
|
}, 0);
|
|||
|
|
|
|||
|
|
if (length > 60) {
|
|||
|
|
return (
|
|||
|
|
braces[0] +
|
|||
|
|
(base === "" ? "" : base + "\n ") +
|
|||
|
|
" " +
|
|||
|
|
output.join(",\n ") +
|
|||
|
|
" " +
|
|||
|
|
braces[1]
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return (
|
|||
|
|
braces[0] + base + " " + output.join(", ") + " " + braces[1]
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|||
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|||
|
|
function isArray(ar) {
|
|||
|
|
return Array.isArray(ar);
|
|||
|
|
}
|
|||
|
|
exports.isArray = isArray;
|
|||
|
|
|
|||
|
|
function isBoolean(arg) {
|
|||
|
|
return typeof arg === "boolean";
|
|||
|
|
}
|
|||
|
|
exports.isBoolean = isBoolean;
|
|||
|
|
|
|||
|
|
function isNull(arg) {
|
|||
|
|
return arg === null;
|
|||
|
|
}
|
|||
|
|
exports.isNull = isNull;
|
|||
|
|
|
|||
|
|
function isNullOrUndefined(arg) {
|
|||
|
|
return arg == null;
|
|||
|
|
}
|
|||
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|||
|
|
|
|||
|
|
function isNumber(arg) {
|
|||
|
|
return typeof arg === "number";
|
|||
|
|
}
|
|||
|
|
exports.isNumber = isNumber;
|
|||
|
|
|
|||
|
|
function isString(arg) {
|
|||
|
|
return typeof arg === "string";
|
|||
|
|
}
|
|||
|
|
exports.isString = isString;
|
|||
|
|
|
|||
|
|
function isSymbol(arg) {
|
|||
|
|
return typeof arg === "symbol";
|
|||
|
|
}
|
|||
|
|
exports.isSymbol = isSymbol;
|
|||
|
|
|
|||
|
|
function isUndefined(arg) {
|
|||
|
|
return arg === void 0;
|
|||
|
|
}
|
|||
|
|
exports.isUndefined = isUndefined;
|
|||
|
|
|
|||
|
|
function isRegExp(re) {
|
|||
|
|
return isObject(re) && objectToString(re) === "[object RegExp]";
|
|||
|
|
}
|
|||
|
|
exports.isRegExp = isRegExp;
|
|||
|
|
|
|||
|
|
function isObject(arg) {
|
|||
|
|
return typeof arg === "object" && arg !== null;
|
|||
|
|
}
|
|||
|
|
exports.isObject = isObject;
|
|||
|
|
|
|||
|
|
function isDate(d) {
|
|||
|
|
return isObject(d) && objectToString(d) === "[object Date]";
|
|||
|
|
}
|
|||
|
|
exports.isDate = isDate;
|
|||
|
|
|
|||
|
|
function isError(e) {
|
|||
|
|
return (
|
|||
|
|
isObject(e) &&
|
|||
|
|
(objectToString(e) === "[object Error]" || e instanceof Error)
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
exports.isError = isError;
|
|||
|
|
|
|||
|
|
function isFunction(arg) {
|
|||
|
|
return typeof arg === "function";
|
|||
|
|
}
|
|||
|
|
exports.isFunction = isFunction;
|
|||
|
|
|
|||
|
|
function isPrimitive(arg) {
|
|||
|
|
return (
|
|||
|
|
arg === null ||
|
|||
|
|
typeof arg === "boolean" ||
|
|||
|
|
typeof arg === "number" ||
|
|||
|
|
typeof arg === "string" ||
|
|||
|
|
typeof arg === "symbol" || // ES6 symbol
|
|||
|
|
typeof arg === "undefined"
|
|||
|
|
);
|
|||
|
|
}
|
|||
|
|
exports.isPrimitive = isPrimitive;
|
|||
|
|
|
|||
|
|
exports.isBuffer = require("./support/isBuffer");
|
|||
|
|
|
|||
|
|
function objectToString(o) {
|
|||
|
|
return Object.prototype.toString.call(o);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function pad(n) {
|
|||
|
|
return n < 10 ? "0" + n.toString(10) : n.toString(10);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var months = [
|
|||
|
|
"Jan",
|
|||
|
|
"Feb",
|
|||
|
|
"Mar",
|
|||
|
|
"Apr",
|
|||
|
|
"May",
|
|||
|
|
"Jun",
|
|||
|
|
"Jul",
|
|||
|
|
"Aug",
|
|||
|
|
"Sep",
|
|||
|
|
"Oct",
|
|||
|
|
"Nov",
|
|||
|
|
"Dec",
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
// 26 Feb 16:19:34
|
|||
|
|
function timestamp() {
|
|||
|
|
var d = new Date();
|
|||
|
|
var time = [
|
|||
|
|
pad(d.getHours()),
|
|||
|
|
pad(d.getMinutes()),
|
|||
|
|
pad(d.getSeconds()),
|
|||
|
|
].join(":");
|
|||
|
|
return [d.getDate(), months[d.getMonth()], time].join(" ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|||
|
|
exports.log = function () {
|
|||
|
|
console.log(
|
|||
|
|
"%s - %s",
|
|||
|
|
timestamp(),
|
|||
|
|
exports.format.apply(exports, arguments)
|
|||
|
|
);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Inherit the prototype methods from one constructor into another.
|
|||
|
|
*
|
|||
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|||
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|||
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|||
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|||
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|||
|
|
*
|
|||
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|||
|
|
* prototype.
|
|||
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|||
|
|
*/
|
|||
|
|
exports.inherits = require("inherits");
|
|||
|
|
|
|||
|
|
exports._extend = function (origin, add) {
|
|||
|
|
// Don't do anything if add isn't an object
|
|||
|
|
if (!add || !isObject(add)) return origin;
|
|||
|
|
|
|||
|
|
var keys = Object.keys(add);
|
|||
|
|
var i = keys.length;
|
|||
|
|
while (i--) {
|
|||
|
|
origin[keys[i]] = add[keys[i]];
|
|||
|
|
}
|
|||
|
|
return origin;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function hasOwnProperty(obj, prop) {
|
|||
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|||
|
|
}
|
|||
|
|
}.call(
|
|||
|
|
this,
|
|||
|
|
require("_process"),
|
|||
|
|
typeof global !== "undefined"
|
|||
|
|
? global
|
|||
|
|
: typeof self !== "undefined"
|
|||
|
|
? self
|
|||
|
|
: typeof window !== "undefined"
|
|||
|
|
? window
|
|||
|
|
: {}
|
|||
|
|
));
|
|||
|
|
},
|
|||
|
|
{ "./support/isBuffer": 27, _process: 24, inherits: 26 },
|
|||
|
|
],
|
|||
|
|
29: [
|
|||
|
|
function (require, module, exports) {
|
|||
|
|
// Returns a wrapper function that returns a wrapped callback
|
|||
|
|
// The wrapper function should do some stuff, and return a
|
|||
|
|
// presumably different callback function.
|
|||
|
|
// This makes sure that own properties are retained, so that
|
|||
|
|
// decorations and such are not lost along the way.
|
|||
|
|
module.exports = wrappy;
|
|||
|
|
function wrappy(fn, cb) {
|
|||
|
|
if (fn && cb) return wrappy(fn)(cb);
|
|||
|
|
|
|||
|
|
if (typeof fn !== "function")
|
|||
|
|
throw new TypeError("need wrapper function");
|
|||
|
|
|
|||
|
|
Object.keys(fn).forEach(function (k) {
|
|||
|
|
wrapper[k] = fn[k];
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return wrapper;
|
|||
|
|
|
|||
|
|
function wrapper() {
|
|||
|
|
var args = new Array(arguments.length);
|
|||
|
|
for (var i = 0; i < args.length; i++) {
|
|||
|
|
args[i] = arguments[i];
|
|||
|
|
}
|
|||
|
|
var ret = fn.apply(this, args);
|
|||
|
|
var cb = args[args.length - 1];
|
|||
|
|
if (typeof ret === "function" && ret !== cb) {
|
|||
|
|
Object.keys(cb).forEach(function (k) {
|
|||
|
|
ret[k] = cb[k];
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
],
|
|||
|
|
},
|
|||
|
|
{},
|
|||
|
|
[7]
|
|||
|
|
)(7);
|
|||
|
|
});
|