Sindbad~EG File Manager
/*
* Underscore.string
* (c) 2010 Esa-Matti Suuronen <esa-matti aet suuronen dot org>
* Underscore.string is freely distributable under the terms of the MIT license.
* Documentation: https://github.com/epeli/underscore.string
* Some code is borrowed from MooTools and Alexandru Marasteanu.
* Version '3.3.6'
* @preserve
*/
(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.s = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
var trim = require('./trim');
var decap = require('./decapitalize');
module.exports = function camelize(str, decapitalize) {
str = trim(str).replace(/[-_\s]+(.)?/g, function(match, c) {
return c ? c.toUpperCase() : '';
});
if (decapitalize === true) {
return decap(str);
} else {
return str;
}
};
},{"./decapitalize":10,"./trim":65}],2:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function capitalize(str, lowercaseRest) {
str = makeString(str);
var remainingChars = !lowercaseRest ? str.slice(1) : str.slice(1).toLowerCase();
return str.charAt(0).toUpperCase() + remainingChars;
};
},{"./helper/makeString":20}],3:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function chars(str) {
return makeString(str).split('');
};
},{"./helper/makeString":20}],4:[function(require,module,exports){
module.exports = function chop(str, step) {
if (str == null) return [];
str = String(str);
step = ~~step;
return step > 0 ? str.match(new RegExp('.{1,' + step + '}', 'g')) : [str];
};
},{}],5:[function(require,module,exports){
var capitalize = require('./capitalize');
var camelize = require('./camelize');
var makeString = require('./helper/makeString');
module.exports = function classify(str) {
str = makeString(str);
return capitalize(camelize(str.replace(/[\W_]/g, ' ')).replace(/\s/g, ''));
};
},{"./camelize":1,"./capitalize":2,"./helper/makeString":20}],6:[function(require,module,exports){
var trim = require('./trim');
module.exports = function clean(str) {
return trim(str).replace(/\s\s+/g, ' ');
};
},{"./trim":65}],7:[function(require,module,exports){
var makeString = require('./helper/makeString');
var from = 'ąàáäâãåæăćčĉęèéëêĝĥìíïîĵłľńňòóöőôõðøśșşšŝťțţŭùúüűûñÿýçżźž',
to = 'aaaaaaaaaccceeeeeghiiiijllnnoooooooossssstttuuuuuunyyczzz';
from += from.toUpperCase();
to += to.toUpperCase();
to = to.split('');
// for tokens requireing multitoken output
from += 'ß';
to.push('ss');
module.exports = function cleanDiacritics(str) {
return makeString(str).replace(/.{1}/g, function(c){
var index = from.indexOf(c);
return index === -1 ? c : to[index];
});
};
},{"./helper/makeString":20}],8:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function(str, substr) {
str = makeString(str);
substr = makeString(substr);
if (str.length === 0 || substr.length === 0) return 0;
return str.split(substr).length - 1;
};
},{"./helper/makeString":20}],9:[function(require,module,exports){
var trim = require('./trim');
module.exports = function dasherize(str) {
return trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
};
},{"./trim":65}],10:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function decapitalize(str) {
str = makeString(str);
return str.charAt(0).toLowerCase() + str.slice(1);
};
},{"./helper/makeString":20}],11:[function(require,module,exports){
var makeString = require('./helper/makeString');
function getIndent(str) {
var matches = str.match(/^[\s\\t]*/gm);
var indent = matches[0].length;
for (var i = 1; i < matches.length; i++) {
indent = Math.min(matches[i].length, indent);
}
return indent;
}
module.exports = function dedent(str, pattern) {
str = makeString(str);
var indent = getIndent(str);
var reg;
if (indent === 0) return str;
if (typeof pattern === 'string') {
reg = new RegExp('^' + pattern, 'gm');
} else {
reg = new RegExp('^[ \\t]{' + indent + '}', 'gm');
}
return str.replace(reg, '');
};
},{"./helper/makeString":20}],12:[function(require,module,exports){
var makeString = require('./helper/makeString');
var toPositive = require('./helper/toPositive');
module.exports = function endsWith(str, ends, position) {
str = makeString(str);
ends = '' + ends;
if (typeof position == 'undefined') {
position = str.length - ends.length;
} else {
position = Math.min(toPositive(position), str.length) - ends.length;
}
return position >= 0 && str.indexOf(ends, position) === position;
};
},{"./helper/makeString":20,"./helper/toPositive":22}],13:[function(require,module,exports){
var makeString = require('./helper/makeString');
var escapeChars = require('./helper/escapeChars');
var regexString = '[';
for(var key in escapeChars) {
regexString += key;
}
regexString += ']';
var regex = new RegExp( regexString, 'g');
module.exports = function escapeHTML(str) {
return makeString(str).replace(regex, function(m) {
return '&' + escapeChars[m] + ';';
});
};
},{"./helper/escapeChars":17,"./helper/makeString":20}],14:[function(require,module,exports){
module.exports = function() {
var result = {};
for (var prop in this) {
if (!this.hasOwnProperty(prop) || prop.match(/^(?:include|contains|reverse|join|map|wrap)$/)) continue;
result[prop] = this[prop];
}
return result;
};
},{}],15:[function(require,module,exports){
var makeString = require('./makeString');
module.exports = function adjacent(str, direction) {
str = makeString(str);
if (str.length === 0) {
return '';
}
return str.slice(0, -1) + String.fromCharCode(str.charCodeAt(str.length - 1) + direction);
};
},{"./makeString":20}],16:[function(require,module,exports){
var escapeRegExp = require('./escapeRegExp');
module.exports = function defaultToWhiteSpace(characters) {
if (characters == null)
return '\\s';
else if (characters.source)
return characters.source;
else
return '[' + escapeRegExp(characters) + ']';
};
},{"./escapeRegExp":18}],17:[function(require,module,exports){
/* We're explicitly defining the list of entities we want to escape.
nbsp is an HTML entity, but we don't want to escape all space characters in a string, hence its omission in this map.
*/
var escapeChars = {
'¢' : 'cent',
'£' : 'pound',
'¥' : 'yen',
'€': 'euro',
'©' :'copy',
'®' : 'reg',
'<' : 'lt',
'>' : 'gt',
'"' : 'quot',
'&' : 'amp',
'\'' : '#39'
};
module.exports = escapeChars;
},{}],18:[function(require,module,exports){
var makeString = require('./makeString');
module.exports = function escapeRegExp(str) {
return makeString(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
},{"./makeString":20}],19:[function(require,module,exports){
/*
We're explicitly defining the list of entities that might see in escape HTML strings
*/
var htmlEntities = {
nbsp: ' ',
cent: '¢',
pound: '£',
yen: '¥',
euro: '€',
copy: '©',
reg: '®',
lt: '<',
gt: '>',
quot: '"',
amp: '&',
apos: '\''
};
module.exports = htmlEntities;
},{}],20:[function(require,module,exports){
/**
* Ensure some object is a coerced to a string
**/
module.exports = function makeString(object) {
if (object == null) return '';
return '' + object;
};
},{}],21:[function(require,module,exports){
module.exports = function strRepeat(str, qty){
if (qty < 1) return '';
var result = '';
while (qty > 0) {
if (qty & 1) result += str;
qty >>= 1, str += str;
}
return result;
};
},{}],22:[function(require,module,exports){
module.exports = function toPositive(number) {
return number < 0 ? 0 : (+number || 0);
};
},{}],23:[function(require,module,exports){
var capitalize = require('./capitalize');
var underscored = require('./underscored');
var trim = require('./trim');
module.exports = function humanize(str) {
return capitalize(trim(underscored(str).replace(/_id$/, '').replace(/_/g, ' ')));
};
},{"./capitalize":2,"./trim":65,"./underscored":67}],24:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function include(str, needle) {
if (needle === '') return true;
return makeString(str).indexOf(needle) !== -1;
};
},{"./helper/makeString":20}],25:[function(require,module,exports){
/*
* Underscore.string
* (c) 2010 Esa-Matti Suuronen <esa-matti aet suuronen dot org>
* Underscore.string is freely distributable under the terms of the MIT license.
* Documentation: https://github.com/epeli/underscore.string
* Some code is borrowed from MooTools and Alexandru Marasteanu.
* Version '3.3.6'
* @preserve
*/
'use strict';
function s(value) {
/* jshint validthis: true */
if (!(this instanceof s)) return new s(value);
this._wrapped = value;
}
s.VERSION = '3.3.6';
s.isBlank = require('./isBlank');
s.stripTags = require('./stripTags');
s.capitalize = require('./capitalize');
s.decapitalize = require('./decapitalize');
s.chop = require('./chop');
s.trim = require('./trim');
s.clean = require('./clean');
s.cleanDiacritics = require('./cleanDiacritics');
s.count = require('./count');
s.chars = require('./chars');
s.swapCase = require('./swapCase');
s.escapeHTML = require('./escapeHTML');
s.unescapeHTML = require('./unescapeHTML');
s.splice = require('./splice');
s.insert = require('./insert');
s.replaceAll = require('./replaceAll');
s.include = require('./include');
s.join = require('./join');
s.lines = require('./lines');
s.dedent = require('./dedent');
s.reverse = require('./reverse');
s.startsWith = require('./startsWith');
s.endsWith = require('./endsWith');
s.pred = require('./pred');
s.succ = require('./succ');
s.titleize = require('./titleize');
s.camelize = require('./camelize');
s.underscored = require('./underscored');
s.dasherize = require('./dasherize');
s.classify = require('./classify');
s.humanize = require('./humanize');
s.ltrim = require('./ltrim');
s.rtrim = require('./rtrim');
s.truncate = require('./truncate');
s.prune = require('./prune');
s.words = require('./words');
s.pad = require('./pad');
s.lpad = require('./lpad');
s.rpad = require('./rpad');
s.lrpad = require('./lrpad');
s.sprintf = require('./sprintf');
s.vsprintf = require('./vsprintf');
s.toNumber = require('./toNumber');
s.numberFormat = require('./numberFormat');
s.strRight = require('./strRight');
s.strRightBack = require('./strRightBack');
s.strLeft = require('./strLeft');
s.strLeftBack = require('./strLeftBack');
s.toSentence = require('./toSentence');
s.toSentenceSerial = require('./toSentenceSerial');
s.slugify = require('./slugify');
s.surround = require('./surround');
s.quote = require('./quote');
s.unquote = require('./unquote');
s.repeat = require('./repeat');
s.naturalCmp = require('./naturalCmp');
s.levenshtein = require('./levenshtein');
s.toBoolean = require('./toBoolean');
s.exports = require('./exports');
s.escapeRegExp = require('./helper/escapeRegExp');
s.wrap = require('./wrap');
s.map = require('./map');
// Aliases
s.strip = s.trim;
s.lstrip = s.ltrim;
s.rstrip = s.rtrim;
s.center = s.lrpad;
s.rjust = s.lpad;
s.ljust = s.rpad;
s.contains = s.include;
s.q = s.quote;
s.toBool = s.toBoolean;
s.camelcase = s.camelize;
s.mapChars = s.map;
// Implement chaining
s.prototype = {
value: function value() {
return this._wrapped;
}
};
function fn2method(key, fn) {
if (typeof fn !== 'function') return;
s.prototype[key] = function() {
var args = [this._wrapped].concat(Array.prototype.slice.call(arguments));
var res = fn.apply(null, args);
// if the result is non-string stop the chain and return the value
return typeof res === 'string' ? new s(res) : res;
};
}
// Copy functions to instance methods for chaining
for (var key in s) fn2method(key, s[key]);
fn2method('tap', function tap(string, fn) {
return fn(string);
});
function prototype2method(methodName) {
fn2method(methodName, function(context) {
var args = Array.prototype.slice.call(arguments, 1);
return String.prototype[methodName].apply(context, args);
});
}
var prototypeMethods = [
'toUpperCase',
'toLowerCase',
'split',
'replace',
'slice',
'substring',
'substr',
'concat'
];
for (var method in prototypeMethods) prototype2method(prototypeMethods[method]);
module.exports = s;
},{"./camelize":1,"./capitalize":2,"./chars":3,"./chop":4,"./classify":5,"./clean":6,"./cleanDiacritics":7,"./count":8,"./dasherize":9,"./decapitalize":10,"./dedent":11,"./endsWith":12,"./escapeHTML":13,"./exports":14,"./helper/escapeRegExp":18,"./humanize":23,"./include":24,"./insert":26,"./isBlank":27,"./join":28,"./levenshtein":29,"./lines":30,"./lpad":31,"./lrpad":32,"./ltrim":33,"./map":34,"./naturalCmp":35,"./numberFormat":38,"./pad":39,"./pred":40,"./prune":41,"./quote":42,"./repeat":43,"./replaceAll":44,"./reverse":45,"./rpad":46,"./rtrim":47,"./slugify":48,"./splice":49,"./sprintf":50,"./startsWith":51,"./strLeft":52,"./strLeftBack":53,"./strRight":54,"./strRightBack":55,"./stripTags":56,"./succ":57,"./surround":58,"./swapCase":59,"./titleize":60,"./toBoolean":61,"./toNumber":62,"./toSentence":63,"./toSentenceSerial":64,"./trim":65,"./truncate":66,"./underscored":67,"./unescapeHTML":68,"./unquote":69,"./vsprintf":70,"./words":71,"./wrap":72}],26:[function(require,module,exports){
var splice = require('./splice');
module.exports = function insert(str, i, substr) {
return splice(str, i, 0, substr);
};
},{"./splice":49}],27:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function isBlank(str) {
return (/^\s*$/).test(makeString(str));
};
},{"./helper/makeString":20}],28:[function(require,module,exports){
var makeString = require('./helper/makeString');
var slice = [].slice;
module.exports = function join() {
var args = slice.call(arguments),
separator = args.shift();
return args.join(makeString(separator));
};
},{"./helper/makeString":20}],29:[function(require,module,exports){
var makeString = require('./helper/makeString');
/**
* Based on the implementation here: https://github.com/hiddentao/fast-levenshtein
*/
module.exports = function levenshtein(str1, str2) {
'use strict';
str1 = makeString(str1);
str2 = makeString(str2);
// Short cut cases
if (str1 === str2) return 0;
if (!str1 || !str2) return Math.max(str1.length, str2.length);
// two rows
var prevRow = new Array(str2.length + 1);
// initialise previous row
for (var i = 0; i < prevRow.length; ++i) {
prevRow[i] = i;
}
// calculate current row distance from previous row
for (i = 0; i < str1.length; ++i) {
var nextCol = i + 1;
for (var j = 0; j < str2.length; ++j) {
var curCol = nextCol;
// substution
nextCol = prevRow[j] + ( (str1.charAt(i) === str2.charAt(j)) ? 0 : 1 );
// insertion
var tmp = curCol + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// deletion
tmp = prevRow[j + 1] + 1;
if (nextCol > tmp) {
nextCol = tmp;
}
// copy current col value into previous (in preparation for next iteration)
prevRow[j] = curCol;
}
// copy last col value into previous (in preparation for next iteration)
prevRow[j] = nextCol;
}
return nextCol;
};
},{"./helper/makeString":20}],30:[function(require,module,exports){
module.exports = function lines(str) {
if (str == null) return [];
return String(str).split(/\r\n?|\n/);
};
},{}],31:[function(require,module,exports){
var pad = require('./pad');
module.exports = function lpad(str, length, padStr) {
return pad(str, length, padStr);
};
},{"./pad":39}],32:[function(require,module,exports){
var pad = require('./pad');
module.exports = function lrpad(str, length, padStr) {
return pad(str, length, padStr, 'both');
};
},{"./pad":39}],33:[function(require,module,exports){
var makeString = require('./helper/makeString');
var defaultToWhiteSpace = require('./helper/defaultToWhiteSpace');
var nativeTrimLeft = String.prototype.trimLeft;
module.exports = function ltrim(str, characters) {
str = makeString(str);
if (!characters && nativeTrimLeft) return nativeTrimLeft.call(str);
characters = defaultToWhiteSpace(characters);
return str.replace(new RegExp('^' + characters + '+'), '');
};
},{"./helper/defaultToWhiteSpace":16,"./helper/makeString":20}],34:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function(str, callback) {
str = makeString(str);
if (str.length === 0 || typeof callback !== 'function') return str;
return str.replace(/./g, callback);
};
},{"./helper/makeString":20}],35:[function(require,module,exports){
module.exports = function naturalCmp(str1, str2) {
if (str1 == str2) return 0;
if (!str1) return -1;
if (!str2) return 1;
var cmpRegex = /(\.\d+|\d+|\D+)/g,
tokens1 = String(str1).match(cmpRegex),
tokens2 = String(str2).match(cmpRegex),
count = Math.min(tokens1.length, tokens2.length);
for (var i = 0; i < count; i++) {
var a = tokens1[i],
b = tokens2[i];
if (a !== b) {
var num1 = +a;
var num2 = +b;
if (num1 === num1 && num2 === num2) {
return num1 > num2 ? 1 : -1;
}
return a < b ? -1 : 1;
}
}
if (tokens1.length != tokens2.length)
return tokens1.length - tokens2.length;
return str1 < str2 ? -1 : 1;
};
},{}],36:[function(require,module,exports){
/* global window, exports, define */
!function() {
'use strict'
var re = {
not_string: /[^s]/,
not_bool: /[^t]/,
not_type: /[^T]/,
not_primitive: /[^v]/,
number: /[diefg]/,
numeric_arg: /[bcdiefguxX]/,
json: /[j]/,
not_json: /[^j]/,
text: /^[^\x25]+/,
modulo: /^\x25{2}/,
placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
key: /^([a-z_][a-z_\d]*)/i,
key_access: /^\.([a-z_][a-z_\d]*)/i,
index_access: /^\[(\d+)\]/,
sign: /^[+-]/
}
function sprintf(key) {
// `arguments` is not an array, but should be fine for this call
return sprintf_format(sprintf_parse(key), arguments)
}
function vsprintf(fmt, argv) {
return sprintf.apply(null, [fmt].concat(argv || []))
}
function sprintf_format(parse_tree, argv) {
var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign
for (i = 0; i < tree_length; i++) {
if (typeof parse_tree[i] === 'string') {
output += parse_tree[i]
}
else if (typeof parse_tree[i] === 'object') {
ph = parse_tree[i] // convenience purposes only
if (ph.keys) { // keyword argument
arg = argv[cursor]
for (k = 0; k < ph.keys.length; k++) {
if (arg == undefined) {
throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))
}
arg = arg[ph.keys[k]]
}
}
else if (ph.param_no) { // positional argument (explicit)
arg = argv[ph.param_no]
}
else { // positional argument (implicit)
arg = argv[cursor++]
}
if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
arg = arg()
}
if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {
throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))
}
if (re.number.test(ph.type)) {
is_positive = arg >= 0
}
switch (ph.type) {
case 'b':
arg = parseInt(arg, 10).toString(2)
break
case 'c':
arg = String.fromCharCode(parseInt(arg, 10))
break
case 'd':
case 'i':
arg = parseInt(arg, 10)
break
case 'j':
arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)
break
case 'e':
arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()
break
case 'f':
arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)
break
case 'g':
arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)
break
case 'o':
arg = (parseInt(arg, 10) >>> 0).toString(8)
break
case 's':
arg = String(arg)
arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
break
case 't':
arg = String(!!arg)
arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
break
case 'T':
arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
break
case 'u':
arg = parseInt(arg, 10) >>> 0
break
case 'v':
arg = arg.valueOf()
arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
break
case 'x':
arg = (parseInt(arg, 10) >>> 0).toString(16)
break
case 'X':
arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()
break
}
if (re.json.test(ph.type)) {
output += arg
}
else {
if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
sign = is_positive ? '+' : '-'
arg = arg.toString().replace(re.sign, '')
}
else {
sign = ''
}
pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '
pad_length = ph.width - (sign + arg).length
pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''
output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)
}
}
}
return output
}
var sprintf_cache = Object.create(null)
function sprintf_parse(fmt) {
if (sprintf_cache[fmt]) {
return sprintf_cache[fmt]
}
var _fmt = fmt, match, parse_tree = [], arg_names = 0
while (_fmt) {
if ((match = re.text.exec(_fmt)) !== null) {
parse_tree.push(match[0])
}
else if ((match = re.modulo.exec(_fmt)) !== null) {
parse_tree.push('%')
}
else if ((match = re.placeholder.exec(_fmt)) !== null) {
if (match[2]) {
arg_names |= 1
var field_list = [], replacement_field = match[2], field_match = []
if ((field_match = re.key.exec(replacement_field)) !== null) {
field_list.push(field_match[1])
while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
if ((field_match = re.key_access.exec(replacement_field)) !== null) {
field_list.push(field_match[1])
}
else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
field_list.push(field_match[1])
}
else {
throw new SyntaxError('[sprintf] failed to parse named argument key')
}
}
}
else {
throw new SyntaxError('[sprintf] failed to parse named argument key')
}
match[2] = field_list
}
else {
arg_names |= 2
}
if (arg_names === 3) {
throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')
}
parse_tree.push(
{
placeholder: match[0],
param_no: match[1],
keys: match[2],
sign: match[3],
pad_char: match[4],
align: match[5],
width: match[6],
precision: match[7],
type: match[8]
}
)
}
else {
throw new SyntaxError('[sprintf] unexpected placeholder')
}
_fmt = _fmt.substring(match[0].length)
}
return sprintf_cache[fmt] = parse_tree
}
/**
* export to either browser or node.js
*/
/* eslint-disable quote-props */
if (typeof exports !== 'undefined') {
exports['sprintf'] = sprintf
exports['vsprintf'] = vsprintf
}
if (typeof window !== 'undefined') {
window['sprintf'] = sprintf
window['vsprintf'] = vsprintf
if (typeof define === 'function' && define['amd']) {
define(function() {
return {
'sprintf': sprintf,
'vsprintf': vsprintf
}
})
}
}
/* eslint-enable quote-props */
}(); // eslint-disable-line
},{}],37:[function(require,module,exports){
(function (global){(function (){
/**
* Module exports.
*/
module.exports = deprecate;
/**
* Mark that a method should not be used.
* Returns a modified function which warns once by default.
*
* If `localStorage.noDeprecation = true` is set, then it is a no-op.
*
* If `localStorage.throwDeprecation = true` is set, then deprecated functions
* will throw an Error when invoked.
*
* If `localStorage.traceDeprecation = true` is set, then deprecated functions
* will invoke `console.trace()` instead of `console.error()`.
*
* @param {Function} fn - the function to deprecate
* @param {String} msg - the string to print to the console when `fn` is invoked
* @returns {Function} a new "deprecated" version of `fn`
* @api public
*/
function deprecate (fn, msg) {
if (config('noDeprecation')) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (config('throwDeprecation')) {
throw new Error(msg);
} else if (config('traceDeprecation')) {
console.trace(msg);
} else {
console.warn(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
}
/**
* Checks `localStorage` for boolean values for the given `name`.
*
* @param {String} name
* @returns {Boolean}
* @api private
*/
function config (name) {
// accessing global.localStorage can trigger a DOMException in sandboxed iframes
try {
if (!global.localStorage) return false;
} catch (_) {
return false;
}
var val = global.localStorage[name];
if (null == val) return false;
return String(val).toLowerCase() === 'true';
}
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],38:[function(require,module,exports){
module.exports = function numberFormat(number, dec, dsep, tsep) {
if (isNaN(number) || number == null) return '';
number = number.toFixed(~~dec);
tsep = typeof tsep == 'string' ? tsep : ',';
var parts = number.split('.'),
fnums = parts[0],
decimals = parts[1] ? (dsep || '.') + parts[1] : '';
return fnums.replace(/(\d)(?=(?:\d{3})+$)/g, '$1' + tsep) + decimals;
};
},{}],39:[function(require,module,exports){
var makeString = require('./helper/makeString');
var strRepeat = require('./helper/strRepeat');
module.exports = function pad(str, length, padStr, type) {
str = makeString(str);
length = ~~length;
var padlen = 0;
if (!padStr)
padStr = ' ';
else if (padStr.length > 1)
padStr = padStr.charAt(0);
switch (type) {
case 'right':
padlen = length - str.length;
return str + strRepeat(padStr, padlen);
case 'both':
padlen = length - str.length;
return strRepeat(padStr, Math.ceil(padlen / 2)) + str + strRepeat(padStr, Math.floor(padlen / 2));
default: // 'left'
padlen = length - str.length;
return strRepeat(padStr, padlen) + str;
}
};
},{"./helper/makeString":20,"./helper/strRepeat":21}],40:[function(require,module,exports){
var adjacent = require('./helper/adjacent');
module.exports = function succ(str) {
return adjacent(str, -1);
};
},{"./helper/adjacent":15}],41:[function(require,module,exports){
/**
* _s.prune: a more elegant version of truncate
* prune extra chars, never leaving a half-chopped word.
* @author github.com/rwz
*/
var makeString = require('./helper/makeString');
var rtrim = require('./rtrim');
module.exports = function prune(str, length, pruneStr) {
str = makeString(str);
length = ~~length;
pruneStr = pruneStr != null ? String(pruneStr) : '...';
if (str.length <= length) return str;
var tmpl = function(c) {
return c.toUpperCase() !== c.toLowerCase() ? 'A' : ' ';
},
template = str.slice(0, length + 1).replace(/.(?=\W*\w*$)/g, tmpl); // 'Hello, world' -> 'HellAA AAAAA'
if (template.slice(template.length - 2).match(/\w\w/))
template = template.replace(/\s*\S+$/, '');
else
template = rtrim(template.slice(0, template.length - 1));
return (template + pruneStr).length > str.length ? str : str.slice(0, template.length) + pruneStr;
};
},{"./helper/makeString":20,"./rtrim":47}],42:[function(require,module,exports){
var surround = require('./surround');
module.exports = function quote(str, quoteChar) {
return surround(str, quoteChar || '"');
};
},{"./surround":58}],43:[function(require,module,exports){
var makeString = require('./helper/makeString');
var strRepeat = require('./helper/strRepeat');
module.exports = function repeat(str, qty, separator) {
str = makeString(str);
qty = ~~qty;
// using faster implementation if separator is not needed;
if (separator == null) return strRepeat(str, qty);
// this one is about 300x slower in Google Chrome
/*eslint no-empty: 0*/
for (var repeat = []; qty > 0; repeat[--qty] = str) {}
return repeat.join(separator);
};
},{"./helper/makeString":20,"./helper/strRepeat":21}],44:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function replaceAll(str, find, replace, ignorecase) {
var flags = (ignorecase === true)?'gi':'g';
var reg = new RegExp(find, flags);
return makeString(str).replace(reg, replace);
};
},{"./helper/makeString":20}],45:[function(require,module,exports){
var chars = require('./chars');
module.exports = function reverse(str) {
return chars(str).reverse().join('');
};
},{"./chars":3}],46:[function(require,module,exports){
var pad = require('./pad');
module.exports = function rpad(str, length, padStr) {
return pad(str, length, padStr, 'right');
};
},{"./pad":39}],47:[function(require,module,exports){
var makeString = require('./helper/makeString');
var defaultToWhiteSpace = require('./helper/defaultToWhiteSpace');
var nativeTrimRight = String.prototype.trimRight;
module.exports = function rtrim(str, characters) {
str = makeString(str);
if (!characters && nativeTrimRight) return nativeTrimRight.call(str);
characters = defaultToWhiteSpace(characters);
return str.replace(new RegExp(characters + '+$'), '');
};
},{"./helper/defaultToWhiteSpace":16,"./helper/makeString":20}],48:[function(require,module,exports){
var trim = require('./trim');
var dasherize = require('./dasherize');
var cleanDiacritics = require('./cleanDiacritics');
module.exports = function slugify(str) {
return trim(dasherize(cleanDiacritics(str).replace(/[^\w\s-]/g, '-').toLowerCase()), '-');
};
},{"./cleanDiacritics":7,"./dasherize":9,"./trim":65}],49:[function(require,module,exports){
var chars = require('./chars');
module.exports = function splice(str, i, howmany, substr) {
var arr = chars(str);
arr.splice(~~i, ~~howmany, substr);
return arr.join('');
};
},{"./chars":3}],50:[function(require,module,exports){
var deprecate = require('util-deprecate');
module.exports = deprecate(require('sprintf-js').sprintf,
'sprintf() will be removed in the next major release, use the sprintf-js package instead.');
},{"sprintf-js":36,"util-deprecate":37}],51:[function(require,module,exports){
var makeString = require('./helper/makeString');
var toPositive = require('./helper/toPositive');
module.exports = function startsWith(str, starts, position) {
str = makeString(str);
starts = '' + starts;
position = position == null ? 0 : Math.min(toPositive(position), str.length);
return str.lastIndexOf(starts, position) === position;
};
},{"./helper/makeString":20,"./helper/toPositive":22}],52:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function strLeft(str, sep) {
str = makeString(str);
sep = makeString(sep);
var pos = !sep ? -1 : str.indexOf(sep);
return~ pos ? str.slice(0, pos) : str;
};
},{"./helper/makeString":20}],53:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function strLeftBack(str, sep) {
str = makeString(str);
sep = makeString(sep);
var pos = str.lastIndexOf(sep);
return~ pos ? str.slice(0, pos) : str;
};
},{"./helper/makeString":20}],54:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function strRight(str, sep) {
str = makeString(str);
sep = makeString(sep);
var pos = !sep ? -1 : str.indexOf(sep);
return~ pos ? str.slice(pos + sep.length, str.length) : str;
};
},{"./helper/makeString":20}],55:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function strRightBack(str, sep) {
str = makeString(str);
sep = makeString(sep);
var pos = !sep ? -1 : str.lastIndexOf(sep);
return~ pos ? str.slice(pos + sep.length, str.length) : str;
};
},{"./helper/makeString":20}],56:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function stripTags(str) {
return makeString(str).replace(/<\/?[^>]+>/g, '');
};
},{"./helper/makeString":20}],57:[function(require,module,exports){
var adjacent = require('./helper/adjacent');
module.exports = function succ(str) {
return adjacent(str, 1);
};
},{"./helper/adjacent":15}],58:[function(require,module,exports){
module.exports = function surround(str, wrapper) {
return [wrapper, str, wrapper].join('');
};
},{}],59:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function swapCase(str) {
return makeString(str).replace(/\S/g, function(c) {
return c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase();
});
};
},{"./helper/makeString":20}],60:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function titleize(str) {
return makeString(str).toLowerCase().replace(/(?:^|\s|-)\S/g, function(c) {
return c.toUpperCase();
});
};
},{"./helper/makeString":20}],61:[function(require,module,exports){
var trim = require('./trim');
function boolMatch(s, matchers) {
var i, matcher, down = s.toLowerCase();
matchers = [].concat(matchers);
for (i = 0; i < matchers.length; i += 1) {
matcher = matchers[i];
if (!matcher) continue;
if (matcher.test && matcher.test(s)) return true;
if (matcher.toLowerCase() === down) return true;
}
}
module.exports = function toBoolean(str, trueValues, falseValues) {
if (typeof str === 'number') str = '' + str;
if (typeof str !== 'string') return !!str;
str = trim(str);
if (boolMatch(str, trueValues || ['true', '1'])) return true;
if (boolMatch(str, falseValues || ['false', '0'])) return false;
};
},{"./trim":65}],62:[function(require,module,exports){
module.exports = function toNumber(num, precision) {
if (num == null) return 0;
var factor = Math.pow(10, isFinite(precision) ? precision : 0);
return Math.round(num * factor) / factor;
};
},{}],63:[function(require,module,exports){
var rtrim = require('./rtrim');
module.exports = function toSentence(array, separator, lastSeparator, serial) {
separator = separator || ', ';
lastSeparator = lastSeparator || ' and ';
var a = array.slice(),
lastMember = a.pop();
if (array.length > 2 && serial) lastSeparator = rtrim(separator) + lastSeparator;
return a.length ? a.join(separator) + lastSeparator + lastMember : lastMember;
};
},{"./rtrim":47}],64:[function(require,module,exports){
var toSentence = require('./toSentence');
module.exports = function toSentenceSerial(array, sep, lastSep) {
return toSentence(array, sep, lastSep, true);
};
},{"./toSentence":63}],65:[function(require,module,exports){
var makeString = require('./helper/makeString');
var defaultToWhiteSpace = require('./helper/defaultToWhiteSpace');
var nativeTrim = String.prototype.trim;
module.exports = function trim(str, characters) {
str = makeString(str);
if (!characters && nativeTrim) return nativeTrim.call(str);
characters = defaultToWhiteSpace(characters);
return str.replace(new RegExp('^' + characters + '+|' + characters + '+$', 'g'), '');
};
},{"./helper/defaultToWhiteSpace":16,"./helper/makeString":20}],66:[function(require,module,exports){
var makeString = require('./helper/makeString');
module.exports = function truncate(str, length, truncateStr) {
str = makeString(str);
truncateStr = truncateStr || '...';
length = ~~length;
return str.length > length ? str.slice(0, length) + truncateStr : str;
};
},{"./helper/makeString":20}],67:[function(require,module,exports){
var trim = require('./trim');
module.exports = function underscored(str) {
return trim(str).replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
};
},{"./trim":65}],68:[function(require,module,exports){
var makeString = require('./helper/makeString');
var htmlEntities = require('./helper/htmlEntities');
module.exports = function unescapeHTML(str) {
return makeString(str).replace(/\&([^;]{1,10});/g, function(entity, entityCode) {
var match;
if (entityCode in htmlEntities) {
return htmlEntities[entityCode];
/*eslint no-cond-assign: 0*/
} else if (match = entityCode.match(/^#x([\da-fA-F]+)$/)) {
return String.fromCharCode(parseInt(match[1], 16));
/*eslint no-cond-assign: 0*/
} else if (match = entityCode.match(/^#(\d+)$/)) {
return String.fromCharCode(~~match[1]);
} else {
return entity;
}
});
};
},{"./helper/htmlEntities":19,"./helper/makeString":20}],69:[function(require,module,exports){
module.exports = function unquote(str, quoteChar) {
quoteChar = quoteChar || '"';
if (str[0] === quoteChar && str[str.length - 1] === quoteChar)
return str.slice(1, str.length - 1);
else return str;
};
},{}],70:[function(require,module,exports){
var deprecate = require('util-deprecate');
module.exports = deprecate(require('sprintf-js').vsprintf,
'vsprintf() will be removed in the next major release, use the sprintf-js package instead.');
},{"sprintf-js":36,"util-deprecate":37}],71:[function(require,module,exports){
var isBlank = require('./isBlank');
var trim = require('./trim');
module.exports = function words(str, delimiter) {
if (isBlank(str)) return [];
return trim(str, delimiter).split(delimiter || /\s+/);
};
},{"./isBlank":27,"./trim":65}],72:[function(require,module,exports){
// Wrap
// wraps a string by a certain width
var makeString = require('./helper/makeString');
module.exports = function wrap(str, options){
str = makeString(str);
options = options || {};
var width = options.width || 75;
var seperator = options.seperator || '\n';
var cut = options.cut || false;
var preserveSpaces = options.preserveSpaces || false;
var trailingSpaces = options.trailingSpaces || false;
var result;
if(width <= 0){
return str;
}
else if(!cut){
var words = str.split(' ');
var current_column = 0;
result = '';
while(words.length > 0){
// if adding a space and the next word would cause this line to be longer than width...
if(1 + words[0].length + current_column > width){
//start a new line if this line is not already empty
if(current_column > 0){
// add a space at the end of the line is preserveSpaces is true
if (preserveSpaces){
result += ' ';
current_column++;
}
// fill the rest of the line with spaces if trailingSpaces option is true
else if(trailingSpaces){
while(current_column < width){
result += ' ';
current_column++;
}
}
//start new line
result += seperator;
current_column = 0;
}
}
// if not at the begining of the line, add a space in front of the word
if(current_column > 0){
result += ' ';
current_column++;
}
// tack on the next word, update current column, a pop words array
result += words[0];
current_column += words[0].length;
words.shift();
}
// fill the rest of the line with spaces if trailingSpaces option is true
if(trailingSpaces){
while(current_column < width){
result += ' ';
current_column++;
}
}
return result;
}
else {
var index = 0;
result = '';
// walk through each character and add seperators where appropriate
while(index < str.length){
if(index % width == 0 && index > 0){
result += seperator;
}
result += str.charAt(index);
index++;
}
// fill the rest of the line with spaces if trailingSpaces option is true
if(trailingSpaces){
while(index % width > 0){
result += ' ';
index++;
}
}
return result;
}
};
},{"./helper/makeString":20}]},{},[25])(25)
});
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists