@nuxt/utils
Advanced tools
Comparing version 2.14.12 to 2.15.0
1325
dist/utils.js
/*! | ||
* @nuxt/utils v2.14.12 (c) 2016-2020 | ||
* - All the amazing contributors | ||
* Released under the MIT License. | ||
* @nuxt/utils v2.15.0 (c) 2016-2021 | ||
* Released under the MIT License | ||
* Repository: https://github.com/nuxt/nuxt.js | ||
* Website: https://nuxtjs.org | ||
@@ -12,2 +11,3 @@ */ | ||
const ufo = require('ufo'); | ||
const path = require('path'); | ||
@@ -19,5 +19,8 @@ const consola = require('consola'); | ||
const onExit = require('signal-exit'); | ||
const ufo = require('@nuxt/ufo'); | ||
const lodash = require('lodash'); | ||
const serialize = require('serialize-javascript'); | ||
const _createRequire = require('create-require'); | ||
const jiti = require('jiti'); | ||
const UAParser = require('ua-parser-js'); | ||
const semver = require('semver'); | ||
@@ -33,3 +36,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } | ||
const serialize__default = /*#__PURE__*/_interopDefaultLegacy(serialize); | ||
const _createRequire__default = /*#__PURE__*/_interopDefaultLegacy(_createRequire); | ||
const jiti__default = /*#__PURE__*/_interopDefaultLegacy(jiti); | ||
const UAParser__default = /*#__PURE__*/_interopDefaultLegacy(UAParser); | ||
const semver__default = /*#__PURE__*/_interopDefaultLegacy(semver); | ||
@@ -80,9 +86,3 @@ const TARGETS = { | ||
const urlJoin = function urlJoin () { | ||
return [].slice | ||
.call(arguments) | ||
.join('/') | ||
.replace(/\/+/g, '/') | ||
.replace(':/', '://') | ||
}; | ||
const urlJoin = ufo.joinURL; | ||
@@ -208,313 +208,2 @@ /** | ||
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; | ||
/** Detect free variable `global` from Node.js. */ | ||
var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal; | ||
var _freeGlobal = freeGlobal; | ||
/** Detect free variable `self`. */ | ||
var freeSelf = typeof self == 'object' && self && self.Object === Object && self; | ||
/** Used as a reference to the global object. */ | ||
var root = _freeGlobal || freeSelf || Function('return this')(); | ||
var _root = root; | ||
/** Built-in value references. */ | ||
var Symbol = _root.Symbol; | ||
var _Symbol = Symbol; | ||
/** | ||
* A specialized version of `_.map` for arrays without support for iteratee | ||
* shorthands. | ||
* | ||
* @private | ||
* @param {Array} [array] The array to iterate over. | ||
* @param {Function} iteratee The function invoked per iteration. | ||
* @returns {Array} Returns the new mapped array. | ||
*/ | ||
function arrayMap(array, iteratee) { | ||
var index = -1, | ||
length = array == null ? 0 : array.length, | ||
result = Array(length); | ||
while (++index < length) { | ||
result[index] = iteratee(array[index], index, array); | ||
} | ||
return result; | ||
} | ||
var _arrayMap = arrayMap; | ||
/** | ||
* Checks if `value` is classified as an `Array` object. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 0.1.0 | ||
* @category Lang | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is an array, else `false`. | ||
* @example | ||
* | ||
* _.isArray([1, 2, 3]); | ||
* // => true | ||
* | ||
* _.isArray(document.body.children); | ||
* // => false | ||
* | ||
* _.isArray('abc'); | ||
* // => false | ||
* | ||
* _.isArray(_.noop); | ||
* // => false | ||
*/ | ||
var isArray = Array.isArray; | ||
var isArray_1 = isArray; | ||
/** Used for built-in method references. */ | ||
var objectProto = Object.prototype; | ||
/** Used to check objects for own properties. */ | ||
var hasOwnProperty = objectProto.hasOwnProperty; | ||
/** | ||
* Used to resolve the | ||
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | ||
* of values. | ||
*/ | ||
var nativeObjectToString = objectProto.toString; | ||
/** Built-in value references. */ | ||
var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined; | ||
/** | ||
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. | ||
* | ||
* @private | ||
* @param {*} value The value to query. | ||
* @returns {string} Returns the raw `toStringTag`. | ||
*/ | ||
function getRawTag(value) { | ||
var isOwn = hasOwnProperty.call(value, symToStringTag), | ||
tag = value[symToStringTag]; | ||
try { | ||
value[symToStringTag] = undefined; | ||
var unmasked = true; | ||
} catch (e) {} | ||
var result = nativeObjectToString.call(value); | ||
if (unmasked) { | ||
if (isOwn) { | ||
value[symToStringTag] = tag; | ||
} else { | ||
delete value[symToStringTag]; | ||
} | ||
} | ||
return result; | ||
} | ||
var _getRawTag = getRawTag; | ||
/** Used for built-in method references. */ | ||
var objectProto$1 = Object.prototype; | ||
/** | ||
* Used to resolve the | ||
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) | ||
* of values. | ||
*/ | ||
var nativeObjectToString$1 = objectProto$1.toString; | ||
/** | ||
* Converts `value` to a string using `Object.prototype.toString`. | ||
* | ||
* @private | ||
* @param {*} value The value to convert. | ||
* @returns {string} Returns the converted string. | ||
*/ | ||
function objectToString(value) { | ||
return nativeObjectToString$1.call(value); | ||
} | ||
var _objectToString = objectToString; | ||
/** `Object#toString` result references. */ | ||
var nullTag = '[object Null]', | ||
undefinedTag = '[object Undefined]'; | ||
/** Built-in value references. */ | ||
var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined; | ||
/** | ||
* The base implementation of `getTag` without fallbacks for buggy environments. | ||
* | ||
* @private | ||
* @param {*} value The value to query. | ||
* @returns {string} Returns the `toStringTag`. | ||
*/ | ||
function baseGetTag(value) { | ||
if (value == null) { | ||
return value === undefined ? undefinedTag : nullTag; | ||
} | ||
return (symToStringTag$1 && symToStringTag$1 in Object(value)) | ||
? _getRawTag(value) | ||
: _objectToString(value); | ||
} | ||
var _baseGetTag = baseGetTag; | ||
/** | ||
* 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 != null && typeof value == 'object'; | ||
} | ||
var isObjectLike_1 = isObjectLike; | ||
/** `Object#toString` result references. */ | ||
var symbolTag = '[object Symbol]'; | ||
/** | ||
* 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 a symbol, else `false`. | ||
* @example | ||
* | ||
* _.isSymbol(Symbol.iterator); | ||
* // => true | ||
* | ||
* _.isSymbol('abc'); | ||
* // => false | ||
*/ | ||
function isSymbol(value) { | ||
return typeof value == 'symbol' || | ||
(isObjectLike_1(value) && _baseGetTag(value) == symbolTag); | ||
} | ||
var isSymbol_1 = isSymbol; | ||
/** Used as references for various `Number` constants. */ | ||
var INFINITY = 1 / 0; | ||
/** Used to convert symbols to primitives and strings. */ | ||
var symbolProto = _Symbol ? _Symbol.prototype : undefined, | ||
symbolToString = symbolProto ? symbolProto.toString : undefined; | ||
/** | ||
* The base implementation of `_.toString` which doesn't convert nullish | ||
* values to empty strings. | ||
* | ||
* @private | ||
* @param {*} value The value to process. | ||
* @returns {string} Returns the string. | ||
*/ | ||
function baseToString(value) { | ||
// Exit early for strings to avoid a performance hit in some environments. | ||
if (typeof value == 'string') { | ||
return value; | ||
} | ||
if (isArray_1(value)) { | ||
// Recursively convert values (susceptible to call stack limits). | ||
return _arrayMap(value, baseToString) + ''; | ||
} | ||
if (isSymbol_1(value)) { | ||
return symbolToString ? symbolToString.call(value) : ''; | ||
} | ||
var result = (value + ''); | ||
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; | ||
} | ||
var _baseToString = baseToString; | ||
/** | ||
* Converts `value` to a string. An empty string is returned for `null` | ||
* and `undefined` values. The sign of `-0` is preserved. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 4.0.0 | ||
* @category Lang | ||
* @param {*} value The value to convert. | ||
* @returns {string} Returns the converted string. | ||
* @example | ||
* | ||
* _.toString(null); | ||
* // => '' | ||
* | ||
* _.toString(-0); | ||
* // => '-0' | ||
* | ||
* _.toString([1, 2, 3]); | ||
* // => '1,2,3' | ||
*/ | ||
function toString(value) { | ||
return value == null ? '' : _baseToString(value); | ||
} | ||
var toString_1 = toString; | ||
/** | ||
* Used to match `RegExp` | ||
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). | ||
*/ | ||
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, | ||
reHasRegExpChar = RegExp(reRegExpChar.source); | ||
/** | ||
* Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", | ||
* "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 3.0.0 | ||
* @category String | ||
* @param {string} [string=''] The string to escape. | ||
* @returns {string} Returns the escaped string. | ||
* @example | ||
* | ||
* _.escapeRegExp('[lodash](https://lodash.com/)'); | ||
* // => '\[lodash\]\(https://lodash\.com/\)' | ||
*/ | ||
function escapeRegExp(string) { | ||
string = toString_1(string); | ||
return (string && reHasRegExpChar.test(string)) | ||
? string.replace(reRegExpChar, '\\$&') | ||
: string; | ||
} | ||
var escapeRegExp_1 = escapeRegExp; | ||
const startsWithAlias = aliasArray => str => aliasArray.some(c => str.startsWith(c)); | ||
@@ -541,3 +230,3 @@ | ||
const reqSep = /\//g; | ||
const sysSep = escapeRegExp_1(path__default['default'].sep); | ||
const sysSep = lodash.escapeRegExp(path__default['default'].sep); | ||
const normalize = string => string.replace(reqSep, sysSep); | ||
@@ -624,915 +313,5 @@ | ||
const getMainModule = () => { | ||
return require.main || (module && module.main) || module | ||
return (require && require.main) || (module && module.main) || module | ||
}; | ||
/** Used to match property names within property paths. */ | ||
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, | ||
reIsPlainProp = /^\w*$/; | ||
/** | ||
* Checks if `value` is a property name and not a property path. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @param {Object} [object] The object to query keys on. | ||
* @returns {boolean} Returns `true` if `value` is a property name, else `false`. | ||
*/ | ||
function isKey(value, object) { | ||
if (isArray_1(value)) { | ||
return false; | ||
} | ||
var type = typeof value; | ||
if (type == 'number' || type == 'symbol' || type == 'boolean' || | ||
value == null || isSymbol_1(value)) { | ||
return true; | ||
} | ||
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || | ||
(object != null && value in Object(object)); | ||
} | ||
var _isKey = isKey; | ||
/** | ||
* Checks if `value` is the | ||
* [language type](http://www.ecma-international.org/ecma-262/7.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 != null && (type == 'object' || type == 'function'); | ||
} | ||
var isObject_1 = isObject; | ||
/** `Object#toString` result references. */ | ||
var asyncTag = '[object AsyncFunction]', | ||
funcTag = '[object Function]', | ||
genTag = '[object GeneratorFunction]', | ||
proxyTag = '[object Proxy]'; | ||
/** | ||
* 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 a function, else `false`. | ||
* @example | ||
* | ||
* _.isFunction(_); | ||
* // => true | ||
* | ||
* _.isFunction(/abc/); | ||
* // => false | ||
*/ | ||
function isFunction(value) { | ||
if (!isObject_1(value)) { | ||
return false; | ||
} | ||
// The use of `Object#toString` avoids issues with the `typeof` operator | ||
// in Safari 9 which returns 'object' for typed arrays and other constructors. | ||
var tag = _baseGetTag(value); | ||
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; | ||
} | ||
var isFunction_1 = isFunction; | ||
/** Used to detect overreaching core-js shims. */ | ||
var coreJsData = _root['__core-js_shared__']; | ||
var _coreJsData = coreJsData; | ||
/** Used to detect methods masquerading as native. */ | ||
var maskSrcKey = (function() { | ||
var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || ''); | ||
return uid ? ('Symbol(src)_1.' + uid) : ''; | ||
}()); | ||
/** | ||
* Checks if `func` has its source masked. | ||
* | ||
* @private | ||
* @param {Function} func The function to check. | ||
* @returns {boolean} Returns `true` if `func` is masked, else `false`. | ||
*/ | ||
function isMasked(func) { | ||
return !!maskSrcKey && (maskSrcKey in func); | ||
} | ||
var _isMasked = isMasked; | ||
/** Used for built-in method references. */ | ||
var funcProto = Function.prototype; | ||
/** Used to resolve the decompiled source of functions. */ | ||
var funcToString = funcProto.toString; | ||
/** | ||
* Converts `func` to its source code. | ||
* | ||
* @private | ||
* @param {Function} func The function to convert. | ||
* @returns {string} Returns the source code. | ||
*/ | ||
function toSource(func) { | ||
if (func != null) { | ||
try { | ||
return funcToString.call(func); | ||
} catch (e) {} | ||
try { | ||
return (func + ''); | ||
} catch (e) {} | ||
} | ||
return ''; | ||
} | ||
var _toSource = toSource; | ||
/** | ||
* Used to match `RegExp` | ||
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). | ||
*/ | ||
var reRegExpChar$1 = /[\\^$.*+?()[\]{}|]/g; | ||
/** Used to detect host constructors (Safari). */ | ||
var reIsHostCtor = /^\[object .+?Constructor\]$/; | ||
/** Used for built-in method references. */ | ||
var funcProto$1 = Function.prototype, | ||
objectProto$2 = Object.prototype; | ||
/** Used to resolve the decompiled source of functions. */ | ||
var funcToString$1 = funcProto$1.toString; | ||
/** Used to check objects for own properties. */ | ||
var hasOwnProperty$1 = objectProto$2.hasOwnProperty; | ||
/** Used to detect if a method is native. */ | ||
var reIsNative = RegExp('^' + | ||
funcToString$1.call(hasOwnProperty$1).replace(reRegExpChar$1, '\\$&') | ||
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' | ||
); | ||
/** | ||
* The base implementation of `_.isNative` without bad shim checks. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is a native function, | ||
* else `false`. | ||
*/ | ||
function baseIsNative(value) { | ||
if (!isObject_1(value) || _isMasked(value)) { | ||
return false; | ||
} | ||
var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor; | ||
return pattern.test(_toSource(value)); | ||
} | ||
var _baseIsNative = baseIsNative; | ||
/** | ||
* Gets the value at `key` of `object`. | ||
* | ||
* @private | ||
* @param {Object} [object] The object to query. | ||
* @param {string} key The key of the property to get. | ||
* @returns {*} Returns the property value. | ||
*/ | ||
function getValue(object, key) { | ||
return object == null ? undefined : object[key]; | ||
} | ||
var _getValue = getValue; | ||
/** | ||
* Gets the native function at `key` of `object`. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @param {string} key The key of the method to get. | ||
* @returns {*} Returns the function if it's native, else `undefined`. | ||
*/ | ||
function getNative(object, key) { | ||
var value = _getValue(object, key); | ||
return _baseIsNative(value) ? value : undefined; | ||
} | ||
var _getNative = getNative; | ||
/* Built-in method references that are verified to be native. */ | ||
var nativeCreate = _getNative(Object, 'create'); | ||
var _nativeCreate = nativeCreate; | ||
/** | ||
* Removes all key-value entries from the hash. | ||
* | ||
* @private | ||
* @name clear | ||
* @memberOf Hash | ||
*/ | ||
function hashClear() { | ||
this.__data__ = _nativeCreate ? _nativeCreate(null) : {}; | ||
this.size = 0; | ||
} | ||
var _hashClear = hashClear; | ||
/** | ||
* Removes `key` and its value from the hash. | ||
* | ||
* @private | ||
* @name delete | ||
* @memberOf Hash | ||
* @param {Object} hash The hash to modify. | ||
* @param {string} key The key of the value to remove. | ||
* @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
*/ | ||
function hashDelete(key) { | ||
var result = this.has(key) && delete this.__data__[key]; | ||
this.size -= result ? 1 : 0; | ||
return result; | ||
} | ||
var _hashDelete = hashDelete; | ||
/** Used to stand-in for `undefined` hash values. */ | ||
var HASH_UNDEFINED = '__lodash_hash_undefined__'; | ||
/** Used for built-in method references. */ | ||
var objectProto$3 = Object.prototype; | ||
/** Used to check objects for own properties. */ | ||
var hasOwnProperty$2 = objectProto$3.hasOwnProperty; | ||
/** | ||
* Gets the hash value for `key`. | ||
* | ||
* @private | ||
* @name get | ||
* @memberOf Hash | ||
* @param {string} key The key of the value to get. | ||
* @returns {*} Returns the entry value. | ||
*/ | ||
function hashGet(key) { | ||
var data = this.__data__; | ||
if (_nativeCreate) { | ||
var result = data[key]; | ||
return result === HASH_UNDEFINED ? undefined : result; | ||
} | ||
return hasOwnProperty$2.call(data, key) ? data[key] : undefined; | ||
} | ||
var _hashGet = hashGet; | ||
/** Used for built-in method references. */ | ||
var objectProto$4 = Object.prototype; | ||
/** Used to check objects for own properties. */ | ||
var hasOwnProperty$3 = objectProto$4.hasOwnProperty; | ||
/** | ||
* Checks if a hash value for `key` exists. | ||
* | ||
* @private | ||
* @name has | ||
* @memberOf Hash | ||
* @param {string} key The key of the entry to check. | ||
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
*/ | ||
function hashHas(key) { | ||
var data = this.__data__; | ||
return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key); | ||
} | ||
var _hashHas = hashHas; | ||
/** Used to stand-in for `undefined` hash values. */ | ||
var HASH_UNDEFINED$1 = '__lodash_hash_undefined__'; | ||
/** | ||
* Sets the hash `key` to `value`. | ||
* | ||
* @private | ||
* @name set | ||
* @memberOf Hash | ||
* @param {string} key The key of the value to set. | ||
* @param {*} value The value to set. | ||
* @returns {Object} Returns the hash instance. | ||
*/ | ||
function hashSet(key, value) { | ||
var data = this.__data__; | ||
this.size += this.has(key) ? 0 : 1; | ||
data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value; | ||
return this; | ||
} | ||
var _hashSet = hashSet; | ||
/** | ||
* Creates a hash object. | ||
* | ||
* @private | ||
* @constructor | ||
* @param {Array} [entries] The key-value pairs to cache. | ||
*/ | ||
function Hash(entries) { | ||
var index = -1, | ||
length = entries == null ? 0 : entries.length; | ||
this.clear(); | ||
while (++index < length) { | ||
var entry = entries[index]; | ||
this.set(entry[0], entry[1]); | ||
} | ||
} | ||
// Add methods to `Hash`. | ||
Hash.prototype.clear = _hashClear; | ||
Hash.prototype['delete'] = _hashDelete; | ||
Hash.prototype.get = _hashGet; | ||
Hash.prototype.has = _hashHas; | ||
Hash.prototype.set = _hashSet; | ||
var _Hash = Hash; | ||
/** | ||
* Removes all key-value entries from the list cache. | ||
* | ||
* @private | ||
* @name clear | ||
* @memberOf ListCache | ||
*/ | ||
function listCacheClear() { | ||
this.__data__ = []; | ||
this.size = 0; | ||
} | ||
var _listCacheClear = listCacheClear; | ||
/** | ||
* Performs a | ||
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) | ||
* comparison between two values to determine if they are equivalent. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 4.0.0 | ||
* @category Lang | ||
* @param {*} value The value to compare. | ||
* @param {*} other The other value to compare. | ||
* @returns {boolean} Returns `true` if the values are equivalent, else `false`. | ||
* @example | ||
* | ||
* var object = { 'a': 1 }; | ||
* var other = { 'a': 1 }; | ||
* | ||
* _.eq(object, object); | ||
* // => true | ||
* | ||
* _.eq(object, other); | ||
* // => false | ||
* | ||
* _.eq('a', 'a'); | ||
* // => true | ||
* | ||
* _.eq('a', Object('a')); | ||
* // => false | ||
* | ||
* _.eq(NaN, NaN); | ||
* // => true | ||
*/ | ||
function eq(value, other) { | ||
return value === other || (value !== value && other !== other); | ||
} | ||
var eq_1 = eq; | ||
/** | ||
* Gets the index at which the `key` is found in `array` of key-value pairs. | ||
* | ||
* @private | ||
* @param {Array} array The array to inspect. | ||
* @param {*} key The key to search for. | ||
* @returns {number} Returns the index of the matched value, else `-1`. | ||
*/ | ||
function assocIndexOf(array, key) { | ||
var length = array.length; | ||
while (length--) { | ||
if (eq_1(array[length][0], key)) { | ||
return length; | ||
} | ||
} | ||
return -1; | ||
} | ||
var _assocIndexOf = assocIndexOf; | ||
/** Used for built-in method references. */ | ||
var arrayProto = Array.prototype; | ||
/** Built-in value references. */ | ||
var splice = arrayProto.splice; | ||
/** | ||
* Removes `key` and its value from the list cache. | ||
* | ||
* @private | ||
* @name delete | ||
* @memberOf ListCache | ||
* @param {string} key The key of the value to remove. | ||
* @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
*/ | ||
function listCacheDelete(key) { | ||
var data = this.__data__, | ||
index = _assocIndexOf(data, key); | ||
if (index < 0) { | ||
return false; | ||
} | ||
var lastIndex = data.length - 1; | ||
if (index == lastIndex) { | ||
data.pop(); | ||
} else { | ||
splice.call(data, index, 1); | ||
} | ||
--this.size; | ||
return true; | ||
} | ||
var _listCacheDelete = listCacheDelete; | ||
/** | ||
* Gets the list cache value for `key`. | ||
* | ||
* @private | ||
* @name get | ||
* @memberOf ListCache | ||
* @param {string} key The key of the value to get. | ||
* @returns {*} Returns the entry value. | ||
*/ | ||
function listCacheGet(key) { | ||
var data = this.__data__, | ||
index = _assocIndexOf(data, key); | ||
return index < 0 ? undefined : data[index][1]; | ||
} | ||
var _listCacheGet = listCacheGet; | ||
/** | ||
* Checks if a list cache value for `key` exists. | ||
* | ||
* @private | ||
* @name has | ||
* @memberOf ListCache | ||
* @param {string} key The key of the entry to check. | ||
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
*/ | ||
function listCacheHas(key) { | ||
return _assocIndexOf(this.__data__, key) > -1; | ||
} | ||
var _listCacheHas = listCacheHas; | ||
/** | ||
* Sets the list cache `key` to `value`. | ||
* | ||
* @private | ||
* @name set | ||
* @memberOf ListCache | ||
* @param {string} key The key of the value to set. | ||
* @param {*} value The value to set. | ||
* @returns {Object} Returns the list cache instance. | ||
*/ | ||
function listCacheSet(key, value) { | ||
var data = this.__data__, | ||
index = _assocIndexOf(data, key); | ||
if (index < 0) { | ||
++this.size; | ||
data.push([key, value]); | ||
} else { | ||
data[index][1] = value; | ||
} | ||
return this; | ||
} | ||
var _listCacheSet = listCacheSet; | ||
/** | ||
* Creates an list cache object. | ||
* | ||
* @private | ||
* @constructor | ||
* @param {Array} [entries] The key-value pairs to cache. | ||
*/ | ||
function ListCache(entries) { | ||
var index = -1, | ||
length = entries == null ? 0 : entries.length; | ||
this.clear(); | ||
while (++index < length) { | ||
var entry = entries[index]; | ||
this.set(entry[0], entry[1]); | ||
} | ||
} | ||
// Add methods to `ListCache`. | ||
ListCache.prototype.clear = _listCacheClear; | ||
ListCache.prototype['delete'] = _listCacheDelete; | ||
ListCache.prototype.get = _listCacheGet; | ||
ListCache.prototype.has = _listCacheHas; | ||
ListCache.prototype.set = _listCacheSet; | ||
var _ListCache = ListCache; | ||
/* Built-in method references that are verified to be native. */ | ||
var Map$1 = _getNative(_root, 'Map'); | ||
var _Map = Map$1; | ||
/** | ||
* Removes all key-value entries from the map. | ||
* | ||
* @private | ||
* @name clear | ||
* @memberOf MapCache | ||
*/ | ||
function mapCacheClear() { | ||
this.size = 0; | ||
this.__data__ = { | ||
'hash': new _Hash, | ||
'map': new (_Map || _ListCache), | ||
'string': new _Hash | ||
}; | ||
} | ||
var _mapCacheClear = mapCacheClear; | ||
/** | ||
* Checks if `value` is suitable for use as unique object key. | ||
* | ||
* @private | ||
* @param {*} value The value to check. | ||
* @returns {boolean} Returns `true` if `value` is suitable, else `false`. | ||
*/ | ||
function isKeyable(value) { | ||
var type = typeof value; | ||
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') | ||
? (value !== '__proto__') | ||
: (value === null); | ||
} | ||
var _isKeyable = isKeyable; | ||
/** | ||
* Gets the data for `map`. | ||
* | ||
* @private | ||
* @param {Object} map The map to query. | ||
* @param {string} key The reference key. | ||
* @returns {*} Returns the map data. | ||
*/ | ||
function getMapData(map, key) { | ||
var data = map.__data__; | ||
return _isKeyable(key) | ||
? data[typeof key == 'string' ? 'string' : 'hash'] | ||
: data.map; | ||
} | ||
var _getMapData = getMapData; | ||
/** | ||
* Removes `key` and its value from the map. | ||
* | ||
* @private | ||
* @name delete | ||
* @memberOf MapCache | ||
* @param {string} key The key of the value to remove. | ||
* @returns {boolean} Returns `true` if the entry was removed, else `false`. | ||
*/ | ||
function mapCacheDelete(key) { | ||
var result = _getMapData(this, key)['delete'](key); | ||
this.size -= result ? 1 : 0; | ||
return result; | ||
} | ||
var _mapCacheDelete = mapCacheDelete; | ||
/** | ||
* Gets the map value for `key`. | ||
* | ||
* @private | ||
* @name get | ||
* @memberOf MapCache | ||
* @param {string} key The key of the value to get. | ||
* @returns {*} Returns the entry value. | ||
*/ | ||
function mapCacheGet(key) { | ||
return _getMapData(this, key).get(key); | ||
} | ||
var _mapCacheGet = mapCacheGet; | ||
/** | ||
* Checks if a map value for `key` exists. | ||
* | ||
* @private | ||
* @name has | ||
* @memberOf MapCache | ||
* @param {string} key The key of the entry to check. | ||
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. | ||
*/ | ||
function mapCacheHas(key) { | ||
return _getMapData(this, key).has(key); | ||
} | ||
var _mapCacheHas = mapCacheHas; | ||
/** | ||
* Sets the map `key` to `value`. | ||
* | ||
* @private | ||
* @name set | ||
* @memberOf MapCache | ||
* @param {string} key The key of the value to set. | ||
* @param {*} value The value to set. | ||
* @returns {Object} Returns the map cache instance. | ||
*/ | ||
function mapCacheSet(key, value) { | ||
var data = _getMapData(this, key), | ||
size = data.size; | ||
data.set(key, value); | ||
this.size += data.size == size ? 0 : 1; | ||
return this; | ||
} | ||
var _mapCacheSet = mapCacheSet; | ||
/** | ||
* Creates a map cache object to store key-value pairs. | ||
* | ||
* @private | ||
* @constructor | ||
* @param {Array} [entries] The key-value pairs to cache. | ||
*/ | ||
function MapCache(entries) { | ||
var index = -1, | ||
length = entries == null ? 0 : entries.length; | ||
this.clear(); | ||
while (++index < length) { | ||
var entry = entries[index]; | ||
this.set(entry[0], entry[1]); | ||
} | ||
} | ||
// Add methods to `MapCache`. | ||
MapCache.prototype.clear = _mapCacheClear; | ||
MapCache.prototype['delete'] = _mapCacheDelete; | ||
MapCache.prototype.get = _mapCacheGet; | ||
MapCache.prototype.has = _mapCacheHas; | ||
MapCache.prototype.set = _mapCacheSet; | ||
var _MapCache = MapCache; | ||
/** Error message constants. */ | ||
var FUNC_ERROR_TEXT = 'Expected a function'; | ||
/** | ||
* Creates a function that memoizes the result of `func`. If `resolver` is | ||
* provided, it determines the cache key for storing the result based on the | ||
* arguments provided to the memoized function. By default, the first argument | ||
* provided to the memoized function is used as the map cache key. The `func` | ||
* is invoked with the `this` binding of the memoized function. | ||
* | ||
* **Note:** The cache is exposed as the `cache` property on the memoized | ||
* function. Its creation may be customized by replacing the `_.memoize.Cache` | ||
* constructor with one whose instances implement the | ||
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) | ||
* method interface of `clear`, `delete`, `get`, `has`, and `set`. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 0.1.0 | ||
* @category Function | ||
* @param {Function} func The function to have its output memoized. | ||
* @param {Function} [resolver] The function to resolve the cache key. | ||
* @returns {Function} Returns the new memoized function. | ||
* @example | ||
* | ||
* var object = { 'a': 1, 'b': 2 }; | ||
* var other = { 'c': 3, 'd': 4 }; | ||
* | ||
* var values = _.memoize(_.values); | ||
* values(object); | ||
* // => [1, 2] | ||
* | ||
* values(other); | ||
* // => [3, 4] | ||
* | ||
* object.a = 2; | ||
* values(object); | ||
* // => [1, 2] | ||
* | ||
* // Modify the result cache. | ||
* values.cache.set(object, ['a', 'b']); | ||
* values(object); | ||
* // => ['a', 'b'] | ||
* | ||
* // Replace `_.memoize.Cache`. | ||
* _.memoize.Cache = WeakMap; | ||
*/ | ||
function memoize(func, resolver) { | ||
if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { | ||
throw new TypeError(FUNC_ERROR_TEXT); | ||
} | ||
var memoized = function() { | ||
var args = arguments, | ||
key = resolver ? resolver.apply(this, args) : args[0], | ||
cache = memoized.cache; | ||
if (cache.has(key)) { | ||
return cache.get(key); | ||
} | ||
var result = func.apply(this, args); | ||
memoized.cache = cache.set(key, result) || cache; | ||
return result; | ||
}; | ||
memoized.cache = new (memoize.Cache || _MapCache); | ||
return memoized; | ||
} | ||
// Expose `MapCache`. | ||
memoize.Cache = _MapCache; | ||
var memoize_1 = memoize; | ||
/** Used as the maximum memoize cache size. */ | ||
var MAX_MEMOIZE_SIZE = 500; | ||
/** | ||
* A specialized version of `_.memoize` which clears the memoized function's | ||
* cache when it exceeds `MAX_MEMOIZE_SIZE`. | ||
* | ||
* @private | ||
* @param {Function} func The function to have its output memoized. | ||
* @returns {Function} Returns the new memoized function. | ||
*/ | ||
function memoizeCapped(func) { | ||
var result = memoize_1(func, function(key) { | ||
if (cache.size === MAX_MEMOIZE_SIZE) { | ||
cache.clear(); | ||
} | ||
return key; | ||
}); | ||
var cache = result.cache; | ||
return result; | ||
} | ||
var _memoizeCapped = memoizeCapped; | ||
/** Used to match property names within property paths. */ | ||
var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; | ||
/** Used to match backslashes in property paths. */ | ||
var reEscapeChar = /\\(\\)?/g; | ||
/** | ||
* Converts `string` to a property path array. | ||
* | ||
* @private | ||
* @param {string} string The string to convert. | ||
* @returns {Array} Returns the property path array. | ||
*/ | ||
var stringToPath = _memoizeCapped(function(string) { | ||
var result = []; | ||
if (string.charCodeAt(0) === 46 /* . */) { | ||
result.push(''); | ||
} | ||
string.replace(rePropName, function(match, number, quote, subString) { | ||
result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); | ||
}); | ||
return result; | ||
}); | ||
var _stringToPath = stringToPath; | ||
/** | ||
* Casts `value` to a path array if it's not one. | ||
* | ||
* @private | ||
* @param {*} value The value to inspect. | ||
* @param {Object} [object] The object to query keys on. | ||
* @returns {Array} Returns the cast property path array. | ||
*/ | ||
function castPath(value, object) { | ||
if (isArray_1(value)) { | ||
return value; | ||
} | ||
return _isKey(value, object) ? [value] : _stringToPath(toString_1(value)); | ||
} | ||
var _castPath = castPath; | ||
/** Used as references for various `Number` constants. */ | ||
var INFINITY$1 = 1 / 0; | ||
/** | ||
* Converts `value` to a string key if it's not a string or symbol. | ||
* | ||
* @private | ||
* @param {*} value The value to inspect. | ||
* @returns {string|symbol} Returns the key. | ||
*/ | ||
function toKey(value) { | ||
if (typeof value == 'string' || isSymbol_1(value)) { | ||
return value; | ||
} | ||
var result = (value + ''); | ||
return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result; | ||
} | ||
var _toKey = toKey; | ||
/** | ||
* The base implementation of `_.get` without support for default values. | ||
* | ||
* @private | ||
* @param {Object} object The object to query. | ||
* @param {Array|string} path The path of the property to get. | ||
* @returns {*} Returns the resolved value. | ||
*/ | ||
function baseGet(object, path) { | ||
path = _castPath(path, object); | ||
var index = 0, | ||
length = path.length; | ||
while (object != null && index < length) { | ||
object = object[_toKey(path[index++])]; | ||
} | ||
return (index && index == length) ? object : undefined; | ||
} | ||
var _baseGet = baseGet; | ||
/** | ||
* Gets the value at `path` of `object`. If the resolved value is | ||
* `undefined`, the `defaultValue` is returned in its place. | ||
* | ||
* @static | ||
* @memberOf _ | ||
* @since 3.7.0 | ||
* @category Object | ||
* @param {Object} object The object to query. | ||
* @param {Array|string} path The path of the property to get. | ||
* @param {*} [defaultValue] The value returned for `undefined` resolved values. | ||
* @returns {*} Returns the resolved value. | ||
* @example | ||
* | ||
* var object = { 'a': [{ 'b': { 'c': 3 } }] }; | ||
* | ||
* _.get(object, 'a[0].b.c'); | ||
* // => 3 | ||
* | ||
* _.get(object, ['a', '0', 'b', 'c']); | ||
* // => 3 | ||
* | ||
* _.get(object, 'a.b.c', 'default'); | ||
* // => 'default' | ||
*/ | ||
function get(object, path, defaultValue) { | ||
var result = object == null ? undefined : _baseGet(object, path); | ||
return result === undefined ? defaultValue : result; | ||
} | ||
var get_1 = get; | ||
const routeChildren = function (route) { | ||
@@ -1614,11 +393,7 @@ const hasChildWithEmptyPath = route.children.some(child => child.path === ''); | ||
if (route.children) { | ||
const indexRoutePath = trailingSlash === false ? '/' : ''; | ||
const defaultChildRoute = route.children.find(child => child.path === indexRoutePath); | ||
const defaultChildRoute = route.children.find(child => child.path === '/' || child.path === ''); | ||
const routeName = route.name; | ||
if (defaultChildRoute) { | ||
if (trailingSlash === false) { | ||
defaultChildRoute.name = route.name; | ||
} | ||
route.children.forEach((child) => { | ||
if (child.path !== indexRoutePath) { | ||
if (child.path !== defaultChildRoute.path) { | ||
const parts = child.path.split('/'); | ||
@@ -1744,3 +519,7 @@ parts[1] = parts[1].endsWith('?') ? parts[1].substr(0, parts[1].length - 1) : parts[1]; | ||
route.pathToRegexpOptions = { ...route.pathToRegexpOptions, strict: true }; | ||
route.path = route.path.replace(/\/+$/, '') + (trailingSlash ? '/' : '') || '/'; | ||
if (trailingSlash && !route.path.endsWith('*')) { | ||
route.path = ufo.withTrailingSlash(route.path); | ||
} else { | ||
route.path = ufo.withoutTrailingSlash(route.path); | ||
} | ||
} | ||
@@ -1757,4 +536,4 @@ | ||
const guardDir = function guardDir (options, key1, key2) { | ||
const dir1 = get_1(options, key1, false); | ||
const dir2 = get_1(options, key2, false); | ||
const dir1 = lodash.get(options, key1, false); | ||
const dir2 = lodash.get(options, key2, false); | ||
@@ -1860,3 +639,3 @@ if ( | ||
}) | ||
.replace(`${func.name || 'function'}(`, 'function (') | ||
.replace(new RegExp(`${(func.name || 'function').replace('$', '\\$')}\\s*\\(`), 'function(') | ||
.replace('function function', 'function') | ||
@@ -1975,2 +754,12 @@ } | ||
const createRequire = (filename, useJiti = global.__NUXT_DEV__) => { | ||
if (useJiti && typeof jest === 'undefined') { | ||
return jiti__default['default'](filename) | ||
} | ||
return _createRequire__default['default'](filename) | ||
}; | ||
const _require = createRequire(); | ||
function isHMRCompatible (id) { | ||
@@ -1992,3 +781,3 @@ return !/[/\\]mongoose[/\\/]/.test(id) | ||
if (!entry) { | ||
delete require.cache[id]; | ||
delete _require.cache[id]; | ||
return | ||
@@ -2002,3 +791,3 @@ } | ||
// Needs to be cleared before children, to protect against circular deps (#7966) | ||
delete require.cache[id]; | ||
delete _require.cache[id]; | ||
@@ -2033,3 +822,3 @@ for (const child of entry.children) { | ||
try { | ||
return require.cache[id] | ||
return _require.cache[id] | ||
} catch (e) { | ||
@@ -2039,13 +828,27 @@ } | ||
function tryRequire (id) { | ||
try { | ||
return require(id) | ||
} catch (e) { | ||
function resolveModule (id, paths) { | ||
if (typeof paths === 'string') { | ||
paths = [paths]; | ||
} | ||
return _require.resolve(id, { | ||
paths: [].concat(paths || [], global.__NUXT_PATHS__ || [], process.cwd()) | ||
}) | ||
} | ||
function getPKG (id) { | ||
return tryRequire(path.join(id, 'package.json')) | ||
function requireModule (id, paths) { | ||
return _require(resolveModule(id, paths)) | ||
} | ||
function tryRequire (id, paths) { | ||
try { return requireModule(id, paths) } catch (e) { } | ||
} | ||
function tryResolve (id, paths) { | ||
try { return resolveModule(id, paths) } catch (e) { } | ||
} | ||
function getPKG (id, paths) { | ||
return tryRequire(path.join(id, 'package.json'), paths) | ||
} | ||
const ModernBrowsers = { | ||
@@ -2065,3 +868,2 @@ Edge: '16', | ||
let semver; | ||
let __modernBrowsers; | ||
@@ -2076,3 +878,3 @@ | ||
.reduce((allBrowsers, browser) => { | ||
allBrowsers[browser] = semver.coerce(ModernBrowsers[browser]); | ||
allBrowsers[browser] = semver__default['default'].coerce(ModernBrowsers[browser]); | ||
return allBrowsers | ||
@@ -2087,7 +889,4 @@ }, {}); | ||
} | ||
if (!semver) { | ||
semver = require('semver'); | ||
} | ||
const { browser } = UAParser__default['default'](ua); | ||
const browserVersion = semver.coerce(browser.version); | ||
const browserVersion = semver__default['default'].coerce(browser.version); | ||
if (!browserVersion) { | ||
@@ -2097,3 +896,3 @@ return false | ||
const modernBrowsers = getModernBrowsers(); | ||
return Boolean(modernBrowsers[browser.name] && semver.gte(browserVersion, modernBrowsers[browser.name])) | ||
return Boolean(modernBrowsers[browser.name] && semver__default['default'].gte(browserVersion, modernBrowsers[browser.name])) | ||
}; | ||
@@ -2125,2 +924,3 @@ | ||
exports.createLockPath = createLockPath; | ||
exports.createRequire = createRequire; | ||
exports.createRoutes = createRoutes; | ||
@@ -2157,2 +957,4 @@ exports.defaultLockOptions = defaultLockOptions; | ||
exports.relativeTo = relativeTo; | ||
exports.requireModule = requireModule; | ||
exports.resolveModule = resolveModule; | ||
exports.safariNoModuleFix = safariNoModuleFix; | ||
@@ -2169,2 +971,3 @@ exports.scanRequireTree = scanRequireTree; | ||
exports.tryRequire = tryRequire; | ||
exports.tryResolve = tryResolve; | ||
exports.urlJoin = urlJoin; | ||
@@ -2171,0 +974,0 @@ exports.wChunk = wChunk; |
{ | ||
"name": "@nuxt/utils", | ||
"version": "2.14.12", | ||
"version": "2.15.0", | ||
"repository": "nuxt/nuxt.js", | ||
@@ -11,11 +11,14 @@ "license": "MIT", | ||
"dependencies": { | ||
"@nuxt/ufo": "^0.5.0", | ||
"consola": "^2.15.0", | ||
"fs-extra": "^8.1.0", | ||
"consola": "^2.15.3", | ||
"create-require": "^1.1.1", | ||
"fs-extra": "^9.1.0", | ||
"hash-sum": "^2.0.0", | ||
"proper-lockfile": "^4.1.1", | ||
"semver": "^7.3.2", | ||
"jiti": "^1.3.0", | ||
"lodash": "^4.17.20", | ||
"proper-lockfile": "^4.1.2", | ||
"semver": "^7.3.4", | ||
"serialize-javascript": "^5.0.1", | ||
"signal-exit": "^3.0.3", | ||
"ua-parser-js": "^0.7.22" | ||
"ua-parser-js": "^0.7.24", | ||
"ufo": "^0.6.6" | ||
}, | ||
@@ -22,0 +25,0 @@ "publishConfig": { |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Dynamic require
Supply chain riskDynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Uses eval
Supply chain riskPackage uses eval() which is a dangerous function. This prevents the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.
Found 1 instance in 1 package
Dynamic require
Supply chain riskDynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.
Found 1 instance in 1 package
3
1
28106
12
818
+ Addedcreate-require@^1.1.1
+ Addedjiti@^1.3.0
+ Addedlodash@^4.17.20
+ Addedufo@^0.6.6
+ Addedat-least-node@1.0.0(transitive)
+ Addedcreate-require@1.1.1(transitive)
+ Addedfs-extra@9.1.0(transitive)
+ Addedjiti@1.21.6(transitive)
+ Addedjsonfile@6.1.0(transitive)
+ Addedlodash@4.17.21(transitive)
+ Addedufo@0.6.12(transitive)
+ Addeduniversalify@2.0.1(transitive)
- Removed@nuxt/ufo@^0.5.0
- Removed@nuxt/ufo@0.5.4(transitive)
- Removedfs-extra@8.1.0(transitive)
- Removedjsonfile@4.0.0(transitive)
- Removeduniversalify@0.1.2(transitive)
Updatedconsola@^2.15.3
Updatedfs-extra@^9.1.0
Updatedproper-lockfile@^4.1.2
Updatedsemver@^7.3.4
Updatedua-parser-js@^0.7.24