eruda2
Version:
Console for Mobile Browsers
1,975 lines (1,576 loc) • 234 kB
JavaScript
// Built by eustia.
/* eslint-disable */
var _ = {};
/* ------------------------------ last ------------------------------ */
export var last = _.last = (function (exports) {
/* Get the last element of array.
*
* |Name |Desc |
* |------|-------------------------|
* |arr |The array to query |
* |return|The last element of array|
*/
/* example
* last([1, 2]); // -> 2
*/
/* typescript
* export declare function last(arr: any[]): any;
*/
exports = function(arr) {
var len = arr ? arr.length : 0;
if (len) return arr[len - 1];
};
return exports;
})({});
/* ------------------------------ isUndef ------------------------------ */
export var isUndef = _.isUndef = (function (exports) {
/* Check if value is undefined.
*
* |Name |Desc |
* |------|--------------------------|
* |val |Value to check |
* |return|True if value is undefined|
*/
/* example
* isUndef(void 0); // -> true
* isUndef(null); // -> false
*/
/* typescript
* export declare function isUndef(val: any): boolean;
*/
exports = function(val) {
return val === void 0;
};
return exports;
})({});
/* ------------------------------ types ------------------------------ */
export var types = _.types = (function (exports) {
/* Used for typescript definitions only.
*/
/* typescript
* export declare namespace types {
* interface Collection<T> {}
* interface List<T> extends Collection<T> {
* [index: number]: T;
* length: number;
* }
* interface ListIterator<T, TResult> {
* (value: T, index: number, list: List<T>): TResult;
* }
* interface Dictionary<T> extends Collection<T> {
* [index: string]: T;
* }
* interface ObjectIterator<T, TResult> {
* (element: T, key: string, list: Dictionary<T>): TResult;
* }
* interface MemoIterator<T, TResult> {
* (prev: TResult, curr: T, index: number, list: List<T>): TResult;
* }
* interface MemoObjectIterator<T, TResult> {
* (prev: TResult, curr: T, key: string, list: Dictionary<T>): TResult;
* }
* type Fn<T> = (...args: any[]) => T;
* type AnyFn = Fn<any>;
* type PlainObj<T> = { [name: string]: T };
* }
* export declare const types: {};
*/
exports = {};
return exports;
})({});
/* ------------------------------ isObj ------------------------------ */
export var isObj = _.isObj = (function (exports) {
/* Check if value is the language type of Object.
*
* |Name |Desc |
* |------|--------------------------|
* |val |Value to check |
* |return|True if value is an object|
*
* [Language Spec](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types)
*/
/* example
* isObj({}); // -> true
* isObj([]); // -> true
*/
/* typescript
* export declare function isObj(val: any): boolean;
*/
exports = function(val) {
var type = typeof val;
return !!val && (type === 'function' || type === 'object');
};
return exports;
})({});
/* ------------------------------ has ------------------------------ */
export var has = _.has = (function (exports) {
/* Checks if key is a direct property.
*
* |Name |Desc |
* |------|--------------------------------|
* |obj |Object to query |
* |key |Path to check |
* |return|True if key is a direct property|
*/
/* example
* has({ one: 1 }, 'one'); // -> true
*/
/* typescript
* export declare function has(obj: {}, key: string): boolean;
*/
var hasOwnProp = Object.prototype.hasOwnProperty;
exports = function(obj, key) {
return hasOwnProp.call(obj, key);
};
return exports;
})({});
/* ------------------------------ slice ------------------------------ */
export var slice = _.slice = (function (exports) {
/* Create slice of source array or array-like object.
*
* |Name |Desc |
* |----------------|--------------------------|
* |array |Array to slice |
* |start=0 |Start position |
* |end=array.length|End position, not included|
*/
/* example
* slice([1, 2, 3, 4], 1, 2); // -> [2]
*/
/* typescript
* export declare function slice(
* array: any[],
* start?: number,
* end?: number
* ): any[];
*/
exports = function(arr, start, end) {
var len = arr.length;
if (start == null) {
start = 0;
} else if (start < 0) {
start = Math.max(len + start, 0);
} else {
start = Math.min(start, len);
}
if (end == null) {
end = len;
} else if (end < 0) {
end = Math.max(len + end, 0);
} else {
end = Math.min(end, len);
}
var ret = [];
while (start < end) {
ret.push(arr[start++]);
}
return ret;
};
return exports;
})({});
/* ------------------------------ keys ------------------------------ */
export var keys = _.keys = (function (exports) {
/* Create an array of the own enumerable property names of object.
*
* |Name |Desc |
* |------|-----------------------|
* |obj |Object to query |
* |return|Array of property names|
*/
/* example
* keys({ a: 1 }); // -> ['a']
*/
/* typescript
* export declare function keys(obj: any): string[];
*/
/* dependencies
* has
*/
if (Object.keys && !false) {
exports = Object.keys;
} else {
exports = function(obj) {
var ret = [];
for (var key in obj) {
if (has(obj, key)) ret.push(key);
}
return ret;
};
}
return exports;
})({});
/* ------------------------------ freeze ------------------------------ */
export var freeze = _.freeze = (function (exports) {
/* Shortcut for Object.freeze.
*
* Use Object.defineProperties if Object.freeze is not supported.
*
* |Name |Desc |
* |------|----------------|
* |obj |Object to freeze|
* |return|Object passed in|
*/
/* example
* const a = { b: 1 };
* freeze(a);
* a.b = 2;
* console.log(a); // -> {b: 1}
*/
/* typescript
* export declare function freeze<T>(obj: T): T;
*/
/* dependencies
* keys
*/
exports = function(obj) {
if (Object.freeze) return Object.freeze(obj);
keys(obj).forEach(function(prop) {
if (!Object.getOwnPropertyDescriptor(obj, prop).configurable) return;
Object.defineProperty(obj, prop, {
writable: false,
configurable: false
});
});
return obj;
};
return exports;
})({});
/* ------------------------------ reverse ------------------------------ */
export var reverse = _.reverse = (function (exports) {
/* Reverse array without mutating it.
*
* |Name |Desc |
* |------|---------------|
* |arr |Array to modify|
* |return|Reversed array |
*/
/* example
* reverse([1, 2, 3]); // -> [3, 2, 1]
*/
/* typescript
* export declare function reverse(arr: any[]): any[];
*/
exports = function(arr) {
var len = arr.length;
var ret = Array(len);
len--;
for (var i = 0; i <= len; i++) {
ret[len - i] = arr[i];
}
return ret;
};
return exports;
})({});
/* ------------------------------ isBrowser ------------------------------ */
export var isBrowser = _.isBrowser = (function (exports) {
/* Check if running in a browser.
*/
/* example
* console.log(isBrowser); // -> true if running in a browser
*/
/* typescript
* export declare const isBrowser: boolean;
*/
exports =
typeof window === 'object' &&
typeof document === 'object' &&
document.nodeType === 9;
return exports;
})({});
/* ------------------------------ noop ------------------------------ */
export var noop = _.noop = (function (exports) {
/* A no-operation function.
*/
/* example
* noop(); // Does nothing
*/
/* typescript
* export declare function noop(): void;
*/
exports = function() {};
return exports;
})({});
/* ------------------------------ before ------------------------------ */
export var before = _.before = (function (exports) {
/* Create a function that invokes less than n times.
*
* |Name |Desc |
* |------|------------------------------------------------|
* |n |Number of calls at which fn is no longer invoked|
* |fn |Function to restrict |
* |return|New restricted function |
*
* Subsequent calls to the created function return the result of the last fn invocation.
*/
/* example
* const fn = before(5, function() {});
* fn(); // Allow function to be call 4 times at last.
*/
/* typescript
* export declare function before<T extends types.AnyFn>(n: number, fn: T): T;
*/
/* dependencies
* types
*/
exports = function(n, fn) {
var memo;
return function() {
if (--n > 0) memo = fn.apply(this, arguments);
if (n <= 1) fn = null;
return memo;
};
};
return exports;
})({});
/* ------------------------------ splitCase ------------------------------ */
export var splitCase = _.splitCase = (function (exports) {
/* Split different string case to an array.
*
* |Name |Desc |
* |------|---------------|
* |str |String to split|
* |return|Result array |
*/
/* example
* splitCase('foo-bar'); // -> ['foo', 'bar']
* splitCase('foo bar'); // -> ['foo', 'bar']
* splitCase('foo_bar'); // -> ['foo', 'bar']
* splitCase('foo.bar'); // -> ['foo', 'bar']
* splitCase('fooBar'); // -> ['foo', 'bar']
* splitCase('foo-Bar'); // -> ['foo', 'bar']
*/
/* typescript
* export declare function splitCase(str: string): string[];
*/
var regUpperCase = /([A-Z])/g;
var regSeparator = /[_.\- ]+/g;
var regTrim = /(^-)|(-$)/g;
exports = function(str) {
str = str
.replace(regUpperCase, '-$1')
.toLowerCase()
.replace(regSeparator, '-')
.replace(regTrim, '');
return str.split('-');
};
return exports;
})({});
/* ------------------------------ camelCase ------------------------------ */
export var camelCase = _.camelCase = (function (exports) {
/* Convert string to "camelCase".
*
* |Name |Desc |
* |------|------------------|
* |str |String to convert |
* |return|Camel cased string|
*/
/* example
* camelCase('foo-bar'); // -> fooBar
* camelCase('foo bar'); // -> fooBar
* camelCase('foo_bar'); // -> fooBar
* camelCase('foo.bar'); // -> fooBar
*/
/* typescript
* export declare function camelCase(str: string): string;
*/
/* dependencies
* splitCase
*/
exports = function(str) {
var arr = splitCase(str);
var ret = arr[0];
arr.shift();
arr.forEach(capitalize, arr);
ret += arr.join('');
return ret;
};
function capitalize(val, idx) {
this[idx] = val.replace(/\w/, function(match) {
return match.toUpperCase();
});
}
return exports;
})({});
/* ------------------------------ kebabCase ------------------------------ */
export var kebabCase = _.kebabCase = (function (exports) {
/* Convert string to "kebabCase".
*
* |Name |Desc |
* |------|------------------|
* |str |String to convert |
* |return|Kebab cased string|
*/
/* example
* kebabCase('fooBar'); // -> foo-bar
* kebabCase('foo bar'); // -> foo-bar
* kebabCase('foo_bar'); // -> foo-bar
* kebabCase('foo.bar'); // -> foo-bar
*/
/* typescript
* export declare function kebabCase(str: string): string;
*/
/* dependencies
* splitCase
*/
exports = function(str) {
return splitCase(str).join('-');
};
return exports;
})({});
/* ------------------------------ clamp ------------------------------ */
export var clamp = _.clamp = (function (exports) {
/* Clamp number within the inclusive lower and upper bounds.
*
* |Name |Desc |
* |------|---------------|
* |n |Number to clamp|
* |lower |Lower bound |
* |upper |Upper bound |
* |return|Clamped number |
*/
/* example
* clamp(-10, -5, 5); // -> -5
* clamp(10, -5, 5); // -> 5
* clamp(2, -5, 5); // -> 2
* clamp(10, 5); // -> 5
* clamp(2, 5); // -> 2
*/
/* typescript
* export declare function clamp(n: number, lower: number, upper: number): number;
* export declare function clamp(n: number, upper: number): number;
*/
/* dependencies
* isUndef
*/
exports = function(n, lower, upper) {
if (isUndef(upper)) {
upper = lower;
lower = undefined;
}
if (!isUndef(lower) && n < lower) return lower;
if (n > upper) return upper;
return n;
};
return exports;
})({});
/* ------------------------------ idxOf ------------------------------ */
export var idxOf = _.idxOf = (function (exports) {
/* Get the index at which the first occurrence of value.
*
* |Name |Desc |
* |---------|--------------------|
* |arr |Array to search |
* |val |Value to search for |
* |fromIdx=0|Index to search from|
* |return |Value index |
*/
/* example
* idxOf([1, 2, 1, 2], 2, 2); // -> 3
*/
/* typescript
* export declare function idxOf(arr: any[], val: any, fromIdx?: number): number;
*/
exports = function(arr, val, fromIdx) {
return Array.prototype.indexOf.call(arr, val, fromIdx);
};
return exports;
})({});
/* ------------------------------ create ------------------------------ */
export var create = _.create = (function (exports) {
/* Create new object using given object as prototype.
*
* |Name |Desc |
* |------|-----------------------|
* |proto |Prototype of new object|
* |return|Created object |
*/
/* example
* const obj = create({ a: 1 });
* console.log(obj.a); // -> 1
*/
/* typescript
* export declare function create(proto?: object): any;
*/
/* dependencies
* isObj
*/
exports = function(proto) {
if (!isObj(proto)) return {};
if (objCreate && !false) return objCreate(proto);
function noop() {}
noop.prototype = proto;
return new noop();
};
var objCreate = Object.create;
return exports;
})({});
/* ------------------------------ inherits ------------------------------ */
export var inherits = _.inherits = (function (exports) {
/* Inherit the prototype methods from one constructor into another.
*
* |Name |Desc |
* |----------|-----------|
* |Class |Child Class|
* |SuperClass|Super Class|
*/
/* example
* function People(name) {
* this._name = name;
* }
* People.prototype = {
* getName: function() {
* return this._name;
* }
* };
* function Student(name) {
* this._name = name;
* }
* inherits(Student, People);
* const s = new Student('RedHood');
* s.getName(); // -> 'RedHood'
*/
/* typescript
* export declare function inherits(
* Class: types.AnyFn,
* SuperClass: types.AnyFn
* ): void;
*/
/* dependencies
* create types
*/
exports = function(Class, SuperClass) {
Class.prototype = create(SuperClass.prototype);
};
return exports;
})({});
/* ------------------------------ toStr ------------------------------ */
export var toStr = _.toStr = (function (exports) {
/* Convert value to a string.
*
* |Name |Desc |
* |------|----------------|
* |val |Value to convert|
* |return|Result string |
*/
/* example
* toStr(null); // -> ''
* toStr(1); // -> '1'
* toStr(false); // -> 'false'
* toStr([1, 2, 3]); // -> '1,2,3'
*/
/* typescript
* export declare function toStr(val: any): string;
*/
exports = function(val) {
return val == null ? '' : val.toString();
};
return exports;
})({});
/* ------------------------------ debounce ------------------------------ */
export var debounce = _.debounce = (function (exports) {
/* Return a new debounced version of the passed function.
*
* |Name |Desc |
* |------|-------------------------------|
* |fn |Function to debounce |
* |wait |Number of milliseconds to delay|
* |return|New debounced function |
*/
/* example
* const calLayout = debounce(function() {}, 300);
* // $(window).resize(calLayout);
*/
/* typescript
* export declare function debounce<T extends types.AnyFn>(fn: T, wait: number): T;
*/
/* dependencies
* types
*/
exports = function(fn, wait, immediate) {
var timeout;
return function() {
var ctx = this;
var args = arguments;
var throttler = function() {
timeout = null;
fn.apply(ctx, args);
};
if (!immediate) clearTimeout(timeout);
if (!immediate || !timeout) timeout = setTimeout(throttler, wait);
};
};
return exports;
})({});
/* ------------------------------ detectOs ------------------------------ */
export var detectOs = _.detectOs = (function (exports) {
/* Detect operating system using ua.
*
* |Name |Desc |
* |----------------------|---------------------|
* |ua=navigator.userAgent|Browser userAgent |
* |return |Operating system name|
*
* Supported os: windows, os x, linux, ios, android, windows phone
*/
/* example
* if (detectOs() === 'ios') {
* // Do something about ios...
* }
*/
/* typescript
* export declare function detectOs(ua?: string): string;
*/
/* dependencies
* isBrowser
*/
exports = function(ua) {
ua = ua || (isBrowser ? navigator.userAgent : '');
ua = ua.toLowerCase();
if (detect('windows phone')) return 'windows phone';
if (detect('win')) return 'windows';
if (detect('android')) return 'android';
if (detect('ipad') || detect('iphone') || detect('ipod')) return 'ios';
if (detect('mac')) return 'os x';
if (detect('linux')) return 'linux';
function detect(keyword) {
return ua.indexOf(keyword) > -1;
}
return 'unknown';
};
return exports;
})({});
/* ------------------------------ restArgs ------------------------------ */
export var restArgs = _.restArgs = (function (exports) {
/* This accumulates the arguments passed into an array, after a given index.
*
* |Name |Desc |
* |----------|---------------------------------------|
* |function |Function that needs rest parameters |
* |startIndex|The start index to accumulates |
* |return |Generated function with rest parameters|
*/
/* example
* const paramArr = restArgs(function(rest) {
* return rest;
* });
* paramArr(1, 2, 3, 4); // -> [1, 2, 3, 4]
*/
/* typescript
* export declare function restArgs(
* fn: types.AnyFn,
* startIndex?: number
* ): types.AnyFn;
*/
/* dependencies
* types
*/
exports = function(fn, startIdx) {
startIdx = startIdx == null ? fn.length - 1 : +startIdx;
return function() {
var len = Math.max(arguments.length - startIdx, 0);
var rest = new Array(len);
var i;
for (i = 0; i < len; i++) {
rest[i] = arguments[i + startIdx];
} // Call runs faster than apply.
switch (startIdx) {
case 0:
return fn.call(this, rest);
case 1:
return fn.call(this, arguments[0], rest);
case 2:
return fn.call(this, arguments[0], arguments[1], rest);
}
var args = new Array(startIdx + 1);
for (i = 0; i < startIdx; i++) {
args[i] = arguments[i];
}
args[startIdx] = rest;
return fn.apply(this, args);
};
};
return exports;
})({});
/* ------------------------------ mergeArr ------------------------------ */
export var mergeArr = _.mergeArr = (function (exports) {
/* Merge the contents of arrays together into the first array.
*
* |Name |Desc |
* |------|------------------------------------|
* |first |Array to merge |
* |arrays|Arrays to merge into the first array|
* |return|First array |
*/
/* example
* const a = [1, 2];
* mergeArr(a, [3, 4], [5, 6]);
* console.log(a); // -> [1, 2, 3, 4, 5, 6]
*/
/* typescript
* export declare function mergeArr<T, U>(
* first: ArrayLike<T>,
* ...arrays: ArrayLike<U>[]
* ): ArrayLike<T | U>;
*/
/* dependencies
* restArgs
*/
exports = restArgs(function(first, arrays) {
var end = first.length;
for (var i = 0, len = arrays.length; i < len; i++) {
var arr = arrays[i];
for (var j = 0, _len = arr.length; j < _len; j++) {
first[end++] = arr[j];
}
}
first.length = end;
return first;
});
return exports;
})({});
/* ------------------------------ optimizeCb ------------------------------ */
export var optimizeCb = _.optimizeCb = (function (exports) {
/* Used for function context binding.
*/
/* typescript
* export declare function optimizeCb(
* fn: types.AnyFn,
* ctx: any,
* argCount?: number
* ): types.AnyFn;
*/
/* dependencies
* isUndef types
*/
exports = function(fn, ctx, argCount) {
if (isUndef(ctx)) return fn;
switch (argCount == null ? 3 : argCount) {
case 1:
return function(val) {
return fn.call(ctx, val);
};
case 3:
return function(val, idx, collection) {
return fn.call(ctx, val, idx, collection);
};
case 4:
return function(accumulator, val, idx, collection) {
return fn.call(ctx, accumulator, val, idx, collection);
};
}
return function() {
return fn.apply(ctx, arguments);
};
};
return exports;
})({});
/* ------------------------------ endWith ------------------------------ */
export var endWith = _.endWith = (function (exports) {
/* Check if string ends with the given target string.
*
* |Name |Desc |
* |------|-------------------------------|
* |str |The string to search |
* |suffix|String suffix |
* |return|True if string ends with target|
*/
/* example
* endWith('ab', 'b'); // -> true
*/
/* typescript
* export declare function endWith(str: string, suffix: string): boolean;
*/
exports = function(str, suffix) {
var idx = str.length - suffix.length;
return idx >= 0 && str.indexOf(suffix, idx) === idx;
};
return exports;
})({});
/* ------------------------------ escape ------------------------------ */
export var escape = _.escape = (function (exports) {
/* Escapes a string for insertion into HTML, replacing &, <, >, ", `, and ' characters.
*
* |Name |Desc |
* |------|----------------|
* |str |String to escape|
* |return|Escaped string |
*/
/* example
* escape('You & Me'); // -> 'You & Me'
*/
/* typescript
* export declare function escape(str: string): string;
*/
/* dependencies
* keys
*/
exports = function(str) {
return regTest.test(str) ? str.replace(regReplace, replaceFn) : str;
};
var map = (exports.map = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
"'": ''',
'`': '`'
});
var regSrc = '(?:' + keys(map).join('|') + ')';
var regTest = new RegExp(regSrc);
var regReplace = new RegExp(regSrc, 'g');
var replaceFn = function(match) {
return map[match];
};
return exports;
})({});
/* ------------------------------ escapeJsStr ------------------------------ */
export var escapeJsStr = _.escapeJsStr = (function (exports) {
/* Escape string to be a valid JavaScript string literal between quotes.
*
* http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
*
* |Name |Desc |
* |------|----------------|
* |str |String to escape|
* |return|Escaped string |
*/
/* example
* escapeJsStr('"\n'); // -> '\\"\\\\n'
*/
/* typescript
* export declare function escapeJsStr(str: string): string;
*/
/* dependencies
* toStr
*/
exports = function(str) {
return toStr(str).replace(regEscapeChars, function(char) {
switch (char) {
case '"':
case "'":
case '\\':
return '\\' + char;
case '\n':
return '\\n';
case '\r':
return '\\r';
// Line separator
case '\u2028':
return '\\u2028';
// Paragraph separator
case '\u2029':
return '\\u2029';
}
});
};
var regEscapeChars = /["'\\\n\r\u2028\u2029]/g;
return exports;
})({});
/* ------------------------------ escapeJsonStr ------------------------------ */
export var escapeJsonStr = _.escapeJsonStr = (function (exports) {
/* Escape json string.
*/
/* dependencies
* escapeJsStr
*/
exports = function (str) {
return escapeJsStr(str)
.replace(/\\'/g, "'")
.replace(/\t/g, '\\t')
}
return exports;
})({});
/* ------------------------------ escapeRegExp ------------------------------ */
export var escapeRegExp = _.escapeRegExp = (function (exports) {
/* Escape special chars to be used as literals in RegExp constructors.
*
* |Name |Desc |
* |------|----------------|
* |str |String to escape|
* |return|Escaped string |
*/
/* example
* escapeRegExp('[licia]'); // -> '\\[licia\\]'
*/
/* typescript
* export declare function escapeRegExp(str: string): string;
*/
exports = function(str) {
return str.replace(/\W/g, '\\$&');
};
return exports;
})({});
/* ------------------------------ upperFirst ------------------------------ */
export var upperFirst = _.upperFirst = (function (exports) {
/* Convert the first character of string to upper case.
*
* |Name |Desc |
* |------|-----------------|
* |str |String to convert|
* |return|Converted string |
*/
/* example
* upperFirst('red'); // -> Red
*/
/* typescript
* export declare function upperFirst(str: string): string;
*/
exports = function(str) {
if (str.length < 1) return str;
return str[0].toUpperCase() + str.slice(1);
};
return exports;
})({});
/* ------------------------------ getObjType ------------------------------ */
export var getObjType = _.getObjType = (function (exports) {
/* Get object type.
*/
/* dependencies
* upperFirst
*/
exports = function (obj) {
if (obj.constructor && obj.constructor.name) return obj.constructor.name
return upperFirst({}.toString.call(obj).replace(/(\[object )|]/g, ''))
}
return exports;
})({});
/* ------------------------------ identity ------------------------------ */
export var identity = _.identity = (function (exports) {
/* Return the first argument given.
*
* |Name |Desc |
* |------|-----------|
* |val |Any value |
* |return|Given value|
*/
/* example
* identity('a'); // -> 'a'
*/
/* typescript
* export declare function identity<T>(val: T): T;
*/
exports = function(val) {
return val;
};
return exports;
})({});
/* ------------------------------ objToStr ------------------------------ */
export var objToStr = _.objToStr = (function (exports) {
/* Alias of Object.prototype.toString.
*
* |Name |Desc |
* |------|------------------------------------|
* |val |Source value |
* |return|String representation of given value|
*/
/* example
* objToStr(5); // -> '[object Number]'
*/
/* typescript
* export declare function objToStr(val: any): string;
*/
var ObjToStr = Object.prototype.toString;
exports = function(val) {
return ObjToStr.call(val);
};
return exports;
})({});
/* ------------------------------ isArgs ------------------------------ */
export var isArgs = _.isArgs = (function (exports) {
/* Check if value is classified as an arguments object.
*
* |Name |Desc |
* |------|------------------------------------|
* |val |Value to check |
* |return|True if value is an arguments object|
*/
/* example
* isArgs(
* (function() {
* return arguments;
* })()
* ); // -> true
*/
/* typescript
* export declare function isArgs(val: any): boolean;
*/
/* dependencies
* objToStr
*/
exports = function(val) {
return objToStr(val) === '[object Arguments]';
};
return exports;
})({});
/* ------------------------------ isArr ------------------------------ */
export var isArr = _.isArr = (function (exports) {
/* Check if value is an `Array` object.
*
* |Name |Desc |
* |------|----------------------------------|
* |val |Value to check |
* |return|True if value is an `Array` object|
*/
/* example
* isArr([]); // -> true
* isArr({}); // -> false
*/
/* typescript
* export declare function isArr(val: any): boolean;
*/
/* dependencies
* objToStr
*/
if (Array.isArray && !false) {
exports = Array.isArray;
} else {
exports = function(val) {
return objToStr(val) === '[object Array]';
};
}
return exports;
})({});
/* ------------------------------ castPath ------------------------------ */
export var castPath = _.castPath = (function (exports) {
/* Cast value into a property path array.
*
* |Name |Desc |
* |------|-------------------|
* |path |Value to inspect |
* |obj |Object to query |
* |return|Property path array|
*/
/* example
* castPath('a.b.c'); // -> ['a', 'b', 'c']
* castPath(['a']); // -> ['a']
* castPath('a[0].b'); // -> ['a', '0', 'b']
* castPath('a.b.c', { 'a.b.c': true }); // -> ['a.b.c']
*/
/* typescript
* export declare function castPath(path: string | string[], obj?: any): string[];
*/
/* dependencies
* has isArr
*/
exports = function(str, obj) {
if (isArr(str)) return str;
if (obj && has(obj, str)) return [str];
var ret = [];
str.replace(regPropName, function(match, number, quote, str) {
ret.push(quote ? str.replace(regEscapeChar, '$1') : number || match);
});
return ret;
}; // Lodash _stringToPath
var regPropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
var regEscapeChar = /\\(\\)?/g;
return exports;
})({});
/* ------------------------------ safeGet ------------------------------ */
export var safeGet = _.safeGet = (function (exports) {
/* Get object property, don't throw undefined error.
*
* |Name |Desc |
* |------|-------------------------|
* |obj |Object to query |
* |path |Path of property to get |
* |return|Target value or undefined|
*/
/* example
* const obj = { a: { aa: { aaa: 1 } } };
* safeGet(obj, 'a.aa.aaa'); // -> 1
* safeGet(obj, ['a', 'aa']); // -> {aaa: 1}
* safeGet(obj, 'a.b'); // -> undefined
*/
/* typescript
* export declare function safeGet(obj: any, path: string | string[]): any;
*/
/* dependencies
* isUndef castPath
*/
exports = function(obj, path) {
path = castPath(path, obj);
var prop;
prop = path.shift();
while (!isUndef(prop)) {
obj = obj[prop];
if (obj == null) return;
prop = path.shift();
}
return obj;
};
return exports;
})({});
/* ------------------------------ flatten ------------------------------ */
export var flatten = _.flatten = (function (exports) {
/* Recursively flatten an array.
*
* |Name |Desc |
* |------|-------------------|
* |arr |Array to flatten |
* |return|New flattened array|
*/
/* example
* flatten(['a', ['b', ['c']], 'd', ['e']]); // -> ['a', 'b', 'c', 'd', 'e']
*/
/* typescript
* export declare function flatten(arr: any[]): any[];
*/
/* dependencies
* isArr
*/
exports = function(arr) {
return flat(arr, []);
};
function flat(arr, res) {
var len = arr.length,
i = -1,
cur;
while (len--) {
cur = arr[++i];
isArr(cur) ? flat(cur, res) : res.push(cur);
}
return res;
}
return exports;
})({});
/* ------------------------------ isDate ------------------------------ */
export var isDate = _.isDate = (function (exports) {
/* Check if value is classified as a Date object.
*
* |Name |Desc |
* |------|------------------------------|
* |val |value to check |
* |return|True if value is a Date object|
*/
/* example
* isDate(new Date()); // -> true
*/
/* typescript
* export declare function isDate(val: any): boolean;
*/
/* dependencies
* objToStr
*/
exports = function(val) {
return objToStr(val) === '[object Date]';
};
return exports;
})({});
/* ------------------------------ isFn ------------------------------ */
export var isFn = _.isFn = (function (exports) {
/* Check if value is a function.
*
* |Name |Desc |
* |------|---------------------------|
* |val |Value to check |
* |return|True if value is a function|
*
* Generator function is also classified as true.
*/
/* example
* isFn(function() {}); // -> true
* isFn(function*() {}); // -> true
* isFn(async function() {}); // -> true
*/
/* typescript
* export declare function isFn(val: any): boolean;
*/
/* dependencies
* objToStr
*/
exports = function(val) {
var objStr = objToStr(val);
return (
objStr === '[object Function]' ||
objStr === '[object GeneratorFunction]' ||
objStr === '[object AsyncFunction]'
);
};
return exports;
})({});
/* ------------------------------ getProto ------------------------------ */
export var getProto = _.getProto = (function (exports) {
/* Get prototype of an object.
*
* |Name |Desc |
* |------|---------------------------------------------|
* |obj |Target object |
* |return|Prototype of given object, null if not exists|
*/
/* example
* const a = {};
* getProto(Object.create(a)); // -> a
*/
/* typescript
* export declare function getProto(obj: any): any;
*/
/* dependencies
* isObj isFn
*/
var getPrototypeOf = Object.getPrototypeOf;
var ObjectCtr = {}.constructor;
exports = function(obj) {
if (!isObj(obj)) return;
if (getPrototypeOf && !false) return getPrototypeOf(obj);
var proto = obj.__proto__;
if (proto || proto === null) return proto;
if (isFn(obj.constructor)) return obj.constructor.prototype;
if (obj instanceof ObjectCtr) return ObjectCtr.prototype;
};
return exports;
})({});
/* ------------------------------ isMiniProgram ------------------------------ */
export var isMiniProgram = _.isMiniProgram = (function (exports) {
/* Check if running in wechat mini program.
*/
/* example
* console.log(isMiniProgram); // -> true if running in mini program.
*/
/* typescript
* export declare const isMiniProgram: boolean;
*/
/* dependencies
* isFn
*/
/* eslint-disable no-undef */
exports = typeof wx !== 'undefined' && isFn(wx.openLocation);
return exports;
})({});
/* ------------------------------ isNum ------------------------------ */
export var isNum = _.isNum = (function (exports) {
/* Check if value is classified as a Number primitive or object.
*
* |Name |Desc |
* |------|-------------------------------------|
* |val |Value to check |
* |return|True if value is correctly classified|
*/
/* example
* isNum(5); // -> true
* isNum(5.1); // -> true
* isNum({}); // -> false
*/
/* typescript
* export declare function isNum(val: any): boolean;
*/
/* dependencies
* objToStr
*/
exports = function(val) {
return objToStr(val) === '[object Number]';
};
return exports;
})({});
/* ------------------------------ isArrLike ------------------------------ */
export var isArrLike = _.isArrLike = (function (exports) {
/* Check if value is array-like.
*
* |Name |Desc |
* |------|---------------------------|
* |val |Value to check |
* |return|True if value is array like|
*
* Function returns false.
*/
/* example
* isArrLike('test'); // -> true
* isArrLike(document.body.children); // -> true;
* isArrLike([1, 2, 3]); // -> true
*/
/* typescript
* export declare function isArrLike(val: any): boolean;
*/
/* dependencies
* isNum isFn
*/
var MAX_ARR_IDX = Math.pow(2, 53) - 1;
exports = function(val) {
if (!val) return false;
var len = val.length;
return isNum(len) && len >= 0 && len <= MAX_ARR_IDX && !isFn(val);
};
return exports;
})({});
/* ------------------------------ each ------------------------------ */
export var each = _.each = (function (exports) {
/* Iterate over elements of collection and invokes iterator for each element.
*
* |Name |Desc |
* |--------|------------------------------|
* |obj |Collection to iterate over |
* |iterator|Function invoked per iteration|
* |ctx |Function context |
*/
/* example
* each({ a: 1, b: 2 }, function(val, key) {});
*/
/* typescript
* export declare function each<T>(
* list: types.List<T>,
* iterator: types.ListIterator<T, void>,
* ctx?: any
* ): types.List<T>;
* export declare function each<T>(
* object: types.Dictionary<T>,
* iterator: types.ObjectIterator<T, void>,
* ctx?: any
* ): types.Collection<T>;
*/
/* dependencies
* isArrLike keys optimizeCb types
*/
exports = function(obj, iterator, ctx) {
iterator = optimizeCb(iterator, ctx);
var i, len;
if (isArrLike(obj)) {
for (i = 0, len = obj.length; i < len; i++) {
iterator(obj[i], i, obj);
}
} else {
var _keys = keys(obj);
for (i = 0, len = _keys.length; i < len; i++) {
iterator(obj[_keys[i]], _keys[i], obj);
}
}
return obj;
};
return exports;
})({});
/* ------------------------------ createAssigner ------------------------------ */
export var createAssigner = _.createAssigner = (function (exports) {
/* Used to create extend, extendOwn and defaults.
*
* |Name |Desc |
* |--------|------------------------------|
* |keysFn |Function to get object keys |
* |defaults|No override when set to true |
* |return |Result function, extend... |
*/
/* typescript
* export declare function createAssigner(
* keysFn: types.AnyFn,
* defaults: boolean
* ): types.AnyFn;
*/
/* dependencies
* isUndef each types
*/
exports = function(keysFn, defaults) {
return function(obj) {
each(arguments, function(src, idx) {
if (idx === 0) return;
var keys = keysFn(src);
each(keys, function(key) {
if (!defaults || isUndef(obj[key])) obj[key] = src[key];
});
});
return obj;
};
};
return exports;
})({});
/* ------------------------------ extendOwn ------------------------------ */
export var extendOwn = _.extendOwn = (function (exports) {
/* Like extend, but only copies own properties over to the destination object.
*
* |Name |Desc |
* |-----------|------------------|
* |destination|Destination object|
* |...sources |Sources objects |
* |return |Destination object|
*/
/* example
* extendOwn({ name: 'RedHood' }, { age: 24 }); // -> {name: 'RedHood', age: 24}
*/
/* typescript
* export declare function extendOwn(destination: any, ...sources: any[]): any;
*/
/* dependencies
* keys createAssigner
*/
exports = createAssigner(keys);
return exports;
})({});
/* ------------------------------ values ------------------------------ */
export var values = _.values = (function (exports) {
/* Create an array of the own enumerable property values of object.
*
* |Name |Desc |
* |------|------------------------|
* |obj |Object to query |
* |return|Array of property values|
*/
/* example
* values({ one: 1, two: 2 }); // -> [1, 2]
*/
/* typescript
* export declare function values(obj: any): any[];
*/
/* dependencies
* each
*/
exports = function(obj) {
var ret = [];
each(obj, function(val) {
ret.push(val);
});
return ret;
};
return exports;
})({});
/* ------------------------------ isStr ------------------------------ */
export var isStr = _.isStr = (function (exports) {
/* Check if value is a string primitive.
*
* |Name |Desc |
* |------|-----------------------------------|
* |val |Value to check |
* |return|True if value is a string primitive|
*/
/* example
* isStr('licia'); // -> true
*/
/* typescript
* export declare function isStr(val: any): boolean;
*/
/* dependencies
* objToStr
*/
exports = function(val) {
return objToStr(val) === '[object String]';
};
return exports;
})({});
/* ------------------------------ contain ------------------------------ */
export var contain = _.contain = (function (exports) {
/* Check if the value is present in the list.
*
* |Name |Desc |
* |------|------------------------------------|
* |target|Target object |
* |val |Value to check |
* |return|True if value is present in the list|
*/
/* example
* contain([1, 2, 3], 1); // -> true
* contain({ a: 1, b: 2 }, 1); // -> true
* contain('abc', 'a'); // -> true
*/
/* typescript
* export declare function contain(arr: any[] | {} | string, val: any): boolean;
*/
/* dependencies
* idxOf isStr isArrLike values
*/
exports = function(arr, val) {
if (isStr(arr)) return arr.indexOf(val) > -1;
if (!isArrLike(arr)) arr = values(arr);
return idxOf(arr, val) >= 0;
};
return exports;
})({});
/* ------------------------------ isEmpty ------------------------------ */
export var isEmpty = _.isEmpty = (function (exports) {
/* Check if value is an empty object or array.
*
* |Name |Desc |
* |------|----------------------|
* |val |Value to check |
* |return|True if value is empty|
*/
/* example
* isEmpty([]); // -> true
* isEmpty({}); // -> true
* isEmpty(''); // -> true
*/
/* typescript
* export declare function isEmpty(val: any): boolean;
*/
/* dependencies
* isArrLike isArr isStr isArgs keys
*/
exports = function(val) {
if (val == null) return true;
if (isArrLike(val) && (isArr(val) || isStr(val) || isArgs(val))) {
return val.length === 0;
}
return keys(val).length === 0;
};
return exports;
})({});
/* ------------------------------ isBool ------------------------------ */
export var isBool = _.isBool = (function (exports) {
/* Check if value is a boolean primitive.
*
* |Name |Desc |
* |------|--------------------------|
* |val |Value to check |
* |return|True if value is a boolean|
*/
/* example
* isBool(true); // -> true
* isBool(false); // -> true
* isBool(1); // -> false
*/
/* typescript
* export declare function isBool(val: any): boolean;
*/
exports = function(val) {
return val === true || val === false;
};
return exports;
})({});
/* ------------------------------ isBuffer ------------------------------ */
export var isBuffer = _.isBuffer = (function (exports) {
/* Check if value is a buffer.
*
* |Name |Desc |
* |------|-------------------------|
* |val |The value to check |
* |return|True if value is a buffer|
*/
/* example
* isBuffer(new Buffer(4)); // -> true
*/
/* typescript
* export declare function isBuffer(val: any): boolean;
*/
/* dependencies
* isFn
*/
exports = function(val) {
if (val == null) return false;
if (val._isBuffer) return true;
return (
val.constructor &&
isFn(val.constructor.isBuffer) &&
val.constructor.isBuffer(val)
);
};
return exports;
})({});
/* ------------------------------ isEl ------------------------------ */
export var isEl = _.isEl = (function (exports) {
/* Check if value is a DOM element.
*
* |Name |Desc |
* |------|------------------------------|
* |val |Value to check |
* |return|True if value is a DOM element|
*/
/* example
* isEl(document.body); // -> true
*/
/* typescript
* export declare function isEl(val: any): boolean;
*/
exports = function(val) {
return !!(val && val.nodeType === 1);
};
return exports;
})({});
/* ------------------------------ isErr ------------------------------ */
export var isErr = _.isErr = (function (exports) {
/* Check if value is an error.
*
* |Name |Desc