| /** |
| * lodash (Custom Build) <https://lodash.com/> |
| * Build: `lodash modularize exports="npm" -o ./` |
| * Copyright jQuery Foundation and other contributors <https://jquery.org/> |
| * Released under MIT license <https://lodash.com/license> |
| * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> |
| * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| */ |
| var baseSlice = require('lodash._baseslice'), |
| baseToString = require('lodash._basetostring'), |
| toString = require('lodash.tostring'); |
| |
| /** Used as references for various `Number` constants. */ |
| var INFINITY = 1 / 0, |
| MAX_SAFE_INTEGER = 9007199254740991, |
| MAX_INTEGER = 1.7976931348623157e+308, |
| NAN = 0 / 0; |
| |
| /** `Object#toString` result references. */ |
| var funcTag = '[object Function]', |
| genTag = '[object GeneratorFunction]', |
| symbolTag = '[object Symbol]'; |
| |
| /** Used to match leading and trailing whitespace. */ |
| var reTrim = /^\s+|\s+$/g; |
| |
| /** Used to detect bad signed hexadecimal string values. */ |
| var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; |
| |
| /** Used to detect binary string values. */ |
| var reIsBinary = /^0b[01]+$/i; |
| |
| /** Used to detect octal string values. */ |
| var reIsOctal = /^0o[0-7]+$/i; |
| |
| /** Used to compose unicode character classes. */ |
| var rsAstralRange = '\\ud800-\\udfff', |
| rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23', |
| rsComboSymbolsRange = '\\u20d0-\\u20f0', |
| rsVarRange = '\\ufe0e\\ufe0f'; |
| |
| /** Used to compose unicode capture groups. */ |
| var rsAstral = '[' + rsAstralRange + ']', |
| rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']', |
| rsFitz = '\\ud83c[\\udffb-\\udfff]', |
| rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', |
| rsNonAstral = '[^' + rsAstralRange + ']', |
| rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', |
| rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', |
| rsZWJ = '\\u200d'; |
| |
| /** Used to compose unicode regexes. */ |
| var reOptMod = rsModifier + '?', |
| rsOptVar = '[' + rsVarRange + ']?', |
| rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', |
| rsSeq = rsOptVar + reOptMod + rsOptJoin, |
| rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; |
| |
| /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ |
| var reComplexSymbol = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); |
| |
| /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ |
| var reHasComplexSymbol = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']'); |
| |
| /** Built-in method references without a dependency on `root`. */ |
| var freeParseInt = parseInt; |
| |
| /** |
| * Gets the number of symbols in `string`. |
| * |
| * @private |
| * @param {string} string The string to inspect. |
| * @returns {number} Returns the string size. |
| */ |
| function stringSize(string) { |
| if (!(string && reHasComplexSymbol.test(string))) { |
| return string.length; |
| } |
| var result = reComplexSymbol.lastIndex = 0; |
| while (reComplexSymbol.test(string)) { |
| result++; |
| } |
| return result; |
| } |
| |
| /** |
| * Converts `string` to an array. |
| * |
| * @private |
| * @param {string} string The string to convert. |
| * @returns {Array} Returns the converted array. |
| */ |
| function stringToArray(string) { |
| return string.match(reComplexSymbol); |
| } |
| |
| /** Used for built-in method references. */ |
| var objectProto = Object.prototype; |
| |
| /** |
| * Used to resolve the |
| * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) |
| * of values. |
| */ |
| var objectToString = objectProto.toString; |
| |
| /* Built-in method references for those with the same name as other `lodash` methods. */ |
| var nativeCeil = Math.ceil, |
| nativeFloor = Math.floor; |
| |
| /** |
| * The base implementation of `_.repeat` which doesn't coerce arguments. |
| * |
| * @private |
| * @param {string} string The string to repeat. |
| * @param {number} n The number of times to repeat the string. |
| * @returns {string} Returns the repeated string. |
| */ |
| function baseRepeat(string, n) { |
| var result = ''; |
| if (!string || n < 1 || n > MAX_SAFE_INTEGER) { |
| return result; |
| } |
| // Leverage the exponentiation by squaring algorithm for a faster repeat. |
| // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. |
| do { |
| if (n % 2) { |
| result += string; |
| } |
| n = nativeFloor(n / 2); |
| if (n) { |
| string += string; |
| } |
| } while (n); |
| |
| return result; |
| } |
| |
| /** |
| * Casts `array` to a slice if it's needed. |
| * |
| * @private |
| * @param {Array} array The array to inspect. |
| * @param {number} start The start position. |
| * @param {number} [end=array.length] The end position. |
| * @returns {Array} Returns the cast slice. |
| */ |
| function castSlice(array, start, end) { |
| var length = array.length; |
| end = end === undefined ? length : end; |
| return (!start && end >= length) ? array : baseSlice(array, start, end); |
| } |
| |
| /** |
| * Creates the padding for `string` based on `length`. The `chars` string |
| * is truncated if the number of characters exceeds `length`. |
| * |
| * @private |
| * @param {number} length The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the padding for `string`. |
| */ |
| function createPadding(length, chars) { |
| chars = chars === undefined ? ' ' : baseToString(chars); |
| |
| var charsLength = chars.length; |
| if (charsLength < 2) { |
| return charsLength ? baseRepeat(chars, length) : chars; |
| } |
| var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); |
| return reHasComplexSymbol.test(chars) |
| ? castSlice(stringToArray(result), 0, length).join('') |
| : result.slice(0, length); |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Function` object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isFunction(_); |
| * // => true |
| * |
| * _.isFunction(/abc/); |
| * // => false |
| */ |
| function isFunction(value) { |
| // The use of `Object#toString` avoids issues with the `typeof` operator |
| // in Safari 8 which returns 'object' for typed array and weak map constructors, |
| // and PhantomJS 1.9 which returns 'function' for `NodeList` instances. |
| var tag = isObject(value) ? objectToString.call(value) : ''; |
| return tag == funcTag || tag == genTag; |
| } |
| |
| /** |
| * Checks if `value` is the |
| * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types) |
| * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) |
| * |
| * @static |
| * @memberOf _ |
| * @since 0.1.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is an object, else `false`. |
| * @example |
| * |
| * _.isObject({}); |
| * // => true |
| * |
| * _.isObject([1, 2, 3]); |
| * // => true |
| * |
| * _.isObject(_.noop); |
| * // => true |
| * |
| * _.isObject(null); |
| * // => false |
| */ |
| function isObject(value) { |
| var type = typeof value; |
| return !!value && (type == 'object' || type == 'function'); |
| } |
| |
| /** |
| * Checks if `value` is object-like. A value is object-like if it's not `null` |
| * and has a `typeof` result of "object". |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is object-like, else `false`. |
| * @example |
| * |
| * _.isObjectLike({}); |
| * // => true |
| * |
| * _.isObjectLike([1, 2, 3]); |
| * // => true |
| * |
| * _.isObjectLike(_.noop); |
| * // => false |
| * |
| * _.isObjectLike(null); |
| * // => false |
| */ |
| function isObjectLike(value) { |
| return !!value && typeof value == 'object'; |
| } |
| |
| /** |
| * Checks if `value` is classified as a `Symbol` primitive or object. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to check. |
| * @returns {boolean} Returns `true` if `value` is correctly classified, |
| * else `false`. |
| * @example |
| * |
| * _.isSymbol(Symbol.iterator); |
| * // => true |
| * |
| * _.isSymbol('abc'); |
| * // => false |
| */ |
| function isSymbol(value) { |
| return typeof value == 'symbol' || |
| (isObjectLike(value) && objectToString.call(value) == symbolTag); |
| } |
| |
| /** |
| * Converts `value` to a finite number. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.12.0 |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {number} Returns the converted number. |
| * @example |
| * |
| * _.toFinite(3.2); |
| * // => 3.2 |
| * |
| * _.toFinite(Number.MIN_VALUE); |
| * // => 5e-324 |
| * |
| * _.toFinite(Infinity); |
| * // => 1.7976931348623157e+308 |
| * |
| * _.toFinite('3.2'); |
| * // => 3.2 |
| */ |
| function toFinite(value) { |
| if (!value) { |
| return value === 0 ? value : 0; |
| } |
| value = toNumber(value); |
| if (value === INFINITY || value === -INFINITY) { |
| var sign = (value < 0 ? -1 : 1); |
| return sign * MAX_INTEGER; |
| } |
| return value === value ? value : 0; |
| } |
| |
| /** |
| * Converts `value` to an integer. |
| * |
| * **Note:** This function is loosely based on |
| * [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to convert. |
| * @returns {number} Returns the converted integer. |
| * @example |
| * |
| * _.toInteger(3.2); |
| * // => 3 |
| * |
| * _.toInteger(Number.MIN_VALUE); |
| * // => 0 |
| * |
| * _.toInteger(Infinity); |
| * // => 1.7976931348623157e+308 |
| * |
| * _.toInteger('3.2'); |
| * // => 3 |
| */ |
| function toInteger(value) { |
| var result = toFinite(value), |
| remainder = result % 1; |
| |
| return result === result ? (remainder ? result - remainder : result) : 0; |
| } |
| |
| /** |
| * Converts `value` to a number. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category Lang |
| * @param {*} value The value to process. |
| * @returns {number} Returns the number. |
| * @example |
| * |
| * _.toNumber(3.2); |
| * // => 3.2 |
| * |
| * _.toNumber(Number.MIN_VALUE); |
| * // => 5e-324 |
| * |
| * _.toNumber(Infinity); |
| * // => Infinity |
| * |
| * _.toNumber('3.2'); |
| * // => 3.2 |
| */ |
| function toNumber(value) { |
| if (typeof value == 'number') { |
| return value; |
| } |
| if (isSymbol(value)) { |
| return NAN; |
| } |
| if (isObject(value)) { |
| var other = isFunction(value.valueOf) ? value.valueOf() : value; |
| value = isObject(other) ? (other + '') : other; |
| } |
| if (typeof value != 'string') { |
| return value === 0 ? value : +value; |
| } |
| value = value.replace(reTrim, ''); |
| var isBinary = reIsBinary.test(value); |
| return (isBinary || reIsOctal.test(value)) |
| ? freeParseInt(value.slice(2), isBinary ? 2 : 8) |
| : (reIsBadHex.test(value) ? NAN : +value); |
| } |
| |
| /** |
| * Pads `string` on the left side if it's shorter than `length`. Padding |
| * characters are truncated if they exceed `length`. |
| * |
| * @static |
| * @memberOf _ |
| * @since 4.0.0 |
| * @category String |
| * @param {string} [string=''] The string to pad. |
| * @param {number} [length=0] The padding length. |
| * @param {string} [chars=' '] The string used as padding. |
| * @returns {string} Returns the padded string. |
| * @example |
| * |
| * _.padStart('abc', 6); |
| * // => ' abc' |
| * |
| * _.padStart('abc', 6, '_-'); |
| * // => '_-_abc' |
| * |
| * _.padStart('abc', 3); |
| * // => 'abc' |
| */ |
| function padStart(string, length, chars) { |
| string = toString(string); |
| length = toInteger(length); |
| |
| var strLength = length ? stringSize(string) : 0; |
| return (length && strLength < length) |
| ? (createPadding(length - strLength, chars) + string) |
| : string; |
| } |
| |
| module.exports = padStart; |