diff --git a/dist/math-sign-x.js b/dist/math-sign-x.js index f437810..0161b17 100644 --- a/dist/math-sign-x.js +++ b/dist/math-sign-x.js @@ -2,13 +2,13 @@ { "author": "Graham Fairweather", "copywrite": "Copyright (c) 2017", - "date": "2019-08-20T13:04:04.195Z", + "date": "2019-08-20T19:18:30.346Z", "describe": "", "description": "Shim for Math.sign.", "file": "math-sign-x.js", - "hash": "3aa199160dbee65690ae", + "hash": "1336900c573015cf8b48", "license": "MIT", - "version": "4.2.0" + "version": "4.2.1" } */ (function webpackUniversalModuleDefinition(root, factory) { @@ -199,20 +199,25 @@ if (hasSymbols) { /***/ (function(module, exports, __webpack_require__) { "use strict"; -/*! - * is-primitive - * - * Copyright (c) 2014-present, Jon Schlinkert. - * Released under the MIT License. - */ +var strValue = String.prototype.valueOf; +var tryStringObject = function tryStringObject(value) { + try { + strValue.call(value); + return true; + } catch (e) { + return false; + } +}; +var toStr = Object.prototype.toString; +var strClass = '[object String]'; +var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; -module.exports = function isPrimitive(val) { - if (typeof val === 'object') { - return val === null; - } - return typeof val !== 'function'; +module.exports = function isString(value) { + if (typeof value === 'string') { return true; } + if (typeof value !== 'object') { return false; } + return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass; }; @@ -350,27 +355,386 @@ __webpack_require__.r(__webpack_exports__); var is_symbol = __webpack_require__(0); var is_symbol_default = /*#__PURE__*/__webpack_require__.n(is_symbol); +// CONCATENATED MODULE: ./node_modules/is-primitive-x/dist/is-primitive-x.esm.js +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +/** + * Returns true if the value is a primitive. + * + * @param {*} [val] - The value to test. + * @returns {boolean} True if a primitive, otherwise false.. + */ +var isPrimitive = function isPrimitive(val) { + return _typeof(val) === 'object' ? val === null : typeof val !== 'function'; +}; + +/* harmony default export */ var is_primitive_x_esm = (isPrimitive); + + +// EXTERNAL MODULE: ./node_modules/is-string/index.js +var is_string = __webpack_require__(1); +var is_string_default = /*#__PURE__*/__webpack_require__.n(is_string); + +// CONCATENATED MODULE: ./node_modules/has-boxed-string-x/dist/has-boxed-string-x.esm.js +var has_boxed_string_x_esm_string = 'a'; +var boxedString = {}.constructor(has_boxed_string_x_esm_string); +/** + * Check failure of by-index access of string characters (IE < 9) + * and failure of `0 in boxedString` (Rhino). + * + * `true` if no failure; otherwise `false`. + * + * @type boolean + */ + +var hasBoxed = boxedString[0] === has_boxed_string_x_esm_string && 0 in boxedString; +/* harmony default export */ var has_boxed_string_x_esm = (hasBoxed); + + +// CONCATENATED MODULE: ./node_modules/noop-x/dist/noop-x.esm.js +/** + * This method returns undefined. + * + * @returns {undefined} Always undefined. + */ +var noop = function noop() {}; +/* eslint-disable-line lodash/prefer-noop */ + + +/* harmony default export */ var noop_x_esm = (noop); + + +// CONCATENATED MODULE: ./node_modules/has-working-bind-x/dist/has-working-bind-x.esm.js + +var has_working_bind_x_esm_bind = noop_x_esm.bind; + +var test1 = function test1() { + var a1 = null; + var a2 = null; + var context = null; + var testThis = []; + + var test1Fn = function test1Fn(arg1, arg2) { + /* eslint-disable-next-line babel/no-invalid-this */ + context = this; + a1 = arg1; + a2 = arg2; + /* eslint-disable-next-line prefer-rest-params */ + + return arguments; + }; + + try { + var boundFn = has_working_bind_x_esm_bind.apply(test1Fn, [testThis, 1]); + var args = boundFn(2); + return boundFn.length === 1 && args.length === 2 && a1 === 1 && a2 === 2 && context === testThis; + } catch (e) { + return false; + } +}; + +var test2 = function test2() { + var a1 = null; + var a2 = null; + var context = null; + var oracle = [1, 2, 3]; + + var Ctr = function Ctr(arg1, arg2) { + a1 = arg1; + a2 = arg2; + context = this; + return oracle; + }; + + try { + var BoundFn = has_working_bind_x_esm_bind.apply(Ctr, [null]); + var returned = new BoundFn(1, 2); + return BoundFn.length === Ctr.length && returned === oracle && a1 === 1 && a2 === 2 && context !== oracle; + } catch (e) { + return false; + } +}; +/** + * Indicates if the engine has a working bind function. + * + * @type {boolean} + */ + + +var isWorking = typeof has_working_bind_x_esm_bind === 'function' && test1() && test2(); +/* harmony default export */ var has_working_bind_x_esm = (isWorking); + + +// CONCATENATED MODULE: ./node_modules/util-pusher-x/dist/util-pusher-x.esm.js + + + + +var EMPTY_STRING = ''; +var split = EMPTY_STRING.split; +var max = Math.max; +var util_pusher_x_esm_bind = is_primitive_x_esm.bind, + util_pusher_x_esm_call = is_primitive_x_esm.call; +var stringSplit = function stringSplit(string, pattern) { + // noinspection JSUnresolvedFunction + return split.call(string, pattern); +}; +var $split = has_working_bind_x_esm ? util_pusher_x_esm_bind.call(util_pusher_x_esm_call, split) : stringSplit; +var util_pusher_x_esm_getIterable = function getIterable(arrayLike) { + // noinspection JSUnresolvedFunction + return is_string_default()(arrayLike) ? $split(arrayLike, EMPTY_STRING) : arrayLike; +}; // eslint-disable jsdoc/no-undefined-types +// noinspection JSCommentMatchesSignature + +/** + * This pushes or concatenates into a new or existing array. + * + * @param {Array} arrayLike - The source. + * @param {number} [from=0] - The from source index. + * @param {Array} [target=[]] - The target array. + * @returns {*} The target array. + */ +// eslint-enable jsdoc/no-undefined-types + +var util_pusher_x_esm_pusher = function pusher(arrayLike, from) { + /* eslint-disable-next-line prefer-rest-params */ + var target = arguments.length > 2 ? arguments[2] : []; + + if (typeof arrayLike !== 'string' && is_primitive_x_esm(arrayLike)) { + return target; + } + + var iterable = has_boxed_string_x_esm ? arrayLike : util_pusher_x_esm_getIterable(arrayLike); + var length = iterable.length; + + for (var i = max(0, from) || 0; i < length; i += 1) { + target[target.length] = arrayLike[i]; + } + + return target; +}; + +/* harmony default export */ var util_pusher_x_esm = (util_pusher_x_esm_pusher); + + +// CONCATENATED MODULE: ./node_modules/simple-bind-x/dist/simple-bind-x.esm.js +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + + + +var nativeBind = util_pusher_x_esm.bind, + simple_bind_x_esm_call = util_pusher_x_esm.call; +var ERROR_MESSAGE = 'bind called on incompatible '; +var simple_bind_x_esm_object = {}; +var ObjectCtr = simple_bind_x_esm_object.constructor; +var toStringTag = simple_bind_x_esm_object.toString; +var funcType = '[object Function]'; +var ZERO = 0; +var argsOffset = 2; + +var getMax = function getMax(a, b) { + return a >= b ? a : b; +}; + +var simple_bind_x_esm_assertIsFunction = function assertIsFunction(value) { + if (typeof value !== 'function' && toStringTag.apply(value) !== funcType) { + throw new TypeError(ERROR_MESSAGE + value); + } +}; + +var boundFns = [function zero(binder) { + return function boundFn() { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments)); + }; +}, function one(binder, boundLength) { + return function boundFn(a) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a])); + }; +}, function two(binder, boundLength) { + return function boundFn(a, b) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b])); + }; +}, function three(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c])); + }; +}, function four(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c, d) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c, d])); + }; +}, function five(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c, d, e) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c, d, e])); + }; +}, function six(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c, d, e, f) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c, d, e, f])); + }; +}, function seven(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c, d, e, f, g) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c, d, e, f, g])); + }; +}, function eight(binder, boundLength) { + /* eslint-disable-next-line max-params */ + return function boundFn(a, b, c, d, e, f, g, h) { + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + return binder.apply(this, util_pusher_x_esm(arguments, boundLength, [a, b, c, d, e, f, g, h])); + }; +}]; + +var getBoundFn = function getBoundFn(args) { + var _args = _slicedToArray(args, 3), + binder = _args[0], + target = _args[1], + bindArgs = _args[2]; + + var boundLength = getMax(ZERO, target.length - getMax(ZERO, bindArgs.length - argsOffset)); + var fn = boundFns[boundLength]; + var boundFn = fn ? fn(binder, boundLength) : boundFns[ZERO](binder); + + if (target.prototype) { + /* eslint-disable-next-line lodash/prefer-noop */ + var Empty = function Empty() {}; + + Empty.prototype = target.prototype; + boundFn.prototype = new Empty(); + Empty.prototype = null; + } + + return boundFn; +}; + +var getResult = function getResult(target, boundArgs) { + /* eslint-disable-next-line babel/no-invalid-this */ + var result = target.apply(this, boundArgs); + /* eslint-disable-next-line babel/no-invalid-this,babel/new-cap */ + + return ObjectCtr(result) === result ? result : this; +}; + +var implementation = function bind(target, thisArg) { + simple_bind_x_esm_assertIsFunction(target); + /* eslint-disable-next-line prefer-rest-params */ + + var bindArgs = arguments; + var bound; + + var binder = function binder() { + /* eslint-disable-next-line prefer-rest-params */ + var boundArgs = util_pusher_x_esm(arguments, ZERO, util_pusher_x_esm(bindArgs, argsOffset)); + /* eslint-disable-next-line babel/no-invalid-this */ + + return this instanceof bound ? getResult.apply(this, [target, boundArgs]) : target.apply(thisArg, boundArgs); + }; + + bound = getBoundFn([binder, target, bindArgs]); + return bound; +}; +/** + * The bind() method creates a new function that, when called, has its this + * keyword set to the provided value, with a given sequence of arguments + * preceding any provided when the new function is called. + * + * @function bind + * @param {Function} target - The target function. + * @param {*} [thisArg] - The value to be passed as the this parameter to the target + * function when the bound function is called. The value is ignored if the + * bound function is constructed using the new operator. + * @param {...*} [args] - Arguments to prepend to arguments provided to the bound + * function when invoking the target function. + * @throws {TypeError} If target is not a function. + * @returns {Function} The bound function. + */ + +var $bind = has_working_bind_x_esm ? simple_bind_x_esm_call.bind(nativeBind) : implementation; +/* harmony default export */ var simple_bind_x_esm = ($bind); + + +// CONCATENATED MODULE: ./node_modules/simple-call-x/dist/simple-call-x.esm.js + + +var $TypeError = TypeError; +var nativeApply = simple_bind_x_esm.apply, + nativeCall = simple_bind_x_esm.call; +var $apply = simple_bind_x_esm(nativeCall, nativeApply); +var simple_call_x_esm_toStringTag = simple_bind_x_esm(nativeApply, {}.toString); +var simple_call_x_esm_ERROR_MESSAGE = ' is not a function'; +var simple_call_x_esm_funcType = '[object Function]'; + +var simple_call_x_esm_assertIsFunction = function assertIsFunction(value) { + if (typeof value !== 'function' && simple_call_x_esm_toStringTag(value) !== simple_call_x_esm_funcType) { + throw new $TypeError(value + simple_call_x_esm_ERROR_MESSAGE); + } + + return value; +}; // eslint-disable jsdoc/check-param-names +// noinspection JSCommentMatchesSignature + +/** + * The abstract operation Call is used to call the [[Call]] internal method of a function object. + * + * @function call + * @param {Function} F - The target function. + * @param {*} [V] - The context. + * @param {Array} [args] - Argument to call the function with. + * @throws {TypeError} If target is not a function. + * @returns {*} The the result of invoking the function. + * @see https://www.ecma-international.org/ecma-262/6.0/#sec-call + */ +// eslint-enable jsdoc/check-param-names + + +var simple_call_x_esm_call = function call(F, V) { + /* eslint-disable-next-line prefer-rest-params */ + return $apply(simple_call_x_esm_assertIsFunction(F), V, util_pusher_x_esm(arguments[2])); +}; + +/* harmony default export */ var simple_call_x_esm = (simple_call_x_esm_call); + + // CONCATENATED MODULE: ./node_modules/attempt-x/dist/attempt-x.esm.js + + // eslint-disable jsdoc/check-param-names +// noinspection JSCommentMatchesSignature + /** * This method attempts to invoke the function, returning either the result or * the caught error object. Any additional arguments are provided to the * function when it's invoked. * + * @function attempt * @param {Function} [fn] - The function to attempt. * @param {...*} [args] - The arguments to invoke the function with. * @returns {object} Returns an object of the result. */ -var attempt = function attempt(fn) { - try { - for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - args[_key - 1] = arguments[_key]; - } +// eslint-disable jsdoc/check-param-names +var attempt_x_esm_attempt = function attempt(fn) { + try { return { threw: false, - /* eslint-disable-next-line babel/no-invalid-this */ - value: fn.apply(this, args) + /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */ + value: simple_call_x_esm(fn, this, util_pusher_x_esm(arguments, 1)) }; } catch (e) { return { @@ -380,7 +744,7 @@ var attempt = function attempt(fn) { } }; -/* harmony default export */ var attempt_x_esm = (attempt); +/* harmony default export */ var attempt_x_esm = (attempt_x_esm_attempt); // CONCATENATED MODULE: ./node_modules/has-symbol-support-x/dist/has-symbol-support-x.esm.js @@ -406,10 +770,6 @@ var hasSymbolSupport = attempt_x_esm(function () { /* harmony default export */ var has_symbol_support_x_esm = (hasSymbolSupport.threw === false && hasSymbolSupport.value === true); -// EXTERNAL MODULE: ./node_modules/is-primitive/index.js -var is_primitive = __webpack_require__(1); -var is_primitive_default = /*#__PURE__*/__webpack_require__.n(is_primitive); - // EXTERNAL MODULE: ./node_modules/is-date-object/index.js var is_date_object = __webpack_require__(2); var is_date_object_default = /*#__PURE__*/__webpack_require__.n(is_date_object); @@ -428,8 +788,43 @@ var toBoolean = function toBoolean(value) { /* harmony default export */ var to_boolean_x_esm = (toBoolean); +// CONCATENATED MODULE: ./node_modules/simple-methodize-x/dist/simple-methodize-x.esm.js + + +var simple_methodize_x_esm_toStringTag = {}.toString; +var simple_methodize_x_esm_ERROR_MESSAGE = 'methodize called on incompatible '; +var simple_methodize_x_esm_funcType = '[object Function]'; + +var simple_methodize_x_esm_assertIsFunction = function assertIsFunction(value) { + if (typeof value !== 'function' && simple_call_x_esm(simple_methodize_x_esm_toStringTag, value) !== simple_methodize_x_esm_funcType) { + throw new TypeError(simple_methodize_x_esm_ERROR_MESSAGE + value); + } + + return value; +}; +/** + * Methodize a prototype method. Compliant to 8 arguments. + * + * @param {Function} prototypeMethod - The prototype method to methodize. + * @throws {TypeError} If target is not a function. + * @returns {Function} The static method. + */ + + +var simple_methodize_x_esm_methodize = function methodize(prototypeMethod) { + simple_methodize_x_esm_assertIsFunction(prototypeMethod); + return function methodized() { + /* eslint-disable-next-line prefer-rest-params */ + return simple_call_x_esm(prototypeMethod, arguments[0], util_pusher_x_esm(arguments, 1)); + }; +}; + +/* harmony default export */ var simple_methodize_x_esm = (simple_methodize_x_esm_methodize); + + // CONCATENATED MODULE: ./node_modules/to-string-tag-x/dist/to-string-tag-x.esm.js -var nativeObjectToString = {}.toString; + +var methodizedToString = simple_methodize_x_esm({}.toString); /** * The `toStringTag` method returns "[object type]", where type is the * object type. @@ -438,7 +833,7 @@ var nativeObjectToString = {}.toString; * @returns {string} The object type string. */ -var toStringTag = function toStringTag(value) { +var to_string_tag_x_esm_toStringTag = function toStringTag(value) { if (value === null) { return '[object Null]'; } @@ -447,10 +842,10 @@ var toStringTag = function toStringTag(value) { return '[object Undefined]'; } - return nativeObjectToString.call(value); + return methodizedToString(value); }; -/* harmony default export */ var to_string_tag_x_esm = (toStringTag); +/* harmony default export */ var to_string_tag_x_esm = (to_string_tag_x_esm_toStringTag); // CONCATENATED MODULE: ./node_modules/has-to-string-tag-x/dist/has-to-string-tag-x.esm.js @@ -507,8 +902,8 @@ var require_object_coercible_x_esm_requireObjectCoercible = function requireObje // CONCATENATED MODULE: ./node_modules/to-string-x/dist/to-string-x.esm.js -var ERROR_MESSAGE = 'Cannot convert a Symbol value to a string'; -var castString = ERROR_MESSAGE.constructor; +var to_string_x_esm_ERROR_MESSAGE = 'Cannot convert a Symbol value to a string'; +var castString = to_string_x_esm_ERROR_MESSAGE.constructor; /** * The abstract operation ToString converts argument to a value of type String. * @@ -519,7 +914,7 @@ var castString = ERROR_MESSAGE.constructor; var to_string_x_esm_ToString = function ToString(value) { if (is_symbol_default()(value)) { - throw new TypeError(ERROR_MESSAGE); + throw new TypeError(to_string_x_esm_ERROR_MESSAGE); } return castString(value); @@ -862,10 +1257,11 @@ var string2016 = stringES2016; // CONCATENATED MODULE: ./node_modules/trim-left-x/dist/trim-left-x.esm.js -var EMPTY_STRING = ''; + +var trim_left_x_esm_EMPTY_STRING = ''; var RegExpCtr = /none/.constructor; var reLeft = new RegExpCtr("^[".concat(white_space_x_esm, "]+")); -var replace = EMPTY_STRING.replace; +var methodizedReplace = simple_methodize_x_esm(trim_left_x_esm_EMPTY_STRING.replace); /** * This method removes whitespace from the start of a string. (ES2019). * @@ -875,7 +1271,7 @@ var replace = EMPTY_STRING.replace; */ var trim_left_x_esm_trimStart = function trimStart(string) { - return replace.call(require_coercible_to_string_x_esm(string), reLeft, EMPTY_STRING); + return methodizedReplace(require_coercible_to_string_x_esm(string), reLeft, trim_left_x_esm_EMPTY_STRING); }; /* harmony default export */ var trim_left_x_esm = (trim_left_x_esm_trimStart); @@ -884,10 +1280,11 @@ var trim_left_x_esm_trimStart = function trimStart(string) { // CONCATENATED MODULE: ./node_modules/trim-right-x/dist/trim-right-x.esm.js + var trim_right_x_esm_EMPTY_STRING = ''; var trim_right_x_esm_RegExpCtr = /none/.constructor; -var reRight2018 = new trim_right_x_esm_RegExpCtr("[".concat(white_space_x_esm, "]+$")); -var trim_right_x_esm_replace = trim_right_x_esm_EMPTY_STRING.replace; +var reRight = new trim_right_x_esm_RegExpCtr("[".concat(white_space_x_esm, "]+$")); +var trim_right_x_esm_methodizedReplace = simple_methodize_x_esm(trim_right_x_esm_EMPTY_STRING.replace); /** * This method removes whitespace from the end of a string. (ES2019). * @@ -897,7 +1294,7 @@ var trim_right_x_esm_replace = trim_right_x_esm_EMPTY_STRING.replace; */ var trim_right_x_esm_trimEnd = function trimEnd(string) { - return trim_right_x_esm_replace.call(require_coercible_to_string_x_esm(string), reRight2018, trim_right_x_esm_EMPTY_STRING); + return trim_right_x_esm_methodizedReplace(require_coercible_to_string_x_esm(string), reRight, trim_right_x_esm_EMPTY_STRING); }; /* harmony default export */ var trim_right_x_esm = (trim_right_x_esm_trimEnd); @@ -925,10 +1322,11 @@ var trim_x_esm_trim = function trim(string) { // CONCATENATED MODULE: ./node_modules/normalize-space-x/dist/normalize-space-x.esm.js + var SPACE = ' '; var normalize_space_x_esm_RegExpCtr = /none/.constructor; -var reNormalize2018 = new normalize_space_x_esm_RegExpCtr("[".concat(white_space_x_esm, "]+"), 'g'); -var normalize_space_x_esm_replace = SPACE.replace; +var reNormalize = new normalize_space_x_esm_RegExpCtr("[".concat(white_space_x_esm, "]+"), 'g'); +var normalize_space_x_esm_methodizedReplace = simple_methodize_x_esm(SPACE.replace); /** * This method strips leading and trailing white-space from a string, * replaces sequences of whitespace characters by a single space, @@ -939,7 +1337,7 @@ var normalize_space_x_esm_replace = SPACE.replace; */ var normalize_space_x_esm_normalizeSpace = function normalizeSpace(string) { - return normalize_space_x_esm_replace.call(trim_x_esm(string), reNormalize2018, SPACE); + return normalize_space_x_esm_methodizedReplace(trim_x_esm(string), reNormalize, SPACE); }; /* harmony default export */ var normalize_space_x_esm = (normalize_space_x_esm_normalizeSpace); @@ -948,9 +1346,10 @@ var normalize_space_x_esm_normalizeSpace = function normalizeSpace(string) { // CONCATENATED MODULE: ./node_modules/replace-comments-x/dist/replace-comments-x.esm.js + var replace_comments_x_esm_EMPTY_STRING = ''; var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm; -var replace_comments_x_esm_replace = replace_comments_x_esm_EMPTY_STRING.replace; +var replace_comments_x_esm_methodizedReplace = simple_methodize_x_esm(replace_comments_x_esm_EMPTY_STRING.replace); /** * This method replaces comments in a string. * @@ -962,7 +1361,7 @@ var replace_comments_x_esm_replace = replace_comments_x_esm_EMPTY_STRING.replace */ var replace_comments_x_esm_replaceComments = function replaceComments(string, replacement) { - return replace_comments_x_esm_replace.call(require_coercible_to_string_x_esm(string), STRIP_COMMENTS, arguments.length > 1 ? to_string_x_esm(replacement) : replace_comments_x_esm_EMPTY_STRING); + return replace_comments_x_esm_methodizedReplace(require_coercible_to_string_x_esm(string), STRIP_COMMENTS, arguments.length > 1 ? to_string_x_esm(replacement) : replace_comments_x_esm_EMPTY_STRING); }; /* harmony default export */ var replace_comments_x_esm = (replace_comments_x_esm_replaceComments); @@ -976,21 +1375,22 @@ var replace_comments_x_esm_replaceComments = function replaceComments(string, re + var FunctionCtr = attempt_x_esm.constructor; var is_function_x_esm_SPACE = ' '; -var fToString = attempt_x_esm.toString; +var methodizedFunctionToString = simple_methodize_x_esm(attempt_x_esm.toString); var funcTag = '[object Function]'; var genTag = '[object GeneratorFunction]'; var asyncTag = '[object AsyncFunction]'; var ctrRx = /^class /; -var test = ctrRx.test; +var methodizedTest = simple_methodize_x_esm(ctrRx.test); var hasNativeClass = attempt_x_esm(function attemptee() { /* eslint-disable-next-line babel/new-cap */ return FunctionCtr('"use strict"; return class My {};')(); }).threw === false; var is_function_x_esm_testClassString = function testClassString(value) { - return test.call(ctrRx, normalize_space_x_esm(replace_comments_x_esm(fToString.call(value), is_function_x_esm_SPACE))); + return methodizedTest(ctrRx, normalize_space_x_esm(replace_comments_x_esm(methodizedFunctionToString(value), is_function_x_esm_SPACE))); }; var isES6ClassFn = function isES6ClassFunc(value) { @@ -1013,7 +1413,9 @@ var tryFuncToString = function funcToString(value, allowClass) { return false; } - return attempt_x_esm.call(value, fToString).threw === false; + return attempt_x_esm(function attemptee() { + return methodizedFunctionToString(value); + }).threw === false; }; var is_function_x_esm_compareTags = function compareTags(value) { @@ -1031,7 +1433,7 @@ var is_function_x_esm_compareTags = function compareTags(value) { var is_function_x_esm_isFunction = function isFunction(value, allowClass) { - if (is_primitive_default()(value)) { + if (is_primitive_x_esm(value)) { return false; } @@ -1057,16 +1459,17 @@ var is_function_x_esm_isFunction = function isFunction(value, allowClass) { -var ZERO = 0; + +var to_primitive_x_esm_ZERO = 0; var ONE = 1; /* eslint-disable-next-line no-void */ -var UNDEFINED = void ZERO; +var UNDEFINED = void to_primitive_x_esm_ZERO; var NUMBER = 'number'; var STRING = 'string'; var DEFAULT = 'default'; var StringCtr = STRING.constructor; -var NumberCtr = ZERO.constructor; +var NumberCtr = to_primitive_x_esm_ZERO.constructor; /* eslint-disable-next-line compat/compat */ var symToPrimitive = has_symbol_support_x_esm && Symbol.toPrimitive; @@ -1095,16 +1498,14 @@ var to_primitive_x_esm_ordinaryToPrimitive = function ordinaryToPrimitive(ordina require_object_coercible_x_esm(ordinary); assertHint(hint); var methodNames = hint === STRING ? toStringOrder : toNumberOrder; - var method; - var result; - for (var i = ZERO; i < orderLength; i += ONE) { - method = ordinary[methodNames[i]]; + for (var i = to_primitive_x_esm_ZERO; i < orderLength; i += ONE) { + var method = ordinary[methodNames[i]]; if (is_function_x_esm(method)) { - result = method.call(ordinary); + var result = simple_call_x_esm(method, ordinary); - if (is_primitive_default()(result)) { + if (is_primitive_x_esm(result)) { return result; } } @@ -1180,9 +1581,9 @@ var to_primitive_x_esm_evalExotic = function evalExotic(obj) { var exoticToPrim = obj.exoticToPrim, input = obj.input, hint = obj.hint; - var result = exoticToPrim.call(input, hint); + var result = simple_call_x_esm(exoticToPrim, input, [hint]); - if (is_primitive_default()(result)) { + if (is_primitive_x_esm(result)) { return result; } @@ -1211,7 +1612,7 @@ var to_primitive_x_esm_evalPrimitive = function evalPrimitive(input, hint) { var to_primitive_x_esm_toPrimitive = function toPrimitive(input, preferredType) { - if (is_primitive_default()(input)) { + if (is_primitive_x_esm(input)) { return input; } @@ -1241,15 +1642,15 @@ var constantNAN = 0 / 0; + var nativeParseInt = parseInt; /** @type {Function} */ -var castNumber = 0 .constructor; // noinspection JSPotentiallyInvalidConstructorUsage - -var _ref = '', - charAt = _ref.charAt; +var castNumber = 0 .constructor; +var BAD_CHAR = "\u180E"; +var methodizedCharAt = simple_methodize_x_esm(BAD_CHAR.charAt); var hexRegex = /^[-+]?0[xX]/; -var parse_int_x_esm_test = hexRegex.test; +var parse_int_x_esm_methodizedTest = simple_methodize_x_esm(hexRegex.test); /** * This method parses a string argument and returns an integer of the specified * radix (the base in mathematical numeral systems). (ES2019). @@ -1271,11 +1672,11 @@ var parse_int_x_esm_test = hexRegex.test; var parse_int_x_esm_$parseInt = function $parseInt(string, radix) { var str = trim_left_x_esm(to_string_x_esm(string)); - if (charAt.call(str, 0) === "\u180E") { + if (methodizedCharAt(str, 0) === BAD_CHAR) { return nan_x_esm; } - return nativeParseInt(str, castNumber(radix) || (parse_int_x_esm_test.call(hexRegex, str) ? 16 : 10)); + return nativeParseInt(str, castNumber(radix) || (parse_int_x_esm_methodizedTest(hexRegex, str) ? 16 : 10)); }; /* harmony default export */ var parse_int_x_esm = (parse_int_x_esm_$parseInt); @@ -1287,38 +1688,39 @@ var parse_int_x_esm_$parseInt = function $parseInt(string, radix) { + var binaryRadix = 2; var octalRadix = 8; var testCharsCount = 2; var to_number_x_esm_ERROR_MESSAGE = 'Cannot convert a Symbol value to a number'; var to_number_x_esm_castNumber = testCharsCount.constructor; -var pStrSlice = to_number_x_esm_ERROR_MESSAGE.slice; +var methodizedStringSlice = simple_methodize_x_esm(to_number_x_esm_ERROR_MESSAGE.slice); var binaryRegex = /^0b[01]+$/i; var RegExpConstructor = binaryRegex.constructor; // Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, "test" is // an own property of regexes. wtf. -var to_number_x_esm_test = binaryRegex.test; +var to_number_x_esm_methodizedTest = simple_methodize_x_esm(binaryRegex.test); var isBinary = function isBinary(value) { - return to_number_x_esm_test.call(binaryRegex, value); + return to_number_x_esm_methodizedTest(binaryRegex, value); }; var octalRegex = /^0o[0-7]+$/i; var isOctal = function isOctal(value) { - return to_number_x_esm_test.call(octalRegex, value); + return to_number_x_esm_methodizedTest(octalRegex, value); }; var nonWSregex = new RegExpConstructor("[\x85\u180E\u200B\uFFFE]", 'g'); var hasNonWS = function hasNonWS(value) { - return to_number_x_esm_test.call(nonWSregex, value); + return to_number_x_esm_methodizedTest(nonWSregex, value); }; var invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i; var isInvalidHexLiteral = function isInvalidHexLiteral(value) { - return to_number_x_esm_test.call(invalidHexLiteral, value); + return to_number_x_esm_methodizedTest(invalidHexLiteral, value); }; var to_number_x_esm_assertNotSymbol = function assertNotSymbol(value) { @@ -1330,7 +1732,7 @@ var to_number_x_esm_assertNotSymbol = function assertNotSymbol(value) { }; var to_number_x_esm_parseBase = function parseBase(value, radix) { - return parse_int_x_esm(pStrSlice.call(value, testCharsCount), radix); + return parse_int_x_esm(methodizedStringSlice(value, testCharsCount), radix); }; var parseString = function parseString(toNum, value) { diff --git a/dist/math-sign-x.js.map b/dist/math-sign-x.js.map index cc29de8..19a516d 100644 --- a/dist/math-sign-x.js.map +++ b/dist/math-sign-x.js.map @@ -1 +1 @@ -{"version":3,"sources":["webpack://mathSignX/webpack/universalModuleDefinition","webpack://mathSignX/webpack/bootstrap","webpack://mathSignX/./node_modules/is-symbol/index.js","webpack://mathSignX/./node_modules/is-primitive/index.js","webpack://mathSignX/./node_modules/is-date-object/index.js","webpack://mathSignX/./node_modules/has-symbols/index.js","webpack://mathSignX/(webpack)/buildin/global.js","webpack://mathSignX/./node_modules/has-symbols/shams.js","webpack://mathSignX/../src/attempt-x.js","webpack://mathSignX/../src/has-symbol-support-x.js","webpack://mathSignX/../src/to-boolean-x.js","webpack://mathSignX/../src/to-string-tag-x.js","webpack://mathSignX/../src/has-to-string-tag-x.js","webpack://mathSignX/../src/is-nil-x.js","webpack://mathSignX/../src/require-object-coercible-x.js","webpack://mathSignX/../src/to-string-x.js","webpack://mathSignX/../src/require-coercible-to-string-x.js","webpack://mathSignX/../src/white-space-x.js","webpack://mathSignX/../src/trim-left-x.js","webpack://mathSignX/../src/trim-right-x.js","webpack://mathSignX/../src/trim-x.js","webpack://mathSignX/../src/normalize-space-x.js","webpack://mathSignX/../src/replace-comments-x.js","webpack://mathSignX/../src/is-function-x.js","webpack://mathSignX/../src/to-primitive-x.js","webpack://mathSignX/../src/nan-x.js","webpack://mathSignX/../src/parse-int-x.js","webpack://mathSignX/../src/to-number-x.js","webpack://mathSignX/../src/is-nan-x.js","webpack://mathSignX/../src/math-sign-x.js"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;;AAEA;;AAEA;;AAEA;AACA,GAAG;AACH;AACA;AACA,CAAC;AACD,O;QCvDA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;;AClFa;;AAEb;AACA,iBAAiB,mBAAO,CAAC,CAAa;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,SAAS,MAAK,IAAI,KAAK;AACvB;AACA;;;;;;;;AClCA;AACA;AACA;AACA;AACA;AACA;;AAEa;;AAEb;AACA;AACA;AACA;AACA;AACA;;;;;;;;ACda;;AAEb;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mDAAmD,cAAc;AACjE;AACA;;;;;;;;ACnBA,8CAAa;;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","file":"math-sign-x.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mathSignX\"] = factory();\n\telse\n\t\troot[\"mathSignX\"] = factory();\n})((function () {\n 'use strict';\n\n var ObjectCtr = {}.constructor;\n var objectPrototype = ObjectCtr.prototype;\n var defineProperty = ObjectCtr.defineProperty;\n var $globalThis;\n var getGlobalFallback = function() {\n if (typeof self !== 'undefined') {\n return self;\n }\n\n if (typeof window !== 'undefined') {\n return window;\n }\n\n if (typeof global !== 'undefined') {\n return global;\n }\n\n return void 0;\n };\n\n var returnThis = function() {\n return this;\n };\n\n try {\n if (defineProperty) {\n defineProperty(objectPrototype, '$$globalThis$$', {\n get: returnThis,\n configurable: true\n });\n } else {\n objectPrototype.__defineGetter__('$$globalThis$$', returnThis);\n }\n\n $globalThis = typeof $$globalThis$$ === 'undefined' ? getGlobalFallback() : $$globalThis$$;\n\n delete objectPrototype.$$globalThis$$;\n\n return $globalThis;\n } catch (error) {\n return getGlobalFallback();\n }\n}()), function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 6);\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n","/*!\n * is-primitive \n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n'use strict';\n\nmodule.exports = function isPrimitive(val) {\n if (typeof val === 'object') {\n return val === null;\n }\n return typeof val !== 'function';\n};\n","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateObject(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) { return false; }\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n","'use strict';\n\nvar origSymbol = global.Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict';\n\n/* eslint complexity: [2, 17], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","/**\n * This method attempts to invoke the function, returning either the result or\n * the caught error object. Any additional arguments are provided to the\n * function when it's invoked.\n *\n * @param {Function} [fn] - The function to attempt.\n * @param {...*} [args] - The arguments to invoke the function with.\n * @returns {object} Returns an object of the result.\n */\nconst attempt = function attempt(fn, ...args) {\n try {\n return {\n threw: false,\n /* eslint-disable-next-line babel/no-invalid-this */\n value: fn.apply(this, args),\n };\n } catch (e) {\n return {\n threw: true,\n value: e,\n };\n }\n};\n\nexport default attempt;\n","import attempt from 'attempt-x';\nimport isSymbol from 'is-symbol';\n\nconst hasSymbolSupport = attempt(() => {\n /* eslint-disable-next-line compat/compat */\n return typeof Symbol === 'function' && isSymbol(Symbol(''));\n});\n\n/**\n * Indicates if `Symbol`exists and creates the correct type.\n * `true`, if it exists and creates the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbolSupport.threw === false && hasSymbolSupport.value === true;\n","/**\n * The abstract operation ToBoolean converts argument to a value of type Boolean.\n *\n * @param {*} [value] - The value to be converted.\n * @returns {boolean} 'true' if value is truthy; otherwise 'false'.\n */\nconst toBoolean = function toBoolean(value) {\n return !!value;\n};\n\nexport default toBoolean;\n","const nativeObjectToString = {}.toString;\n\n/**\n * The `toStringTag` method returns \"[object type]\", where type is the\n * object type.\n *\n * @param {*} [value] - The object of which to get the object type string.\n * @returns {string} The object type string.\n */\nconst toStringTag = function toStringTag(value) {\n if (value === null) {\n return '[object Null]';\n }\n\n if (typeof value === 'undefined') {\n return '[object Undefined]';\n }\n\n return nativeObjectToString.call(value);\n};\n\nexport default toStringTag;\n","import hasSymbols from 'has-symbol-support-x';\nimport isSymbol from 'is-symbol';\n\n/**\n * Indicates if `Symbol.toStringTag`exists and is the correct type.\n * `true`, if it exists and is the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbols &&\n /* eslint-disable-next-line compat/compat */\n isSymbol(Symbol.toStringTag);\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n */\nconst isNil = function isNil(value) {\n /* eslint-disable-next-line lodash/prefer-is-nil */\n return value === null || typeof value === 'undefined';\n};\n\nexport default isNil;\n","import isNil from 'is-nil-x';\n\n/**\n * The abstract operation RequireObjectCoercible throws an error if argument\n * is a value that cannot be converted to an Object using ToObject.\n *\n * @param {*} [value] - The `value` to check.\n * @throws {TypeError} If `value` is a `null` or `undefined`.\n * @returns {string} The `value`.\n */\nconst requireObjectCoercible = function requireObjectCoercible(value) {\n if (isNil(value)) {\n throw new TypeError(`Cannot call method on ${value}`);\n }\n\n return value;\n};\n\nexport default requireObjectCoercible;\n","import isSymbol from 'is-symbol';\n\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a string';\nconst castString = ERROR_MESSAGE.constructor;\n/**\n * The abstract operation ToString converts argument to a value of type String.\n *\n * @param {*} [value] - The value to convert to a string.\n * @throws {TypeError} If `value` is a Symbol.\n * @returns {string} The converted value.\n */\nconst ToString = function ToString(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return castString(value);\n};\n\nexport default ToString;\n","import requireObjectCoercible from 'require-object-coercible-x';\nimport toStr from 'to-string-x';\n\n/**\n * This method requires an argument is corecible then converts using ToString.\n *\n * @param {*} [value] - The value to converted to a string.\n * @throws {TypeError} If value is null or undefined.\n * @returns {string} The value as a string.\n */\nconst requireCoercibleToString = function requireCoercibleToString(value) {\n return toStr(requireObjectCoercible(value));\n};\n\nexport default requireCoercibleToString;\n","/**\n * A record of a white space character.\n *\n * @typedef {object} CharRecord\n * @property {number} code - The character code.\n * @property {string} description - A description of the character.\n * @property {boolean} es5 - Whether the spec lists this as a white space.\n * @property {boolean} es2015 - Whether the spec lists this as a white space.\n * @property {boolean} es2016 - Whether the spec lists this as a white space.\n * @property {boolean} es2017 - Whether the spec lists this as a white space.\n * @property {boolean} es2018 - Whether the spec lists this as a white space.\n * @property {string} string - The character string.\n */\n\n/**\n * An array of the whitespace char codes, string, descriptions and language\n * presence in the specifications.\n *\n * @type Array.\n */\nexport const list = [\n {\n code: 0x0009,\n description: 'Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0009',\n },\n {\n code: 0x000a,\n description: 'Line Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000a',\n },\n {\n code: 0x000b,\n description: 'Vertical Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000b',\n },\n {\n code: 0x000c,\n description: 'Form Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000c',\n },\n {\n code: 0x000d,\n description: 'Carriage Return',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000d',\n },\n {\n code: 0x0020,\n description: 'Space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0020',\n },\n /*\n {\n code: 0x0085,\n description: 'Next line',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u0085'\n }\n */\n {\n code: 0x00a0,\n description: 'No-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u00a0',\n },\n {\n code: 0x1680,\n description: 'Ogham space mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u1680',\n },\n {\n code: 0x180e,\n description: 'Mongolian vowel separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: false,\n es2018: false,\n string: '\\u180e',\n },\n {\n code: 0x2000,\n description: 'En quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2000',\n },\n {\n code: 0x2001,\n description: 'Em quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2001',\n },\n {\n code: 0x2002,\n description: 'En space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2002',\n },\n {\n code: 0x2003,\n description: 'Em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2003',\n },\n {\n code: 0x2004,\n description: 'Three-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2004',\n },\n {\n code: 0x2005,\n description: 'Four-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2005',\n },\n {\n code: 0x2006,\n description: 'Six-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2006',\n },\n {\n code: 0x2007,\n description: 'Figure space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2007',\n },\n {\n code: 0x2008,\n description: 'Punctuation space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2008',\n },\n {\n code: 0x2009,\n description: 'Thin space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2009',\n },\n {\n code: 0x200a,\n description: 'Hair space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u200a',\n },\n /*\n {\n code: 0x200b,\n description: 'Zero width space',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u200b'\n },\n */\n {\n code: 0x2028,\n description: 'Line separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2028',\n },\n {\n code: 0x2029,\n description: 'Paragraph separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2029',\n },\n {\n code: 0x202f,\n description: 'Narrow no-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u202f',\n },\n {\n code: 0x205f,\n description: 'Medium mathematical space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u205f',\n },\n {\n code: 0x3000,\n description: 'Ideographic space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u3000',\n },\n {\n code: 0xfeff,\n description: 'Byte Order Mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\ufeff',\n },\n];\n\n/**\n * A string of the ES5 to ES2016 whitespace characters.\n *\n * @type string\n */\nlet stringES2016 = '';\n\n/**\n * A string of the ES2017 to ES2018 whitespace characters.\n *\n * @type string\n */\nlet stringES2018 = '';\nconst {length} = list;\nfor (let i = 0; i < length; i += 1) {\n if (list[i].es2016) {\n stringES2016 += list[i].string;\n }\n\n if (list[i].es2018) {\n stringES2018 += list[i].string;\n }\n}\n\nconst string2018 = stringES2018;\n\nexport default string2018;\nexport const string2016 = stringES2016;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reLeft = new RegExpCtr(`^[${whiteSpace}]+`);\nconst {replace} = EMPTY_STRING;\n/**\n * This method removes whitespace from the start of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the left end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The left trimmed string.\n */\nconst trimStart = function trimStart(string) {\n return replace.call(requireCoercibleToString(string), reLeft, EMPTY_STRING);\n};\n\nexport default trimStart;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reRight2018 = new RegExpCtr(`[${whiteSpace}]+$`);\nconst {replace} = EMPTY_STRING;\n\n/**\n * This method removes whitespace from the end of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the right end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The right trimmed string.\n */\nconst trimEnd = function trimEnd(string) {\n return replace.call(requireCoercibleToString(string), reRight2018, EMPTY_STRING);\n};\n\nexport default trimEnd;\n","import trimStart from 'trim-left-x';\nimport trimEnd from 'trim-right-x';\n\n/**\n * This method removes whitespace from the start and end of a string.\n * (ES2019).\n *\n * @param {string} [string] - The string to trim the whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The trimmed string.\n */\nconst trim = function trim(string) {\n return trimStart(trimEnd(string));\n};\n\nexport default trim;\n","import trim from 'trim-x';\nimport whiteSpace from 'white-space-x';\n\nconst SPACE = ' ';\nconst RegExpCtr = /none/.constructor;\nconst reNormalize2018 = new RegExpCtr(`[${whiteSpace}]+`, 'g');\nconst {replace} = SPACE;\n\n/**\n * This method strips leading and trailing white-space from a string,\n * replaces sequences of whitespace characters by a single space,\n * and returns the resulting string. (ES2019).\n *\n * @param {string} [string] - The string to be normalized.\n * @throws {TypeError} If string is null or undefined or not coercible.\n */\nconst normalizeSpace = function normalizeSpace(string) {\n return replace.call(trim(string), reNormalize2018, SPACE);\n};\n\nexport default normalizeSpace;\n","import toStr from 'to-string-x';\nimport requireCoercibleToString from 'require-coercible-to-string-x';\n\nconst EMPTY_STRING = '';\nconst STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/gm;\nconst {replace} = EMPTY_STRING;\n\n/**\n * This method replaces comments in a string.\n *\n * @param {string} [string] - The string to be stripped.\n * @param {string} [replacement=''] - The string to be used as a replacement.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @throws {TypeError} If replacement is not coercible.\n * @returns {string} The new string with the comments replaced.\n */\nconst replaceComments = function replaceComments(string, replacement) {\n return replace.call(requireCoercibleToString(string), STRIP_COMMENTS, arguments.length > 1 ? toStr(replacement) : EMPTY_STRING);\n};\n\nexport default replaceComments;\n","import attempt from 'attempt-x';\nimport toBoolean from 'to-boolean-x';\nimport toStringTag from 'to-string-tag-x';\nimport hasToStringTag from 'has-to-string-tag-x';\nimport isPrimitive from 'is-primitive';\nimport normalise from 'normalize-space-x';\nimport deComment from 'replace-comments-x';\n\nconst FunctionCtr = attempt.constructor;\nconst SPACE = ' ';\nconst fToString = attempt.toString;\nconst funcTag = '[object Function]';\nconst genTag = '[object GeneratorFunction]';\nconst asyncTag = '[object AsyncFunction]';\nconst ctrRx = /^class /;\nconst {test} = ctrRx;\n\nconst hasNativeClass =\n attempt(function attemptee() {\n /* eslint-disable-next-line babel/new-cap */\n return FunctionCtr('\"use strict\"; return class My {};')();\n }).threw === false;\n\nconst testClassString = function testClassString(value) {\n return test.call(ctrRx, normalise(deComment(fToString.call(value), SPACE)));\n};\n\nconst isES6ClassFn = function isES6ClassFunc(value) {\n const result = attempt(testClassString, value);\n\n return result.threw === false && result.value;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @private\n * @param {*} value - The value to check.\n * @param {boolean} allowClass - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst tryFuncToString = function funcToString(value, allowClass) {\n if (hasNativeClass && allowClass === false && isES6ClassFn(value)) {\n return false;\n }\n\n return attempt.call(value, fToString).threw === false;\n};\n\nconst compareTags = function compareTags(value) {\n const strTag = toStringTag(value);\n\n return strTag === funcTag || strTag === genTag || strTag === asyncTag;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @param {*} value - The value to check.\n * @param {boolean} [allowClass=false] - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst isFunction = function isFunction(value, allowClass) {\n if (isPrimitive(value)) {\n return false;\n }\n\n if (hasToStringTag) {\n return tryFuncToString(value, toBoolean(allowClass));\n }\n\n if (hasNativeClass && toBoolean(allowClass) === false && isES6ClassFn(value)) {\n return false;\n }\n\n return compareTags(value);\n};\n\nexport default isFunction;\n","import hasSymbols from 'has-symbol-support-x';\nimport isPrimitive from 'is-primitive';\nimport isDate from 'is-date-object';\nimport isSymbol from 'is-symbol';\nimport isFunction from 'is-function-x';\nimport requireObjectCoercible from 'require-object-coercible-x';\nimport isNil from 'is-nil-x';\n\nconst ZERO = 0;\nconst ONE = 1;\n/* eslint-disable-next-line no-void */\nconst UNDEFINED = void ZERO;\nconst NUMBER = 'number';\nconst STRING = 'string';\nconst DEFAULT = 'default';\nconst StringCtr = STRING.constructor;\nconst NumberCtr = ZERO.constructor;\n/* eslint-disable-next-line compat/compat */\nconst symToPrimitive = hasSymbols && Symbol.toPrimitive;\n/* eslint-disable-next-line compat/compat */\nconst symValueOf = hasSymbols && Symbol.prototype.valueOf;\n\nconst toStringOrder = ['toString', 'valueOf'];\nconst toNumberOrder = ['valueOf', 'toString'];\nconst orderLength = 2;\n\nconst assertHint = function assertHint(hint) {\n if (typeof hint !== 'string' || (hint !== NUMBER && hint !== STRING)) {\n throw new TypeError('hint must be \"string\" or \"number\"');\n }\n\n return hint;\n};\n\n/**\n * @param {*} ordinary - The ordinary to convert.\n * @param {*} hint - The hint.\n * @returns {*} - The primitive.\n */\nconst ordinaryToPrimitive = function ordinaryToPrimitive(ordinary, hint) {\n requireObjectCoercible(ordinary);\n assertHint(hint);\n\n const methodNames = hint === STRING ? toStringOrder : toNumberOrder;\n let method;\n let result;\n for (let i = ZERO; i < orderLength; i += ONE) {\n method = ordinary[methodNames[i]];\n\n if (isFunction(method)) {\n result = method.call(ordinary);\n\n if (isPrimitive(result)) {\n return result;\n }\n }\n }\n\n throw new TypeError('No default value');\n};\n\n/**\n * @param {*} object - The object.\n * @param {*} property - The property.\n * @returns {undefined|Function} - The method.\n */\nconst getMethod = function getMethod(object, property) {\n const func = object[property];\n\n if (isNil(func) === false) {\n if (isFunction(func) === false) {\n throw new TypeError(`${func} returned for property ${property} of object ${object} is not a function`);\n }\n\n return func;\n }\n\n return UNDEFINED;\n};\n\n/**\n * Get the hint.\n *\n * @param {*} value - The value to compare.\n * @param {boolean} supplied - Was a value supplied.\n * @returns {string} - The hint string.\n */\nconst getHint = function getHint(value, supplied) {\n if (supplied) {\n if (value === StringCtr) {\n return STRING;\n }\n\n if (value === NumberCtr) {\n return NUMBER;\n }\n }\n\n return DEFAULT;\n};\n\n/**\n * Get the primitive from the exotic.\n *\n * @param {*} value - The exotic.\n * @returns {*} - The primitive.\n */\nconst getExoticToPrim = function getExoticToPrim(value) {\n if (hasSymbols) {\n if (symToPrimitive) {\n return getMethod(value, symToPrimitive);\n }\n\n if (isSymbol(value)) {\n return symValueOf;\n }\n }\n\n return UNDEFINED;\n};\n\nconst evalExotic = function evalExotic(obj) {\n const {exoticToPrim, input, hint} = obj;\n const result = exoticToPrim.call(input, hint);\n\n if (isPrimitive(result)) {\n return result;\n }\n\n throw new TypeError('unable to convert exotic object to primitive');\n};\n\nconst evalPrimitive = function evalPrimitive(input, hint) {\n const newHint = hint === DEFAULT && (isDate(input) || isSymbol(input)) ? STRING : hint;\n\n return ordinaryToPrimitive(input, newHint === DEFAULT ? NUMBER : newHint);\n};\n\n/**\n * This method converts a JavaScript object to a primitive value.\n * Note: When toPrimitive is called with no hint, then it generally behaves as\n * if the hint were Number. However, objects may over-ride this behaviour by\n * defining a @@toPrimitive method. Of the objects defined in this specification\n * only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.4) over-ride\n * the default ToPrimitive behaviour. Date objects treat no hint as if the hint\n * were String.\n *\n * @param {*} input - The input to convert.\n * @param {Function} [preferredType] - The preferred type (String or Number).\n * @throws {TypeError} If unable to convert input to a primitive.\n * @returns {string|number} The converted input as a primitive.\n * @see {http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive}\n */\nconst toPrimitive = function toPrimitive(input, preferredType) {\n if (isPrimitive(input)) {\n return input;\n }\n\n const hint = getHint(preferredType, arguments.length > ONE);\n const exoticToPrim = getExoticToPrim(input);\n\n return typeof exoticToPrim === 'undefined' ? evalPrimitive(input, hint) : evalExotic({exoticToPrim, input, hint});\n};\n\nexport default toPrimitive;\n","/**\n * The constant NaN derived mathematically by 0 / 0.\n *\n * @type number\n */\nconst constantNAN = 0 / 0;\n\nexport default constantNAN;\n","import NAN from 'nan-x';\nimport toStr from 'to-string-x';\nimport trimLeft from 'trim-left-x';\n\nconst nativeParseInt = parseInt;\n/** @type {Function} */\nconst castNumber = (0).constructor;\n// noinspection JSPotentiallyInvalidConstructorUsage\nconst {charAt} = '';\nconst hexRegex = /^[-+]?0[xX]/;\nconst {test} = hexRegex;\n\n/**\n * This method parses a string argument and returns an integer of the specified\n * radix (the base in mathematical numeral systems). (ES2019).\n *\n * @param {string} [string] - The value to parse. If the string argument is not a\n * string, then it is converted to a string (using the ToString abstract\n * operation). Leading whitespace in the string argument is ignored.\n * @param {number} [radix] - An integer between 2 and 36 that represents the radix\n * (the base in mathematical numeral systems) of the above mentioned string.\n * Specify 10 for the decimal numeral system commonly used by humans. Always\n * specify this parameter to eliminate reader confusion and to guarantee\n * predictable behavior. Different implementations produce different results\n * when a radix is not specified, usually defaulting the value to 10.\n * @throws {TypeError} If target is a Symbol or is not coercible.\n * @returns {number} An integer number parsed from the given string. If the first\n * character cannot be converted to a number, NaN is returned.\n */\nconst $parseInt = function $parseInt(string, radix) {\n const str = trimLeft(toStr(string));\n\n if (charAt.call(str, 0) === '\\u180E') {\n return NAN;\n }\n\n return nativeParseInt(str, castNumber(radix) || (test.call(hexRegex, str) ? 16 : 10));\n};\n\nexport default $parseInt;\n","import isSymbol from 'is-symbol';\nimport toPrimitive from 'to-primitive-x';\nimport trim from 'trim-x';\nimport $parseInt from 'parse-int-x';\nimport NAN from 'nan-x';\n\nconst binaryRadix = 2;\nconst octalRadix = 8;\nconst testCharsCount = 2;\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a number';\n\nconst castNumber = testCharsCount.constructor;\nconst pStrSlice = ERROR_MESSAGE.slice;\n\nconst binaryRegex = /^0b[01]+$/i;\nconst RegExpConstructor = binaryRegex.constructor;\n// Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is\n// an own property of regexes. wtf.\nconst {test} = binaryRegex;\nconst isBinary = function isBinary(value) {\n return test.call(binaryRegex, value);\n};\n\nconst octalRegex = /^0o[0-7]+$/i;\nconst isOctal = function isOctal(value) {\n return test.call(octalRegex, value);\n};\n\nconst nonWSregex = new RegExpConstructor('[\\u0085\\u180e\\u200b\\ufffe]', 'g');\nconst hasNonWS = function hasNonWS(value) {\n return test.call(nonWSregex, value);\n};\n\nconst invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i;\nconst isInvalidHexLiteral = function isInvalidHexLiteral(value) {\n return test.call(invalidHexLiteral, value);\n};\n\nconst assertNotSymbol = function assertNotSymbol(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return value;\n};\n\nconst parseBase = function parseBase(value, radix) {\n return $parseInt(pStrSlice.call(value, testCharsCount), radix);\n};\n\nconst parseString = function parseString(toNum, value) {\n if (isBinary(value)) {\n return toNum(parseBase(value, binaryRadix));\n }\n\n if (isOctal(value)) {\n return toNum(parseBase(value, octalRadix));\n }\n\n return null;\n};\n\nconst convertString = function convertString(toNum, value) {\n const val = parseString(toNum, value);\n\n if (val !== null) {\n return val;\n }\n\n if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n return NAN;\n }\n\n const trimmed = trim(value);\n\n if (trimmed !== value) {\n return toNum(trimmed);\n }\n\n return null;\n};\n\n/**\n * This method converts argument to a value of type Number. (ES2019).\n *\n * @param {*} [argument] - The argument to convert to a number.\n * @throws {TypeError} - If argument is a Symbol or not coercible.\n * @returns {*} The argument converted to a number.\n */\nconst toNumber = function toNumber(argument) {\n const value = assertNotSymbol(toPrimitive(argument, castNumber));\n\n if (typeof value === 'string') {\n const val = convertString(toNumber, value);\n\n if (val !== null) {\n return val;\n }\n }\n\n return castNumber(value);\n};\n\nexport default toNumber;\n","/**\n * This method determines whether the passed value is NaN and its type is\n * `Number`. It is a more robust version of the original, global isNaN().\n *\n * @param {*} [value] - The value to be tested for NaN.\n * @returns {boolean} `true` if the given value is NaN and its type is Number;\n * otherwise, `false`.\n */\nconst isNaN = function isNaN(value) {\n /* eslint-disable-next-line no-self-compare */\n return value !== value;\n};\n\nexport default isNaN;\n","import toNumber from 'to-number-x';\nimport numberIsNaN from 'is-nan-x';\n\n/**\n * This method returns the sign of a number, indicating whether the number is positive,\n * negative or zero. (ES2019).\n *\n * @param {*} x - A number.\n * @returns {number} A number representing the sign of the given argument. If the argument\n * is a positive number, negative number, positive zero or negative zero, the function will\n * return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned.\n */\nconst sign = function sign(x) {\n const n = toNumber(x);\n\n if (n === 0 || numberIsNaN(n)) {\n return n;\n }\n\n return n > 0 ? 1 : -1;\n};\n\nexport default sign;\n"],"sourceRoot":""} \ No newline at end of file +{"version":3,"sources":["webpack://mathSignX/webpack/universalModuleDefinition","webpack://mathSignX/webpack/bootstrap","webpack://mathSignX/./node_modules/is-symbol/index.js","webpack://mathSignX/./node_modules/is-string/index.js","webpack://mathSignX/./node_modules/is-date-object/index.js","webpack://mathSignX/./node_modules/has-symbols/index.js","webpack://mathSignX/(webpack)/buildin/global.js","webpack://mathSignX/./node_modules/has-symbols/shams.js","webpack://mathSignX/../src/is-primitive-x.js","webpack://mathSignX/../src/has-boxed-string-x.js","webpack://mathSignX/../src/noop-x.js","webpack://mathSignX/../src/has-working-bind-x.js","webpack://mathSignX/../src/util-pusher-x.js","webpack://mathSignX/../src/simple-bind-x.js","webpack://mathSignX/../src/simple-call-x.js","webpack://mathSignX/../src/attempt-x.js","webpack://mathSignX/../src/has-symbol-support-x.js","webpack://mathSignX/../src/to-boolean-x.js","webpack://mathSignX/../src/simple-methodize-x.js","webpack://mathSignX/../src/to-string-tag-x.js","webpack://mathSignX/../src/has-to-string-tag-x.js","webpack://mathSignX/../src/is-nil-x.js","webpack://mathSignX/../src/require-object-coercible-x.js","webpack://mathSignX/../src/to-string-x.js","webpack://mathSignX/../src/require-coercible-to-string-x.js","webpack://mathSignX/../src/white-space-x.js","webpack://mathSignX/../src/trim-left-x.js","webpack://mathSignX/../src/trim-right-x.js","webpack://mathSignX/../src/trim-x.js","webpack://mathSignX/../src/normalize-space-x.js","webpack://mathSignX/../src/replace-comments-x.js","webpack://mathSignX/../src/is-function-x.js","webpack://mathSignX/../src/to-primitive-x.js","webpack://mathSignX/../src/nan-x.js","webpack://mathSignX/../src/parse-int-x.js","webpack://mathSignX/../src/to-number-x.js","webpack://mathSignX/../src/is-nan-x.js","webpack://mathSignX/../src/math-sign-x.js"],"names":[],"mappings":";;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;;AAEA;;AAEA;;AAEA;AACA,GAAG;AACH;AACA;AACA,CAAC;AACD,O;QCvDA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;;QAEA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;;;QAGA;QACA;;QAEA;QACA;;QAEA;QACA;QACA;QACA,0CAA0C,gCAAgC;QAC1E;QACA;;QAEA;QACA;QACA;QACA,wDAAwD,kBAAkB;QAC1E;QACA,iDAAiD,cAAc;QAC/D;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,yCAAyC,iCAAiC;QAC1E,gHAAgH,mBAAmB,EAAE;QACrI;QACA;;QAEA;QACA;QACA;QACA,2BAA2B,0BAA0B,EAAE;QACvD,iCAAiC,eAAe;QAChD;QACA;QACA;;QAEA;QACA,sDAAsD,+DAA+D;;QAErH;QACA;;;QAGA;QACA;;;;;;;;AClFa;;AAEb;AACA,iBAAiB,mBAAO,CAAC,CAAa;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,SAAS,MAAK,IAAI,KAAK;AACvB;AACA;;;;;;;;AClCa;;AAEb;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iCAAiC,aAAa;AAC9C,iCAAiC,cAAc;AAC/C;AACA;;;;;;;;ACnBa;;AAEb;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;AACA;AACA;;AAEA;AACA;AA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","file":"math-sign-x.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mathSignX\"] = factory();\n\telse\n\t\troot[\"mathSignX\"] = factory();\n})((function () {\n 'use strict';\n\n var ObjectCtr = {}.constructor;\n var objectPrototype = ObjectCtr.prototype;\n var defineProperty = ObjectCtr.defineProperty;\n var $globalThis;\n var getGlobalFallback = function() {\n if (typeof self !== 'undefined') {\n return self;\n }\n\n if (typeof window !== 'undefined') {\n return window;\n }\n\n if (typeof global !== 'undefined') {\n return global;\n }\n\n return void 0;\n };\n\n var returnThis = function() {\n return this;\n };\n\n try {\n if (defineProperty) {\n defineProperty(objectPrototype, '$$globalThis$$', {\n get: returnThis,\n configurable: true\n });\n } else {\n objectPrototype.__defineGetter__('$$globalThis$$', returnThis);\n }\n\n $globalThis = typeof $$globalThis$$ === 'undefined' ? getGlobalFallback() : $$globalThis$$;\n\n delete objectPrototype.$$globalThis$$;\n\n return $globalThis;\n } catch (error) {\n return getGlobalFallback();\n }\n}()), function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 6);\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n","'use strict';\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') { return true; }\n\tif (typeof value !== 'object') { return false; }\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateObject(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) { return false; }\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n","'use strict';\n\nvar origSymbol = global.Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict';\n\n/* eslint complexity: [2, 17], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","/**\n * Returns true if the value is a primitive.\n *\n * @param {*} [val] - The value to test.\n * @returns {boolean} True if a primitive, otherwise false..\n */\nconst isPrimitive = function isPrimitive(val) {\n return typeof val === 'object' ? val === null : typeof val !== 'function';\n};\n\nexport default isPrimitive;\n","const string = 'a';\nconst boxedString = {}.constructor(string);\n\n/**\n * Check failure of by-index access of string characters (IE < 9)\n * and failure of `0 in boxedString` (Rhino).\n *\n * `true` if no failure; otherwise `false`.\n *\n * @type boolean\n */\nconst hasBoxed = boxedString[0] === string && 0 in boxedString;\n\nexport default hasBoxed;\n","/**\n * This method returns undefined.\n *\n * @returns {undefined} Always undefined.\n */\nconst noop = function noop() {}; /* eslint-disable-line lodash/prefer-noop */\n\nexport default noop;\n","import noop from 'noop-x';\n\nconst {bind} = noop;\n\nconst test1 = function test1() {\n let a1 = null;\n let a2 = null;\n let context = null;\n const testThis = [];\n\n const test1Fn = function test1Fn(arg1, arg2) {\n /* eslint-disable-next-line babel/no-invalid-this */\n context = this;\n a1 = arg1;\n a2 = arg2;\n\n /* eslint-disable-next-line prefer-rest-params */\n return arguments;\n };\n\n try {\n const boundFn = bind.apply(test1Fn, [testThis, 1]);\n const args = boundFn(2);\n\n return boundFn.length === 1 && args.length === 2 && a1 === 1 && a2 === 2 && context === testThis;\n } catch (e) {\n return false;\n }\n};\n\nconst test2 = function test2() {\n let a1 = null;\n let a2 = null;\n let context = null;\n const oracle = [1, 2, 3];\n\n const Ctr = function Ctr(arg1, arg2) {\n a1 = arg1;\n a2 = arg2;\n context = this;\n\n return oracle;\n };\n\n try {\n const BoundFn = bind.apply(Ctr, [null]);\n const returned = new BoundFn(1, 2);\n\n return BoundFn.length === Ctr.length && returned === oracle && a1 === 1 && a2 === 2 && context !== oracle;\n } catch (e) {\n return false;\n }\n};\n\n/**\n * Indicates if the engine has a working bind function.\n *\n * @type {boolean}\n */\nconst isWorking = typeof bind === 'function' && test1() && test2();\n\nexport default isWorking;\n","import isPrimitive from 'is-primitive-x';\nimport isString from 'is-string';\nimport hasBoxed from 'has-boxed-string-x';\nimport hasWorkingBind from 'has-working-bind-x';\n\nconst EMPTY_STRING = '';\nconst {split} = EMPTY_STRING;\nconst {max} = Math;\nconst {bind, call} = isPrimitive;\nexport const stringSplit = function stringSplit(string, pattern) {\n // noinspection JSUnresolvedFunction\n return split.call(string, pattern);\n};\n\nexport const $split = hasWorkingBind ? bind.call(call, split) : stringSplit;\n\nexport const getIterable = function getIterable(arrayLike) {\n // noinspection JSUnresolvedFunction\n return isString(arrayLike) ? $split(arrayLike, EMPTY_STRING) : arrayLike;\n};\n\n// eslint-disable jsdoc/no-undefined-types\n// noinspection JSCommentMatchesSignature\n/**\n * This pushes or concatenates into a new or existing array.\n *\n * @param {Array} arrayLike - The source.\n * @param {number} [from=0] - The from source index.\n * @param {Array} [target=[]] - The target array.\n * @returns {*} The target array.\n */\n// eslint-enable jsdoc/no-undefined-types\nconst pusher = function pusher(arrayLike, from) {\n /* eslint-disable-next-line prefer-rest-params */\n const target = arguments.length > 2 ? arguments[2] : [];\n\n if (typeof arrayLike !== 'string' && isPrimitive(arrayLike)) {\n return target;\n }\n\n const iterable = hasBoxed ? arrayLike : getIterable(arrayLike);\n const {length} = iterable;\n for (let i = max(0, from) || 0; i < length; i += 1) {\n target[target.length] = arrayLike[i];\n }\n\n return target;\n};\n\nexport default pusher;\n","import hasWorkingBind from 'has-working-bind-x';\nimport pusher from 'util-pusher-x';\n\nconst {bind: nativeBind, call} = pusher;\nconst ERROR_MESSAGE = 'bind called on incompatible ';\nconst object = {};\nconst ObjectCtr = object.constructor;\nconst toStringTag = object.toString;\nconst funcType = '[object Function]';\nconst ZERO = 0;\nconst argsOffset = 2;\n\nconst getMax = function getMax(a, b) {\n return a >= b ? a : b;\n};\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && toStringTag.apply(value) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + value);\n }\n};\n\nconst boundFns = [\n function zero(binder) {\n return function boundFn() {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments));\n };\n },\n function one(binder, boundLength) {\n return function boundFn(a) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a]));\n };\n },\n function two(binder, boundLength) {\n return function boundFn(a, b) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b]));\n };\n },\n function three(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c]));\n };\n },\n function four(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d]));\n };\n },\n function five(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e]));\n };\n },\n function six(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f]));\n };\n },\n function seven(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f, g) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f, g]));\n };\n },\n function eight(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f, g, h) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f, g, h]));\n };\n },\n];\n\nconst getBoundFn = function getBoundFn(args) {\n const [binder, target, bindArgs] = args;\n const boundLength = getMax(ZERO, target.length - getMax(ZERO, bindArgs.length - argsOffset));\n const fn = boundFns[boundLength];\n const boundFn = fn ? fn(binder, boundLength) : boundFns[ZERO](binder);\n\n if (target.prototype) {\n /* eslint-disable-next-line lodash/prefer-noop */\n const Empty = function Empty() {};\n\n Empty.prototype = target.prototype;\n boundFn.prototype = new Empty();\n Empty.prototype = null;\n }\n\n return boundFn;\n};\n\nconst getResult = function getResult(target, boundArgs) {\n /* eslint-disable-next-line babel/no-invalid-this */\n const result = target.apply(this, boundArgs);\n\n /* eslint-disable-next-line babel/no-invalid-this,babel/new-cap */\n return ObjectCtr(result) === result ? result : this;\n};\n\nexport const implementation = function bind(target, thisArg) {\n assertIsFunction(target);\n /* eslint-disable-next-line prefer-rest-params */\n const bindArgs = arguments;\n\n let bound;\n const binder = function binder() {\n /* eslint-disable-next-line prefer-rest-params */\n const boundArgs = pusher(arguments, ZERO, pusher(bindArgs, argsOffset));\n\n /* eslint-disable-next-line babel/no-invalid-this */\n return this instanceof bound ? getResult.apply(this, [target, boundArgs]) : target.apply(thisArg, boundArgs);\n };\n\n bound = getBoundFn([binder, target, bindArgs]);\n\n return bound;\n};\n\n/**\n * The bind() method creates a new function that, when called, has its this\n * keyword set to the provided value, with a given sequence of arguments\n * preceding any provided when the new function is called.\n *\n * @function bind\n * @param {Function} target - The target function.\n * @param {*} [thisArg] - The value to be passed as the this parameter to the target\n * function when the bound function is called. The value is ignored if the\n * bound function is constructed using the new operator.\n * @param {...*} [args] - Arguments to prepend to arguments provided to the bound\n * function when invoking the target function.\n * @throws {TypeError} If target is not a function.\n * @returns {Function} The bound function.\n */\nconst $bind = hasWorkingBind ? call.bind(nativeBind) : implementation;\n\nexport default $bind;\n","import pusher from 'util-pusher-x';\nimport bind from 'simple-bind-x';\n\nconst $TypeError = TypeError;\nconst {apply: nativeApply, call: nativeCall} = bind;\nconst $apply = bind(nativeCall, nativeApply);\nconst toStringTag = bind(nativeApply, {}.toString);\nconst ERROR_MESSAGE = ' is not a function';\nconst funcType = '[object Function]';\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && toStringTag(value) !== funcType) {\n throw new $TypeError(value + ERROR_MESSAGE);\n }\n\n return value;\n};\n\n// eslint-disable jsdoc/check-param-names\n// noinspection JSCommentMatchesSignature\n/**\n * The abstract operation Call is used to call the [[Call]] internal method of a function object.\n *\n * @function call\n * @param {Function} F - The target function.\n * @param {*} [V] - The context.\n * @param {Array} [args] - Argument to call the function with.\n * @throws {TypeError} If target is not a function.\n * @returns {*} The the result of invoking the function.\n * @see https://www.ecma-international.org/ecma-262/6.0/#sec-call\n */\n// eslint-enable jsdoc/check-param-names\nconst call = function call(F, V) {\n /* eslint-disable-next-line prefer-rest-params */\n return $apply(assertIsFunction(F), V, pusher(arguments[2]));\n};\n\nexport default call;\n","import pusher from 'util-pusher-x';\nimport call from 'simple-call-x';\n\n// eslint-disable jsdoc/check-param-names\n// noinspection JSCommentMatchesSignature\n/**\n * This method attempts to invoke the function, returning either the result or\n * the caught error object. Any additional arguments are provided to the\n * function when it's invoked.\n *\n * @function attempt\n * @param {Function} [fn] - The function to attempt.\n * @param {...*} [args] - The arguments to invoke the function with.\n * @returns {object} Returns an object of the result.\n */\n// eslint-disable jsdoc/check-param-names\nconst attempt = function attempt(fn) {\n try {\n return {\n threw: false,\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n value: call(fn, this, pusher(arguments, 1)),\n };\n } catch (e) {\n return {\n threw: true,\n value: e,\n };\n }\n};\n\nexport default attempt;\n","import attempt from 'attempt-x';\nimport isSymbol from 'is-symbol';\n\nconst hasSymbolSupport = attempt(() => {\n /* eslint-disable-next-line compat/compat */\n return typeof Symbol === 'function' && isSymbol(Symbol(''));\n});\n\n/**\n * Indicates if `Symbol`exists and creates the correct type.\n * `true`, if it exists and creates the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbolSupport.threw === false && hasSymbolSupport.value === true;\n","/**\n * The abstract operation ToBoolean converts argument to a value of type Boolean.\n *\n * @param {*} [value] - The value to be converted.\n * @returns {boolean} 'true' if value is truthy; otherwise 'false'.\n */\nconst toBoolean = function toBoolean(value) {\n return !!value;\n};\n\nexport default toBoolean;\n","import call from 'simple-call-x';\nimport pusher from 'util-pusher-x';\n\nconst toStringTag = {}.toString;\nconst ERROR_MESSAGE = 'methodize called on incompatible ';\nconst funcType = '[object Function]';\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && call(toStringTag, value) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + value);\n }\n\n return value;\n};\n\n/**\n * Methodize a prototype method. Compliant to 8 arguments.\n *\n * @param {Function} prototypeMethod - The prototype method to methodize.\n * @throws {TypeError} If target is not a function.\n * @returns {Function} The static method.\n */\nconst methodize = function methodize(prototypeMethod) {\n assertIsFunction(prototypeMethod);\n\n return function methodized() {\n /* eslint-disable-next-line prefer-rest-params */\n return call(prototypeMethod, arguments[0], pusher(arguments, 1));\n };\n};\n\nexport default methodize;\n","import methodize from 'simple-methodize-x';\n\nconst methodizedToString = methodize({}.toString);\n\n/**\n * The `toStringTag` method returns \"[object type]\", where type is the\n * object type.\n *\n * @param {*} [value] - The object of which to get the object type string.\n * @returns {string} The object type string.\n */\nconst toStringTag = function toStringTag(value) {\n if (value === null) {\n return '[object Null]';\n }\n\n if (typeof value === 'undefined') {\n return '[object Undefined]';\n }\n\n return methodizedToString(value);\n};\n\nexport default toStringTag;\n","import hasSymbols from 'has-symbol-support-x';\nimport isSymbol from 'is-symbol';\n\n/**\n * Indicates if `Symbol.toStringTag`exists and is the correct type.\n * `true`, if it exists and is the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbols &&\n /* eslint-disable-next-line compat/compat */\n isSymbol(Symbol.toStringTag);\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n */\nconst isNil = function isNil(value) {\n /* eslint-disable-next-line lodash/prefer-is-nil */\n return value === null || typeof value === 'undefined';\n};\n\nexport default isNil;\n","import isNil from 'is-nil-x';\n\n/**\n * The abstract operation RequireObjectCoercible throws an error if argument\n * is a value that cannot be converted to an Object using ToObject.\n *\n * @param {*} [value] - The `value` to check.\n * @throws {TypeError} If `value` is a `null` or `undefined`.\n * @returns {string} The `value`.\n */\nconst requireObjectCoercible = function requireObjectCoercible(value) {\n if (isNil(value)) {\n throw new TypeError(`Cannot call method on ${value}`);\n }\n\n return value;\n};\n\nexport default requireObjectCoercible;\n","import isSymbol from 'is-symbol';\n\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a string';\nconst castString = ERROR_MESSAGE.constructor;\n/**\n * The abstract operation ToString converts argument to a value of type String.\n *\n * @param {*} [value] - The value to convert to a string.\n * @throws {TypeError} If `value` is a Symbol.\n * @returns {string} The converted value.\n */\nconst ToString = function ToString(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return castString(value);\n};\n\nexport default ToString;\n","import requireObjectCoercible from 'require-object-coercible-x';\nimport toStr from 'to-string-x';\n\n/**\n * This method requires an argument is corecible then converts using ToString.\n *\n * @param {*} [value] - The value to converted to a string.\n * @throws {TypeError} If value is null or undefined.\n * @returns {string} The value as a string.\n */\nconst requireCoercibleToString = function requireCoercibleToString(value) {\n return toStr(requireObjectCoercible(value));\n};\n\nexport default requireCoercibleToString;\n","/**\n * A record of a white space character.\n *\n * @typedef {object} CharRecord\n * @property {number} code - The character code.\n * @property {string} description - A description of the character.\n * @property {boolean} es5 - Whether the spec lists this as a white space.\n * @property {boolean} es2015 - Whether the spec lists this as a white space.\n * @property {boolean} es2016 - Whether the spec lists this as a white space.\n * @property {boolean} es2017 - Whether the spec lists this as a white space.\n * @property {boolean} es2018 - Whether the spec lists this as a white space.\n * @property {string} string - The character string.\n */\n\n/**\n * An array of the whitespace char codes, string, descriptions and language\n * presence in the specifications.\n *\n * @type Array.\n */\nexport const list = [\n {\n code: 0x0009,\n description: 'Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0009',\n },\n {\n code: 0x000a,\n description: 'Line Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000a',\n },\n {\n code: 0x000b,\n description: 'Vertical Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000b',\n },\n {\n code: 0x000c,\n description: 'Form Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000c',\n },\n {\n code: 0x000d,\n description: 'Carriage Return',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000d',\n },\n {\n code: 0x0020,\n description: 'Space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0020',\n },\n /*\n {\n code: 0x0085,\n description: 'Next line',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u0085'\n }\n */\n {\n code: 0x00a0,\n description: 'No-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u00a0',\n },\n {\n code: 0x1680,\n description: 'Ogham space mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u1680',\n },\n {\n code: 0x180e,\n description: 'Mongolian vowel separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: false,\n es2018: false,\n string: '\\u180e',\n },\n {\n code: 0x2000,\n description: 'En quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2000',\n },\n {\n code: 0x2001,\n description: 'Em quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2001',\n },\n {\n code: 0x2002,\n description: 'En space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2002',\n },\n {\n code: 0x2003,\n description: 'Em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2003',\n },\n {\n code: 0x2004,\n description: 'Three-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2004',\n },\n {\n code: 0x2005,\n description: 'Four-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2005',\n },\n {\n code: 0x2006,\n description: 'Six-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2006',\n },\n {\n code: 0x2007,\n description: 'Figure space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2007',\n },\n {\n code: 0x2008,\n description: 'Punctuation space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2008',\n },\n {\n code: 0x2009,\n description: 'Thin space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2009',\n },\n {\n code: 0x200a,\n description: 'Hair space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u200a',\n },\n /*\n {\n code: 0x200b,\n description: 'Zero width space',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u200b'\n },\n */\n {\n code: 0x2028,\n description: 'Line separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2028',\n },\n {\n code: 0x2029,\n description: 'Paragraph separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2029',\n },\n {\n code: 0x202f,\n description: 'Narrow no-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u202f',\n },\n {\n code: 0x205f,\n description: 'Medium mathematical space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u205f',\n },\n {\n code: 0x3000,\n description: 'Ideographic space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u3000',\n },\n {\n code: 0xfeff,\n description: 'Byte Order Mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\ufeff',\n },\n];\n\n/**\n * A string of the ES5 to ES2016 whitespace characters.\n *\n * @type string\n */\nlet stringES2016 = '';\n\n/**\n * A string of the ES2017 to ES2018 whitespace characters.\n *\n * @type string\n */\nlet stringES2018 = '';\nconst {length} = list;\nfor (let i = 0; i < length; i += 1) {\n if (list[i].es2016) {\n stringES2016 += list[i].string;\n }\n\n if (list[i].es2018) {\n stringES2018 += list[i].string;\n }\n}\n\nconst string2018 = stringES2018;\n\nexport default string2018;\nexport const string2016 = stringES2016;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reLeft = new RegExpCtr(`^[${whiteSpace}]+`);\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method removes whitespace from the start of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the left end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The left trimmed string.\n */\nconst trimStart = function trimStart(string) {\n return methodizedReplace(requireCoercibleToString(string), reLeft, EMPTY_STRING);\n};\n\nexport default trimStart;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reRight = new RegExpCtr(`[${whiteSpace}]+$`);\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method removes whitespace from the end of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the right end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The right trimmed string.\n */\nconst trimEnd = function trimEnd(string) {\n return methodizedReplace(requireCoercibleToString(string), reRight, EMPTY_STRING);\n};\n\nexport default trimEnd;\n","import trimStart from 'trim-left-x';\nimport trimEnd from 'trim-right-x';\n\n/**\n * This method removes whitespace from the start and end of a string.\n * (ES2019).\n *\n * @param {string} [string] - The string to trim the whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The trimmed string.\n */\nconst trim = function trim(string) {\n return trimStart(trimEnd(string));\n};\n\nexport default trim;\n","import trim from 'trim-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst SPACE = ' ';\nconst RegExpCtr = /none/.constructor;\nconst reNormalize = new RegExpCtr(`[${whiteSpace}]+`, 'g');\nconst methodizedReplace = methodize(SPACE.replace);\n\n/**\n * This method strips leading and trailing white-space from a string,\n * replaces sequences of whitespace characters by a single space,\n * and returns the resulting string. (ES2019).\n *\n * @param {string} [string] - The string to be normalized.\n * @throws {TypeError} If string is null or undefined or not coercible.\n */\nconst normalizeSpace = function normalizeSpace(string) {\n return methodizedReplace(trim(string), reNormalize, SPACE);\n};\n\nexport default normalizeSpace;\n","import toStr from 'to-string-x';\nimport requireCoercibleToString from 'require-coercible-to-string-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/gm;\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method replaces comments in a string.\n *\n * @param {string} [string] - The string to be stripped.\n * @param {string} [replacement=''] - The string to be used as a replacement.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @throws {TypeError} If replacement is not coercible.\n * @returns {string} The new string with the comments replaced.\n */\nconst replaceComments = function replaceComments(string, replacement) {\n return methodizedReplace(\n requireCoercibleToString(string),\n STRIP_COMMENTS,\n arguments.length > 1 ? toStr(replacement) : EMPTY_STRING,\n );\n};\n\nexport default replaceComments;\n","import attempt from 'attempt-x';\nimport toBoolean from 'to-boolean-x';\nimport toStringTag from 'to-string-tag-x';\nimport hasToStringTag from 'has-to-string-tag-x';\nimport isPrimitive from 'is-primitive-x';\nimport normalise from 'normalize-space-x';\nimport deComment from 'replace-comments-x';\nimport methodize from 'simple-methodize-x';\n\nconst FunctionCtr = attempt.constructor;\nconst SPACE = ' ';\nconst methodizedFunctionToString = methodize(attempt.toString);\nconst funcTag = '[object Function]';\nconst genTag = '[object GeneratorFunction]';\nconst asyncTag = '[object AsyncFunction]';\nconst ctrRx = /^class /;\nconst methodizedTest = methodize(ctrRx.test);\n\nconst hasNativeClass =\n attempt(function attemptee() {\n /* eslint-disable-next-line babel/new-cap */\n return FunctionCtr('\"use strict\"; return class My {};')();\n }).threw === false;\n\nconst testClassString = function testClassString(value) {\n return methodizedTest(ctrRx, normalise(deComment(methodizedFunctionToString(value), SPACE)));\n};\n\nconst isES6ClassFn = function isES6ClassFunc(value) {\n const result = attempt(testClassString, value);\n\n return result.threw === false && result.value;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @private\n * @param {*} value - The value to check.\n * @param {boolean} allowClass - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst tryFuncToString = function funcToString(value, allowClass) {\n if (hasNativeClass && allowClass === false && isES6ClassFn(value)) {\n return false;\n }\n\n return (\n attempt(function attemptee() {\n return methodizedFunctionToString(value);\n }).threw === false\n );\n};\n\nconst compareTags = function compareTags(value) {\n const strTag = toStringTag(value);\n\n return strTag === funcTag || strTag === genTag || strTag === asyncTag;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @param {*} value - The value to check.\n * @param {boolean} [allowClass=false] - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst isFunction = function isFunction(value, allowClass) {\n if (isPrimitive(value)) {\n return false;\n }\n\n if (hasToStringTag) {\n return tryFuncToString(value, toBoolean(allowClass));\n }\n\n if (hasNativeClass && toBoolean(allowClass) === false && isES6ClassFn(value)) {\n return false;\n }\n\n return compareTags(value);\n};\n\nexport default isFunction;\n","import hasSymbols from 'has-symbol-support-x';\nimport isPrimitive from 'is-primitive-x';\nimport isDate from 'is-date-object';\nimport isSymbol from 'is-symbol';\nimport isFunction from 'is-function-x';\nimport requireObjectCoercible from 'require-object-coercible-x';\nimport isNil from 'is-nil-x';\nimport call from 'simple-call-x';\n\nconst ZERO = 0;\nconst ONE = 1;\n/* eslint-disable-next-line no-void */\nconst UNDEFINED = void ZERO;\nconst NUMBER = 'number';\nconst STRING = 'string';\nconst DEFAULT = 'default';\nconst StringCtr = STRING.constructor;\nconst NumberCtr = ZERO.constructor;\n/* eslint-disable-next-line compat/compat */\nconst symToPrimitive = hasSymbols && Symbol.toPrimitive;\n/* eslint-disable-next-line compat/compat */\nconst symValueOf = hasSymbols && Symbol.prototype.valueOf;\n\nconst toStringOrder = ['toString', 'valueOf'];\nconst toNumberOrder = ['valueOf', 'toString'];\nconst orderLength = 2;\n\nconst assertHint = function assertHint(hint) {\n if (typeof hint !== 'string' || (hint !== NUMBER && hint !== STRING)) {\n throw new TypeError('hint must be \"string\" or \"number\"');\n }\n\n return hint;\n};\n\n/**\n * @param {*} ordinary - The ordinary to convert.\n * @param {*} hint - The hint.\n * @returns {*} - The primitive.\n */\nconst ordinaryToPrimitive = function ordinaryToPrimitive(ordinary, hint) {\n requireObjectCoercible(ordinary);\n assertHint(hint);\n\n const methodNames = hint === STRING ? toStringOrder : toNumberOrder;\n for (let i = ZERO; i < orderLength; i += ONE) {\n const method = ordinary[methodNames[i]];\n\n if (isFunction(method)) {\n const result = call(method, ordinary);\n\n if (isPrimitive(result)) {\n return result;\n }\n }\n }\n\n throw new TypeError('No default value');\n};\n\n/**\n * @param {*} object - The object.\n * @param {*} property - The property.\n * @returns {undefined|Function} - The method.\n */\nconst getMethod = function getMethod(object, property) {\n const func = object[property];\n\n if (isNil(func) === false) {\n if (isFunction(func) === false) {\n throw new TypeError(`${func} returned for property ${property} of object ${object} is not a function`);\n }\n\n return func;\n }\n\n return UNDEFINED;\n};\n\n/**\n * Get the hint.\n *\n * @param {*} value - The value to compare.\n * @param {boolean} supplied - Was a value supplied.\n * @returns {string} - The hint string.\n */\nconst getHint = function getHint(value, supplied) {\n if (supplied) {\n if (value === StringCtr) {\n return STRING;\n }\n\n if (value === NumberCtr) {\n return NUMBER;\n }\n }\n\n return DEFAULT;\n};\n\n/**\n * Get the primitive from the exotic.\n *\n * @param {*} value - The exotic.\n * @returns {*} - The primitive.\n */\nconst getExoticToPrim = function getExoticToPrim(value) {\n if (hasSymbols) {\n if (symToPrimitive) {\n return getMethod(value, symToPrimitive);\n }\n\n if (isSymbol(value)) {\n return symValueOf;\n }\n }\n\n return UNDEFINED;\n};\n\nconst evalExotic = function evalExotic(obj) {\n const {exoticToPrim, input, hint} = obj;\n const result = call(exoticToPrim, input, [hint]);\n\n if (isPrimitive(result)) {\n return result;\n }\n\n throw new TypeError('unable to convert exotic object to primitive');\n};\n\nconst evalPrimitive = function evalPrimitive(input, hint) {\n const newHint = hint === DEFAULT && (isDate(input) || isSymbol(input)) ? STRING : hint;\n\n return ordinaryToPrimitive(input, newHint === DEFAULT ? NUMBER : newHint);\n};\n\n/**\n * This method converts a JavaScript object to a primitive value.\n * Note: When toPrimitive is called with no hint, then it generally behaves as\n * if the hint were Number. However, objects may over-ride this behaviour by\n * defining a @@toPrimitive method. Of the objects defined in this specification\n * only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.4) over-ride\n * the default ToPrimitive behaviour. Date objects treat no hint as if the hint\n * were String.\n *\n * @param {*} input - The input to convert.\n * @param {Function} [preferredType] - The preferred type (String or Number).\n * @throws {TypeError} If unable to convert input to a primitive.\n * @returns {string|number} The converted input as a primitive.\n * @see {http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive}\n */\nconst toPrimitive = function toPrimitive(input, preferredType) {\n if (isPrimitive(input)) {\n return input;\n }\n\n const hint = getHint(preferredType, arguments.length > ONE);\n const exoticToPrim = getExoticToPrim(input);\n\n return typeof exoticToPrim === 'undefined' ? evalPrimitive(input, hint) : evalExotic({exoticToPrim, input, hint});\n};\n\nexport default toPrimitive;\n","/**\n * The constant NaN derived mathematically by 0 / 0.\n *\n * @type number\n */\nconst constantNAN = 0 / 0;\n\nexport default constantNAN;\n","import NAN from 'nan-x';\nimport toStr from 'to-string-x';\nimport trimLeft from 'trim-left-x';\nimport methodize from 'simple-methodize-x';\n\nconst nativeParseInt = parseInt;\n/** @type {Function} */\nconst castNumber = (0).constructor;\nconst BAD_CHAR = '\\u180E';\nconst methodizedCharAt = methodize(BAD_CHAR.charAt);\nconst hexRegex = /^[-+]?0[xX]/;\nconst methodizedTest = methodize(hexRegex.test);\n\n/**\n * This method parses a string argument and returns an integer of the specified\n * radix (the base in mathematical numeral systems). (ES2019).\n *\n * @param {string} [string] - The value to parse. If the string argument is not a\n * string, then it is converted to a string (using the ToString abstract\n * operation). Leading whitespace in the string argument is ignored.\n * @param {number} [radix] - An integer between 2 and 36 that represents the radix\n * (the base in mathematical numeral systems) of the above mentioned string.\n * Specify 10 for the decimal numeral system commonly used by humans. Always\n * specify this parameter to eliminate reader confusion and to guarantee\n * predictable behavior. Different implementations produce different results\n * when a radix is not specified, usually defaulting the value to 10.\n * @throws {TypeError} If target is a Symbol or is not coercible.\n * @returns {number} An integer number parsed from the given string. If the first\n * character cannot be converted to a number, NaN is returned.\n */\nconst $parseInt = function $parseInt(string, radix) {\n const str = trimLeft(toStr(string));\n\n if (methodizedCharAt(str, 0) === BAD_CHAR) {\n return NAN;\n }\n\n return nativeParseInt(str, castNumber(radix) || (methodizedTest(hexRegex, str) ? 16 : 10));\n};\n\nexport default $parseInt;\n","import isSymbol from 'is-symbol';\nimport toPrimitive from 'to-primitive-x';\nimport trim from 'trim-x';\nimport $parseInt from 'parse-int-x';\nimport NAN from 'nan-x';\nimport methodize from 'simple-methodize-x';\n\nconst binaryRadix = 2;\nconst octalRadix = 8;\nconst testCharsCount = 2;\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a number';\n\nconst castNumber = testCharsCount.constructor;\nconst methodizedStringSlice = methodize(ERROR_MESSAGE.slice);\n\nconst binaryRegex = /^0b[01]+$/i;\nconst RegExpConstructor = binaryRegex.constructor;\n// Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is\n// an own property of regexes. wtf.\nconst methodizedTest = methodize(binaryRegex.test);\nconst isBinary = function isBinary(value) {\n return methodizedTest(binaryRegex, value);\n};\n\nconst octalRegex = /^0o[0-7]+$/i;\nconst isOctal = function isOctal(value) {\n return methodizedTest(octalRegex, value);\n};\n\nconst nonWSregex = new RegExpConstructor('[\\u0085\\u180e\\u200b\\ufffe]', 'g');\nconst hasNonWS = function hasNonWS(value) {\n return methodizedTest(nonWSregex, value);\n};\n\nconst invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i;\nconst isInvalidHexLiteral = function isInvalidHexLiteral(value) {\n return methodizedTest(invalidHexLiteral, value);\n};\n\nconst assertNotSymbol = function assertNotSymbol(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return value;\n};\n\nconst parseBase = function parseBase(value, radix) {\n return $parseInt(methodizedStringSlice(value, testCharsCount), radix);\n};\n\nconst parseString = function parseString(toNum, value) {\n if (isBinary(value)) {\n return toNum(parseBase(value, binaryRadix));\n }\n\n if (isOctal(value)) {\n return toNum(parseBase(value, octalRadix));\n }\n\n return null;\n};\n\nconst convertString = function convertString(toNum, value) {\n const val = parseString(toNum, value);\n\n if (val !== null) {\n return val;\n }\n\n if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n return NAN;\n }\n\n const trimmed = trim(value);\n\n if (trimmed !== value) {\n return toNum(trimmed);\n }\n\n return null;\n};\n\n/**\n * This method converts argument to a value of type Number. (ES2019).\n *\n * @param {*} [argument] - The argument to convert to a number.\n * @throws {TypeError} - If argument is a Symbol or not coercible.\n * @returns {*} The argument converted to a number.\n */\nconst toNumber = function toNumber(argument) {\n const value = assertNotSymbol(toPrimitive(argument, castNumber));\n\n if (typeof value === 'string') {\n const val = convertString(toNumber, value);\n\n if (val !== null) {\n return val;\n }\n }\n\n return castNumber(value);\n};\n\nexport default toNumber;\n","/**\n * This method determines whether the passed value is NaN and its type is\n * `Number`. It is a more robust version of the original, global isNaN().\n *\n * @param {*} [value] - The value to be tested for NaN.\n * @returns {boolean} `true` if the given value is NaN and its type is Number;\n * otherwise, `false`.\n */\nconst isNaN = function isNaN(value) {\n /* eslint-disable-next-line no-self-compare */\n return value !== value;\n};\n\nexport default isNaN;\n","import toNumber from 'to-number-x';\nimport numberIsNaN from 'is-nan-x';\n\n/**\n * This method returns the sign of a number, indicating whether the number is positive,\n * negative or zero. (ES2019).\n *\n * @param {*} x - A number.\n * @returns {number} A number representing the sign of the given argument. If the argument\n * is a positive number, negative number, positive zero or negative zero, the function will\n * return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned.\n */\nconst sign = function sign(x) {\n const n = toNumber(x);\n\n if (n === 0 || numberIsNaN(n)) {\n return n;\n }\n\n return n > 0 ? 1 : -1;\n};\n\nexport default sign;\n"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/math-sign-x.min.js b/dist/math-sign-x.min.js index 483710f..dd58820 100644 --- a/dist/math-sign-x.min.js +++ b/dist/math-sign-x.min.js @@ -2,20 +2,14 @@ { "author": "Graham Fairweather", "copywrite": "Copyright (c) 2017", - "date": "2019-08-20T13:04:04.195Z", + "date": "2019-08-20T19:18:30.346Z", "describe": "", "description": "Shim for Math.sign.", "file": "math-sign-x.min.js", - "hash": "7798e7879034996b68f6", + "hash": "46faf3052038ab79e3fa", "license": "MIT", - "version": "4.2.0" + "version": "4.2.1" } */ -!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.mathSignX=t():e.mathSignX=t()}(function(){"use strict";var e,t={}.constructor,r=t.prototype,n=t.defineProperty,o=function(){return"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:void 0},i=function(){return this};try{return n?n(r,"$$globalThis$$",{get:i,configurable:!0}):r.__defineGetter__("$$globalThis$$",i),e="undefined"==typeof $$globalThis$$?o():$$globalThis$$,delete r.$$globalThis$$,e}catch(e){return o()}}(),function(){return function(e){var t={};function r(n){if(t[n])return t[n].exports;var o=t[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=e,r.c=t,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(e,t){if(1&t&&(e=r(e)),8&t)return e;if(4&t&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&t&&"string"!=typeof e)for(var o in e)r.d(n,o,function(t){return e[t]}.bind(null,o));return n},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=6)}([function(e,t,r){"use strict";var n=Object.prototype.toString;if(r(3)()){var o=Symbol.prototype.toString,i=/^Symbol\(.*\)$/;e.exports=function(e){if("symbol"==typeof e)return!0;if("[object Symbol]"!==n.call(e))return!1;try{return function(e){return"symbol"==typeof e.valueOf()&&i.test(o.call(e))}(e)}catch(e){return!1}}}else e.exports=function(e){return!1}},function(e,t,r){"use strict"; -/*! - * is-primitive - * - * Copyright (c) 2014-present, Jon Schlinkert. - * Released under the MIT License. - */e.exports=function(e){return"object"==typeof e?null===e:"function"!=typeof e}},function(e,t,r){"use strict";var n=Date.prototype.getDay,o=Object.prototype.toString,i="function"==typeof Symbol&&"symbol"==typeof Symbol.toStringTag;e.exports=function(e){return"object"==typeof e&&null!==e&&(i?function(e){try{return n.call(e),!0}catch(e){return!1}}(e):"[object Date]"===o.call(e))}},function(e,t,r){"use strict";(function(t){var n=t.Symbol,o=r(5);e.exports=function(){return"function"==typeof n&&("function"==typeof Symbol&&("symbol"==typeof n("foo")&&("symbol"==typeof Symbol("bar")&&o())))}}).call(this,r(4))},function(e,t){var r;r=function(){return this}();try{r=r||new Function("return this")()}catch(e){"object"==typeof window&&(r=window)}e.exports=r},function(e,t,r){"use strict";e.exports=function(){if("function"!=typeof Symbol||"function"!=typeof Object.getOwnPropertySymbols)return!1;if("symbol"==typeof Symbol.iterator)return!0;var e={},t=Symbol("test"),r=Object(t);if("string"==typeof t)return!1;if("[object Symbol]"!==Object.prototype.toString.call(t))return!1;if("[object Symbol]"!==Object.prototype.toString.call(r))return!1;for(t in e[t]=42,e)return!1;if("function"==typeof Object.keys&&0!==Object.keys(e).length)return!1;if("function"==typeof Object.getOwnPropertyNames&&0!==Object.getOwnPropertyNames(e).length)return!1;var n=Object.getOwnPropertySymbols(e);if(1!==n.length||n[0]!==t)return!1;if(!Object.prototype.propertyIsEnumerable.call(e,t))return!1;if("function"==typeof Object.getOwnPropertyDescriptor){var o=Object.getOwnPropertyDescriptor(e,t);if(42!==o.value||!0!==o.enumerable)return!1}return!0}},function(e,t,r){"use strict";r.r(t);var n=r(0),o=r.n(n),i=function(e){try{for(var t=arguments.length,r=new Array(t>1?t-1:0),n=1;n1?w(t):"")},G=i.constructor,L=i.toString,B=/^class /,H=B.test,R=!1===i(function(){return G('"use strict"; return class My {};')()}).threw,U=function(e){return H.call(B,A(q(L.call(e)," ")))},V=function(e){var t=i(U,e);return!1===t.threw&&t.value},z=function(e,t){return!a()(e)&&(b?function(e,t){return!(R&&!1===t&&V(e)||!1!==i.call(e,L).threw)}(e,p(t)):(!R||!1!==p(t)||!V(e))&&function(e){var t=y(e);return"[object Function]"===t||"[object GeneratorFunction]"===t||"[object AsyncFunction]"===t}(e))},J="string".constructor,K=(0).constructor,Q=c&&Symbol.toPrimitive,W=c&&Symbol.prototype.valueOf,Y=["toString","valueOf"],Z=["valueOf","toString"],ee=function(e,t){m(e),function(e){if("string"!=typeof e||"number"!==e&&"string"!==e)throw new TypeError('hint must be "string" or "number"')}(t);for(var r,n,o="string"===t?Y:Z,i=0;i<2;i+=1)if(r=e[o[i]],z(r)&&(n=r.call(e),a()(n)))return n;throw new TypeError("No default value")},te=function(e,t){if(t){if(e===J)return"string";if(e===K)return"number"}return"default"},re=function(e){if(c){if(Q)return function(e,t){var r=e[t];if(!1===g(r)){if(!1===z(r))throw new TypeError("".concat(r," returned for property ").concat(t," of object ").concat(e," is not a function"));return r}}(e,Q);if(o()(e))return W}},ne=function(e){var t=e.exoticToPrim,r=e.input,n=e.hint,o=t.call(r,n);if(a()(o))return o;throw new TypeError("unable to convert exotic object to primitive")},oe=function(e,t){var r="default"===t&&(l()(e)||o()(e))?"string":t;return ee(e,"default"===r?"number":r)},ie=function(e,t){if(a()(e))return e;var r=te(t,arguments.length>1),n=re(e);return void 0===n?oe(e,r):ne({exoticToPrim:n,input:e,hint:r})},se=parseInt,ce=(0).constructor,ue="".charAt,ae=/^[-+]?0[xX]/,fe=ae.test,le=function(e,t){var r=N(w(e));return"᠎"===ue.call(r,0)?NaN:se(r,ce(t)||(fe.call(ae,r)?16:10))},pe=2..constructor,de="Cannot convert a Symbol value to a number".slice,ye=/^0b[01]+$/i,be=ye.test,ge=/^0o[0-7]+$/i,me=new(0,ye.constructor)("[…᠎​￾]","g"),ve=/^[-+]0x[0-9a-f]+$/i,he=function(e,t){return le(de.call(e,2),t)},we=function(e,t){return function(e){return be.call(ye,e)}(t)?e(he(t,2)):function(e){return be.call(ge,e)}(t)?e(he(t,8)):null},Se=function(e,t){var r=we(e,t);if(null!==r)return r;if(function(e){return be.call(me,e)}(t)||function(e){return be.call(ve,e)}(t))return NaN;var n=k(t);return n!==t?e(n):null},je=function e(t){var r=function(e){if(o()(e))throw new TypeError("Cannot convert a Symbol value to a number");return e}(ie(t,pe));if("string"==typeof r){var n=Se(e,r);if(null!==n)return n}return pe(r)},Oe=function(e){return e!=e};t.default=function(e){var t=je(e);return 0===t||Oe(t)?t:t>0?1:-1}}])}); +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.mathSignX=e():t.mathSignX=e()}(function(){"use strict";var t,e={}.constructor,n=e.prototype,r=e.defineProperty,o=function(){return"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:void 0},i=function(){return this};try{return r?r(n,"$$globalThis$$",{get:i,configurable:!0}):n.__defineGetter__("$$globalThis$$",i),t="undefined"==typeof $$globalThis$$?o():$$globalThis$$,delete n.$$globalThis$$,t}catch(t){return o()}}(),function(){return function(t){var e={};function n(r){if(e[r])return e[r].exports;var o=e[r]={i:r,l:!1,exports:{}};return t[r].call(o.exports,o,o.exports,n),o.l=!0,o.exports}return n.m=t,n.c=e,n.d=function(t,e,r){n.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:r})},n.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})},n.t=function(t,e){if(1&e&&(t=n(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var r=Object.create(null);if(n.r(r),Object.defineProperty(r,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)n.d(r,o,function(e){return t[e]}.bind(null,o));return r},n.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return n.d(e,"a",e),e},n.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},n.p="",n(n.s=6)}([function(t,e,n){"use strict";var r=Object.prototype.toString;if(n(3)()){var o=Symbol.prototype.toString,i=/^Symbol\(.*\)$/;t.exports=function(t){if("symbol"==typeof t)return!0;if("[object Symbol]"!==r.call(t))return!1;try{return function(t){return"symbol"==typeof t.valueOf()&&i.test(o.call(t))}(t)}catch(t){return!1}}}else t.exports=function(t){return!1}},function(t,e,n){"use strict";var r=String.prototype.valueOf,o=Object.prototype.toString,i="function"==typeof Symbol&&"symbol"==typeof Symbol.toStringTag;t.exports=function(t){return"string"==typeof t||"object"==typeof t&&(i?function(t){try{return r.call(t),!0}catch(t){return!1}}(t):"[object String]"===o.call(t))}},function(t,e,n){"use strict";var r=Date.prototype.getDay,o=Object.prototype.toString,i="function"==typeof Symbol&&"symbol"==typeof Symbol.toStringTag;t.exports=function(t){return"object"==typeof t&&null!==t&&(i?function(t){try{return r.call(t),!0}catch(t){return!1}}(t):"[object Date]"===o.call(t))}},function(t,e,n){"use strict";(function(e){var r=e.Symbol,o=n(5);t.exports=function(){return"function"==typeof r&&("function"==typeof Symbol&&("symbol"==typeof r("foo")&&("symbol"==typeof Symbol("bar")&&o())))}}).call(this,n(4))},function(t,e){var n;n=function(){return this}();try{n=n||new Function("return this")()}catch(t){"object"==typeof window&&(n=window)}t.exports=n},function(t,e,n){"use strict";t.exports=function(){if("function"!=typeof Symbol||"function"!=typeof Object.getOwnPropertySymbols)return!1;if("symbol"==typeof Symbol.iterator)return!0;var t={},e=Symbol("test"),n=Object(e);if("string"==typeof e)return!1;if("[object Symbol]"!==Object.prototype.toString.call(e))return!1;if("[object Symbol]"!==Object.prototype.toString.call(n))return!1;for(e in t[e]=42,t)return!1;if("function"==typeof Object.keys&&0!==Object.keys(t).length)return!1;if("function"==typeof Object.getOwnPropertyNames&&0!==Object.getOwnPropertyNames(t).length)return!1;var r=Object.getOwnPropertySymbols(t);if(1!==r.length||r[0]!==e)return!1;if(!Object.prototype.propertyIsEnumerable.call(t,e))return!1;if("function"==typeof Object.getOwnPropertyDescriptor){var o=Object.getOwnPropertyDescriptor(t,e);if(42!==o.value||!0!==o.enumerable)return!1}return!0}},function(t,e,n){"use strict";n.r(e);var r=n(0),o=n.n(r);function i(t){return(i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t})(t)}var u=function(t){return"object"===i(t)?null===t:"function"!=typeof t},c=n(1),s=n.n(c),f={}.constructor("a"),a="a"===f[0]&&0 in f,l=function(){}.bind,p="function"==typeof l&&function(){var t=null,e=null,n=null,r=[];try{var o=l.apply(function(r,o){return n=this,t=r,e=o,arguments},[r,1]),i=o(2);return 1===o.length&&2===i.length&&1===t&&2===e&&n===r}catch(t){return!1}}()&&function(){var t=null,e=null,n=null,r=[1,2,3],o=function(o,i){return t=o,e=i,n=this,r};try{var i=l.apply(o,[null]),u=new i(1,2);return i.length===o.length&&u===r&&1===t&&2===e&&n!==r}catch(t){return!1}}(),y="".split,b=Math.max,d=u.bind,g=u.call,h=p?d.call(g,y):function(t,e){return y.call(t,e)},m=function(t){return s()(t)?h(t,""):t},v=function(t,e){var n=arguments.length>2?arguments[2]:[];if("string"!=typeof t&&u(t))return n;for(var r=a?t:m(t),o=r.length,i=b(0,e)||0;i=e?t:e},E=function(t){if("function"!=typeof t&&"[object Function]"!==$.apply(t))throw new TypeError("bind called on incompatible "+t)},P=[function(t){return function(){return t.apply(this,v(arguments))}},function(t,e){return function(n){return t.apply(this,v(arguments,e,[n]))}},function(t,e){return function(n,r){return t.apply(this,v(arguments,e,[n,r]))}},function(t,e){return function(n,r,o){return t.apply(this,v(arguments,e,[n,r,o]))}},function(t,e){return function(n,r,o,i){return t.apply(this,v(arguments,e,[n,r,o,i]))}},function(t,e){return function(n,r,o,i,u){return t.apply(this,v(arguments,e,[n,r,o,i,u]))}},function(t,e){return function(n,r,o,i,u,c){return t.apply(this,v(arguments,e,[n,r,o,i,u,c]))}},function(t,e){return function(n,r,o,i,u,c,s){return t.apply(this,v(arguments,e,[n,r,o,i,u,c,s]))}},function(t,e){return function(n,r,o,i,u,c,s,f){return t.apply(this,v(arguments,e,[n,r,o,i,u,c,s,f]))}}],F=function(t){var e=S(t,3),n=e[0],r=e[1],o=e[2],i=x(0,r.length-x(0,o.length-2)),u=P[i],c=u?u(n,i):P[0](n);if(r.prototype){var s=function(){};s.prototype=r.prototype,c.prototype=new s,s.prototype=null}return c},N=function(t,e){var n=t.apply(this,e);return T(n)===n?n:this},_=p?j.bind(w):function(t,e){E(t);var n,r=arguments,o=function(){var o=v(arguments,0,v(r,2));return this instanceof n?N.apply(this,[t,o]):t.apply(e,o)};return n=F([o,t,r])},M=TypeError,C=_.apply,k=_(_.call,C),D=_(C,{}.toString),A=function(t){if("function"!=typeof t&&"[object Function]"!==D(t))throw new M(t+" is not a function");return t},I=function(t,e){return k(A(t),e,v(arguments[2]))},X=function(t){try{return{threw:!1,value:I(t,this,v(arguments,1))}}catch(t){return{threw:!0,value:t}}};for(var q=X(function(){return function(t,e){if(t!==e)throw new TypeError("Cannot instantiate an arrow function")}(this,void 0),"function"==typeof Symbol&&o()(Symbol(""))}.bind(void 0)),G=!1===q.threw&&!0===q.value,L=n(2),z=n.n(L),B=function(t){return!!t},H={}.toString,R=function(t){return function(t){if("function"!=typeof t&&"[object Function]"!==I(H,t))throw new TypeError("methodize called on incompatible "+t)}(t),function(){return I(t,arguments[0],v(arguments,1))}},U=R({}.toString),V=function(t){return null===t?"[object Null]":void 0===t?"[object Undefined]":U(t)},J=G&&o()(Symbol.toStringTag),K=function(t){return null==t},Q=function(t){if(K(t))throw new TypeError("Cannot call method on ".concat(t));return t},W="Cannot convert a Symbol value to a string".constructor,Y=function(t){if(o()(t))throw new TypeError("Cannot convert a Symbol value to a string");return W(t)},Z=function(t){return Y(Q(t))},tt=[{code:9,description:"Tab",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\t"},{code:10,description:"Line Feed",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\n"},{code:11,description:"Vertical Tab",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\v"},{code:12,description:"Form Feed",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\f"},{code:13,description:"Carriage Return",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\r"},{code:32,description:"Space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:160,description:"No-break space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:5760,description:"Ogham space mark",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:6158,description:"Mongolian vowel separator",es5:!0,es2015:!0,es2016:!0,es2017:!1,es2018:!1,string:"᠎"},{code:8192,description:"En quad",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8193,description:"Em quad",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8194,description:"En space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8195,description:"Em space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8196,description:"Three-per-em space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8197,description:"Four-per-em space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8198,description:"Six-per-em space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8199,description:"Figure space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8200,description:"Punctuation space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8201,description:"Thin space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8202,description:"Hair space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8232,description:"Line separator",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\u2028"},{code:8233,description:"Paragraph separator",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\u2029"},{code:8239,description:"Narrow no-break space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:8287,description:"Medium mathematical space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:" "},{code:12288,description:"Ideographic space",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"　"},{code:65279,description:"Byte Order Mark",es5:!0,es2015:!0,es2016:!0,es2017:!0,es2018:!0,string:"\ufeff"}],et="",nt=tt.length,rt=0;rt1?Y(e):"")},mt=X.constructor,vt=R(X.toString),St=/^class /,wt=R(St.test),jt=!1===X(function(){return mt('"use strict"; return class My {};')()}).threw,Ot=function(t){return wt(St,bt(ht(vt(t)," ")))},Tt=function(t){var e=X(Ot,t);return!1===e.threw&&e.value},$t=function(t,e){return!u(t)&&(J?function(t,e){return!(jt&&!1===e&&Tt(t)||!1!==X(function(){return vt(t)}).threw)}(t,B(e)):(!jt||!1!==B(e)||!Tt(t))&&function(t){var e=V(t);return"[object Function]"===e||"[object GeneratorFunction]"===e||"[object AsyncFunction]"===e}(t))},xt="string".constructor,Et=(0).constructor,Pt=G&&Symbol.toPrimitive,Ft=G&&Symbol.prototype.valueOf,Nt=["toString","valueOf"],_t=["valueOf","toString"],Mt=function(t,e){Q(t),function(t){if("string"!=typeof t||"number"!==t&&"string"!==t)throw new TypeError('hint must be "string" or "number"')}(e);for(var n="string"===e?Nt:_t,r=0;r<2;r+=1){var o=t[n[r]];if($t(o)){var i=I(o,t);if(u(i))return i}}throw new TypeError("No default value")},Ct=function(t,e){if(e){if(t===xt)return"string";if(t===Et)return"number"}return"default"},kt=function(t){if(G){if(Pt)return function(t,e){var n=t[e];if(!1===K(n)){if(!1===$t(n))throw new TypeError("".concat(n," returned for property ").concat(e," of object ").concat(t," is not a function"));return n}}(t,Pt);if(o()(t))return Ft}},Dt=function(t){var e=t.exoticToPrim,n=t.input,r=t.hint,o=I(e,n,[r]);if(u(o))return o;throw new TypeError("unable to convert exotic object to primitive")},At=function(t,e){var n="default"===e&&(z()(t)||o()(t))?"string":e;return Mt(t,"default"===n?"number":n)},It=function(t,e){if(u(t))return t;var n=Ct(e,arguments.length>1),r=kt(t);return void 0===r?At(t,n):Dt({exoticToPrim:r,input:t,hint:n})},Xt=parseInt,qt=(0).constructor,Gt=R("᠎".charAt),Lt=/^[-+]?0[xX]/,zt=R(Lt.test),Bt=function(t,e){var n=ct(Y(t));return"᠎"===Gt(n,0)?NaN:Xt(n,qt(e)||(zt(Lt,n)?16:10))},Ht=2..constructor,Rt=R("Cannot convert a Symbol value to a number".slice),Ut=/^0b[01]+$/i,Vt=Ut.constructor,Jt=R(Ut.test),Kt=/^0o[0-7]+$/i,Qt=new Vt("[…᠎​￾]","g"),Wt=/^[-+]0x[0-9a-f]+$/i,Yt=function(t,e){return Bt(Rt(t,2),e)},Zt=function(t,e){return function(t){return Jt(Ut,t)}(e)?t(Yt(e,2)):function(t){return Jt(Kt,t)}(e)?t(Yt(e,8)):null},te=function(t,e){var n=Zt(t,e);if(null!==n)return n;if(function(t){return Jt(Qt,t)}(e)||function(t){return Jt(Wt,t)}(e))return NaN;var r=lt(e);return r!==e?t(r):null},ee=function t(e){var n=function(t){if(o()(t))throw new TypeError("Cannot convert a Symbol value to a number");return t}(It(e,Ht));if("string"==typeof n){var r=te(t,n);if(null!==r)return r}return Ht(n)},ne=function(t){return t!=t};e.default=function(t){var e=ee(t);return 0===e||ne(e)?e:e>0?1:-1}}])}); //# sourceMappingURL=math-sign-x.min.js.map \ No newline at end of file diff --git a/dist/math-sign-x.min.js.map b/dist/math-sign-x.min.js.map index ab7c056..d8eab23 100644 --- a/dist/math-sign-x.min.js.map +++ b/dist/math-sign-x.min.js.map @@ -1 +1 @@ -{"version":3,"sources":["webpack://mathSignX/webpack/universalModuleDefinition","webpack://mathSignX/webpack/bootstrap","webpack://mathSignX/./node_modules/is-symbol/index.js","webpack://mathSignX/./node_modules/is-primitive/index.js","webpack://mathSignX/./node_modules/is-date-object/index.js","webpack://mathSignX/./node_modules/has-symbols/index.js","webpack://mathSignX/(webpack)/buildin/global.js","webpack://mathSignX/./node_modules/has-symbols/shams.js","webpack://mathSignX/../src/attempt-x.js","webpack://mathSignX/../src/white-space-x.js","webpack://mathSignX/../src/has-symbol-support-x.js","webpack://mathSignX/../src/to-boolean-x.js","webpack://mathSignX/../src/to-string-tag-x.js","webpack://mathSignX/../src/has-to-string-tag-x.js","webpack://mathSignX/../src/is-nil-x.js","webpack://mathSignX/../src/require-object-coercible-x.js","webpack://mathSignX/../src/to-string-x.js","webpack://mathSignX/../src/require-coercible-to-string-x.js","webpack://mathSignX/../src/trim-left-x.js","webpack://mathSignX/../src/trim-right-x.js","webpack://mathSignX/../src/trim-x.js","webpack://mathSignX/../src/normalize-space-x.js","webpack://mathSignX/../src/replace-comments-x.js","webpack://mathSignX/../src/is-function-x.js","webpack://mathSignX/../src/to-primitive-x.js","webpack://mathSignX/../src/parse-int-x.js","webpack://mathSignX/../src/nan-x.js","webpack://mathSignX/../src/to-number-x.js","webpack://mathSignX/../src/is-nan-x.js","webpack://mathSignX/../src/math-sign-x.js"],"names":["root","factory","exports","module","define","amd","$globalThis","ObjectCtr","constructor","objectPrototype","prototype","defineProperty","getGlobalFallback","self","window","global","returnThis","this","get","configurable","__defineGetter__","$$globalThis$$","error","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","enumerable","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","hasOwnProperty","p","s","toStr","toString","symToStr","symStringRegex","valueOf","test","isSymbolObject","e","val","getDay","Date","hasToStringTag","tryDateObject","origSymbol","hasSymbolSham","g","Function","getOwnPropertySymbols","iterator","obj","sym","symObj","keys","length","getOwnPropertyNames","syms","propertyIsEnumerable","getOwnPropertyDescriptor","descriptor","attempt_x_esm","fn","_len","arguments","args","Array","_key","threw","apply","hasSymbolSupport","_newArrowCheck","is_symbol_default","undefined","has_symbol_support_x_esm","to_boolean_x_esm","nativeObjectToString","to_string_tag_x_esm","has_to_string_tag_x_esm","is_nil_x_esm","require_object_coercible_x_esm","TypeError","concat","ERROR_MESSAGE","castString","to_string_x_esm","require_coercible_to_string_x_esm","list","code","description","es5","es2015","es2016","es2017","es2018","string","stringES2018","white_space_x_esm_length","white_space_x_esm_i","white_space_x_esm","reLeft","RegExpCtr","replace","trim_left_x_esm","reRight2018","trim_right_x_esm_RegExpCtr","trim_right_x_esm_replace","trim_right_x_esm","trim_x_esm","reNormalize2018","normalize_space_x_esm_RegExpCtr","normalize_space_x_esm_replace","normalize_space_x_esm","STRIP_COMMENTS","replace_comments_x_esm_replace","replace_comments_x_esm","replacement","FunctionCtr","fToString","ctrRx","hasNativeClass","is_function_x_esm_testClassString","isES6ClassFn","result","is_function_x_esm","allowClass","is_primitive_default","tryFuncToString","strTag","is_function_x_esm_compareTags","StringCtr","NumberCtr","symToPrimitive","toPrimitive","symValueOf","toStringOrder","toNumberOrder","to_primitive_x_esm_ordinaryToPrimitive","ordinary","hint","assertHint","method","methodNames","getHint","supplied","to_primitive_x_esm_getExoticToPrim","func","to_primitive_x_esm_getMethod","to_primitive_x_esm_evalExotic","exoticToPrim","input","to_primitive_x_esm_evalPrimitive","newHint","is_date_object_default","to_primitive_x_esm","preferredType","nativeParseInt","parseInt","castNumber","charAt","hexRegex","parse_int_x_esm_test","parse_int_x_esm","radix","str","to_number_x_esm_castNumber","pStrSlice","slice","binaryRegex","to_number_x_esm_test","octalRegex","nonWSregex","RegExpConstructor","invalidHexLiteral","to_number_x_esm_parseBase","parseString","toNum","isBinary","isOctal","to_number_x_esm_convertString","hasNonWS","isInvalidHexLiteral","trimmed","to_number_x_esm","toNumber","argument","to_number_x_esm_assertNotSymbol","is_nan_x_esm","__webpack_exports__","x"],"mappings":"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","file":"math-sign-x.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mathSignX\"] = factory();\n\telse\n\t\troot[\"mathSignX\"] = factory();\n})((function () {\n 'use strict';\n\n var ObjectCtr = {}.constructor;\n var objectPrototype = ObjectCtr.prototype;\n var defineProperty = ObjectCtr.defineProperty;\n var $globalThis;\n var getGlobalFallback = function() {\n if (typeof self !== 'undefined') {\n return self;\n }\n\n if (typeof window !== 'undefined') {\n return window;\n }\n\n if (typeof global !== 'undefined') {\n return global;\n }\n\n return void 0;\n };\n\n var returnThis = function() {\n return this;\n };\n\n try {\n if (defineProperty) {\n defineProperty(objectPrototype, '$$globalThis$$', {\n get: returnThis,\n configurable: true\n });\n } else {\n objectPrototype.__defineGetter__('$$globalThis$$', returnThis);\n }\n\n $globalThis = typeof $$globalThis$$ === 'undefined' ? getGlobalFallback() : $$globalThis$$;\n\n delete objectPrototype.$$globalThis$$;\n\n return $globalThis;\n } catch (error) {\n return getGlobalFallback();\n }\n}()), function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 6);\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n","/*!\n * is-primitive \n *\n * Copyright (c) 2014-present, Jon Schlinkert.\n * Released under the MIT License.\n */\n\n'use strict';\n\nmodule.exports = function isPrimitive(val) {\n if (typeof val === 'object') {\n return val === null;\n }\n return typeof val !== 'function';\n};\n","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateObject(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) { return false; }\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n","'use strict';\n\nvar origSymbol = global.Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict';\n\n/* eslint complexity: [2, 17], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","/**\n * This method attempts to invoke the function, returning either the result or\n * the caught error object. Any additional arguments are provided to the\n * function when it's invoked.\n *\n * @param {Function} [fn] - The function to attempt.\n * @param {...*} [args] - The arguments to invoke the function with.\n * @returns {object} Returns an object of the result.\n */\nconst attempt = function attempt(fn, ...args) {\n try {\n return {\n threw: false,\n /* eslint-disable-next-line babel/no-invalid-this */\n value: fn.apply(this, args),\n };\n } catch (e) {\n return {\n threw: true,\n value: e,\n };\n }\n};\n\nexport default attempt;\n","/**\n * A record of a white space character.\n *\n * @typedef {object} CharRecord\n * @property {number} code - The character code.\n * @property {string} description - A description of the character.\n * @property {boolean} es5 - Whether the spec lists this as a white space.\n * @property {boolean} es2015 - Whether the spec lists this as a white space.\n * @property {boolean} es2016 - Whether the spec lists this as a white space.\n * @property {boolean} es2017 - Whether the spec lists this as a white space.\n * @property {boolean} es2018 - Whether the spec lists this as a white space.\n * @property {string} string - The character string.\n */\n\n/**\n * An array of the whitespace char codes, string, descriptions and language\n * presence in the specifications.\n *\n * @type Array.\n */\nexport const list = [\n {\n code: 0x0009,\n description: 'Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0009',\n },\n {\n code: 0x000a,\n description: 'Line Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000a',\n },\n {\n code: 0x000b,\n description: 'Vertical Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000b',\n },\n {\n code: 0x000c,\n description: 'Form Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000c',\n },\n {\n code: 0x000d,\n description: 'Carriage Return',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000d',\n },\n {\n code: 0x0020,\n description: 'Space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0020',\n },\n /*\n {\n code: 0x0085,\n description: 'Next line',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u0085'\n }\n */\n {\n code: 0x00a0,\n description: 'No-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u00a0',\n },\n {\n code: 0x1680,\n description: 'Ogham space mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u1680',\n },\n {\n code: 0x180e,\n description: 'Mongolian vowel separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: false,\n es2018: false,\n string: '\\u180e',\n },\n {\n code: 0x2000,\n description: 'En quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2000',\n },\n {\n code: 0x2001,\n description: 'Em quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2001',\n },\n {\n code: 0x2002,\n description: 'En space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2002',\n },\n {\n code: 0x2003,\n description: 'Em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2003',\n },\n {\n code: 0x2004,\n description: 'Three-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2004',\n },\n {\n code: 0x2005,\n description: 'Four-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2005',\n },\n {\n code: 0x2006,\n description: 'Six-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2006',\n },\n {\n code: 0x2007,\n description: 'Figure space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2007',\n },\n {\n code: 0x2008,\n description: 'Punctuation space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2008',\n },\n {\n code: 0x2009,\n description: 'Thin space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2009',\n },\n {\n code: 0x200a,\n description: 'Hair space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u200a',\n },\n /*\n {\n code: 0x200b,\n description: 'Zero width space',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u200b'\n },\n */\n {\n code: 0x2028,\n description: 'Line separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2028',\n },\n {\n code: 0x2029,\n description: 'Paragraph separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2029',\n },\n {\n code: 0x202f,\n description: 'Narrow no-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u202f',\n },\n {\n code: 0x205f,\n description: 'Medium mathematical space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u205f',\n },\n {\n code: 0x3000,\n description: 'Ideographic space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u3000',\n },\n {\n code: 0xfeff,\n description: 'Byte Order Mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\ufeff',\n },\n];\n\n/**\n * A string of the ES5 to ES2016 whitespace characters.\n *\n * @type string\n */\nlet stringES2016 = '';\n\n/**\n * A string of the ES2017 to ES2018 whitespace characters.\n *\n * @type string\n */\nlet stringES2018 = '';\nconst {length} = list;\nfor (let i = 0; i < length; i += 1) {\n if (list[i].es2016) {\n stringES2016 += list[i].string;\n }\n\n if (list[i].es2018) {\n stringES2018 += list[i].string;\n }\n}\n\nconst string2018 = stringES2018;\n\nexport default string2018;\nexport const string2016 = stringES2016;\n","import attempt from 'attempt-x';\nimport isSymbol from 'is-symbol';\n\nconst hasSymbolSupport = attempt(() => {\n /* eslint-disable-next-line compat/compat */\n return typeof Symbol === 'function' && isSymbol(Symbol(''));\n});\n\n/**\n * Indicates if `Symbol`exists and creates the correct type.\n * `true`, if it exists and creates the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbolSupport.threw === false && hasSymbolSupport.value === true;\n","/**\n * The abstract operation ToBoolean converts argument to a value of type Boolean.\n *\n * @param {*} [value] - The value to be converted.\n * @returns {boolean} 'true' if value is truthy; otherwise 'false'.\n */\nconst toBoolean = function toBoolean(value) {\n return !!value;\n};\n\nexport default toBoolean;\n","const nativeObjectToString = {}.toString;\n\n/**\n * The `toStringTag` method returns \"[object type]\", where type is the\n * object type.\n *\n * @param {*} [value] - The object of which to get the object type string.\n * @returns {string} The object type string.\n */\nconst toStringTag = function toStringTag(value) {\n if (value === null) {\n return '[object Null]';\n }\n\n if (typeof value === 'undefined') {\n return '[object Undefined]';\n }\n\n return nativeObjectToString.call(value);\n};\n\nexport default toStringTag;\n","import hasSymbols from 'has-symbol-support-x';\nimport isSymbol from 'is-symbol';\n\n/**\n * Indicates if `Symbol.toStringTag`exists and is the correct type.\n * `true`, if it exists and is the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbols &&\n /* eslint-disable-next-line compat/compat */\n isSymbol(Symbol.toStringTag);\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n */\nconst isNil = function isNil(value) {\n /* eslint-disable-next-line lodash/prefer-is-nil */\n return value === null || typeof value === 'undefined';\n};\n\nexport default isNil;\n","import isNil from 'is-nil-x';\n\n/**\n * The abstract operation RequireObjectCoercible throws an error if argument\n * is a value that cannot be converted to an Object using ToObject.\n *\n * @param {*} [value] - The `value` to check.\n * @throws {TypeError} If `value` is a `null` or `undefined`.\n * @returns {string} The `value`.\n */\nconst requireObjectCoercible = function requireObjectCoercible(value) {\n if (isNil(value)) {\n throw new TypeError(`Cannot call method on ${value}`);\n }\n\n return value;\n};\n\nexport default requireObjectCoercible;\n","import isSymbol from 'is-symbol';\n\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a string';\nconst castString = ERROR_MESSAGE.constructor;\n/**\n * The abstract operation ToString converts argument to a value of type String.\n *\n * @param {*} [value] - The value to convert to a string.\n * @throws {TypeError} If `value` is a Symbol.\n * @returns {string} The converted value.\n */\nconst ToString = function ToString(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return castString(value);\n};\n\nexport default ToString;\n","import requireObjectCoercible from 'require-object-coercible-x';\nimport toStr from 'to-string-x';\n\n/**\n * This method requires an argument is corecible then converts using ToString.\n *\n * @param {*} [value] - The value to converted to a string.\n * @throws {TypeError} If value is null or undefined.\n * @returns {string} The value as a string.\n */\nconst requireCoercibleToString = function requireCoercibleToString(value) {\n return toStr(requireObjectCoercible(value));\n};\n\nexport default requireCoercibleToString;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reLeft = new RegExpCtr(`^[${whiteSpace}]+`);\nconst {replace} = EMPTY_STRING;\n/**\n * This method removes whitespace from the start of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the left end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The left trimmed string.\n */\nconst trimStart = function trimStart(string) {\n return replace.call(requireCoercibleToString(string), reLeft, EMPTY_STRING);\n};\n\nexport default trimStart;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reRight2018 = new RegExpCtr(`[${whiteSpace}]+$`);\nconst {replace} = EMPTY_STRING;\n\n/**\n * This method removes whitespace from the end of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the right end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The right trimmed string.\n */\nconst trimEnd = function trimEnd(string) {\n return replace.call(requireCoercibleToString(string), reRight2018, EMPTY_STRING);\n};\n\nexport default trimEnd;\n","import trimStart from 'trim-left-x';\nimport trimEnd from 'trim-right-x';\n\n/**\n * This method removes whitespace from the start and end of a string.\n * (ES2019).\n *\n * @param {string} [string] - The string to trim the whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The trimmed string.\n */\nconst trim = function trim(string) {\n return trimStart(trimEnd(string));\n};\n\nexport default trim;\n","import trim from 'trim-x';\nimport whiteSpace from 'white-space-x';\n\nconst SPACE = ' ';\nconst RegExpCtr = /none/.constructor;\nconst reNormalize2018 = new RegExpCtr(`[${whiteSpace}]+`, 'g');\nconst {replace} = SPACE;\n\n/**\n * This method strips leading and trailing white-space from a string,\n * replaces sequences of whitespace characters by a single space,\n * and returns the resulting string. (ES2019).\n *\n * @param {string} [string] - The string to be normalized.\n * @throws {TypeError} If string is null or undefined or not coercible.\n */\nconst normalizeSpace = function normalizeSpace(string) {\n return replace.call(trim(string), reNormalize2018, SPACE);\n};\n\nexport default normalizeSpace;\n","import toStr from 'to-string-x';\nimport requireCoercibleToString from 'require-coercible-to-string-x';\n\nconst EMPTY_STRING = '';\nconst STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/gm;\nconst {replace} = EMPTY_STRING;\n\n/**\n * This method replaces comments in a string.\n *\n * @param {string} [string] - The string to be stripped.\n * @param {string} [replacement=''] - The string to be used as a replacement.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @throws {TypeError} If replacement is not coercible.\n * @returns {string} The new string with the comments replaced.\n */\nconst replaceComments = function replaceComments(string, replacement) {\n return replace.call(requireCoercibleToString(string), STRIP_COMMENTS, arguments.length > 1 ? toStr(replacement) : EMPTY_STRING);\n};\n\nexport default replaceComments;\n","import attempt from 'attempt-x';\nimport toBoolean from 'to-boolean-x';\nimport toStringTag from 'to-string-tag-x';\nimport hasToStringTag from 'has-to-string-tag-x';\nimport isPrimitive from 'is-primitive';\nimport normalise from 'normalize-space-x';\nimport deComment from 'replace-comments-x';\n\nconst FunctionCtr = attempt.constructor;\nconst SPACE = ' ';\nconst fToString = attempt.toString;\nconst funcTag = '[object Function]';\nconst genTag = '[object GeneratorFunction]';\nconst asyncTag = '[object AsyncFunction]';\nconst ctrRx = /^class /;\nconst {test} = ctrRx;\n\nconst hasNativeClass =\n attempt(function attemptee() {\n /* eslint-disable-next-line babel/new-cap */\n return FunctionCtr('\"use strict\"; return class My {};')();\n }).threw === false;\n\nconst testClassString = function testClassString(value) {\n return test.call(ctrRx, normalise(deComment(fToString.call(value), SPACE)));\n};\n\nconst isES6ClassFn = function isES6ClassFunc(value) {\n const result = attempt(testClassString, value);\n\n return result.threw === false && result.value;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @private\n * @param {*} value - The value to check.\n * @param {boolean} allowClass - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst tryFuncToString = function funcToString(value, allowClass) {\n if (hasNativeClass && allowClass === false && isES6ClassFn(value)) {\n return false;\n }\n\n return attempt.call(value, fToString).threw === false;\n};\n\nconst compareTags = function compareTags(value) {\n const strTag = toStringTag(value);\n\n return strTag === funcTag || strTag === genTag || strTag === asyncTag;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @param {*} value - The value to check.\n * @param {boolean} [allowClass=false] - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst isFunction = function isFunction(value, allowClass) {\n if (isPrimitive(value)) {\n return false;\n }\n\n if (hasToStringTag) {\n return tryFuncToString(value, toBoolean(allowClass));\n }\n\n if (hasNativeClass && toBoolean(allowClass) === false && isES6ClassFn(value)) {\n return false;\n }\n\n return compareTags(value);\n};\n\nexport default isFunction;\n","import hasSymbols from 'has-symbol-support-x';\nimport isPrimitive from 'is-primitive';\nimport isDate from 'is-date-object';\nimport isSymbol from 'is-symbol';\nimport isFunction from 'is-function-x';\nimport requireObjectCoercible from 'require-object-coercible-x';\nimport isNil from 'is-nil-x';\n\nconst ZERO = 0;\nconst ONE = 1;\n/* eslint-disable-next-line no-void */\nconst UNDEFINED = void ZERO;\nconst NUMBER = 'number';\nconst STRING = 'string';\nconst DEFAULT = 'default';\nconst StringCtr = STRING.constructor;\nconst NumberCtr = ZERO.constructor;\n/* eslint-disable-next-line compat/compat */\nconst symToPrimitive = hasSymbols && Symbol.toPrimitive;\n/* eslint-disable-next-line compat/compat */\nconst symValueOf = hasSymbols && Symbol.prototype.valueOf;\n\nconst toStringOrder = ['toString', 'valueOf'];\nconst toNumberOrder = ['valueOf', 'toString'];\nconst orderLength = 2;\n\nconst assertHint = function assertHint(hint) {\n if (typeof hint !== 'string' || (hint !== NUMBER && hint !== STRING)) {\n throw new TypeError('hint must be \"string\" or \"number\"');\n }\n\n return hint;\n};\n\n/**\n * @param {*} ordinary - The ordinary to convert.\n * @param {*} hint - The hint.\n * @returns {*} - The primitive.\n */\nconst ordinaryToPrimitive = function ordinaryToPrimitive(ordinary, hint) {\n requireObjectCoercible(ordinary);\n assertHint(hint);\n\n const methodNames = hint === STRING ? toStringOrder : toNumberOrder;\n let method;\n let result;\n for (let i = ZERO; i < orderLength; i += ONE) {\n method = ordinary[methodNames[i]];\n\n if (isFunction(method)) {\n result = method.call(ordinary);\n\n if (isPrimitive(result)) {\n return result;\n }\n }\n }\n\n throw new TypeError('No default value');\n};\n\n/**\n * @param {*} object - The object.\n * @param {*} property - The property.\n * @returns {undefined|Function} - The method.\n */\nconst getMethod = function getMethod(object, property) {\n const func = object[property];\n\n if (isNil(func) === false) {\n if (isFunction(func) === false) {\n throw new TypeError(`${func} returned for property ${property} of object ${object} is not a function`);\n }\n\n return func;\n }\n\n return UNDEFINED;\n};\n\n/**\n * Get the hint.\n *\n * @param {*} value - The value to compare.\n * @param {boolean} supplied - Was a value supplied.\n * @returns {string} - The hint string.\n */\nconst getHint = function getHint(value, supplied) {\n if (supplied) {\n if (value === StringCtr) {\n return STRING;\n }\n\n if (value === NumberCtr) {\n return NUMBER;\n }\n }\n\n return DEFAULT;\n};\n\n/**\n * Get the primitive from the exotic.\n *\n * @param {*} value - The exotic.\n * @returns {*} - The primitive.\n */\nconst getExoticToPrim = function getExoticToPrim(value) {\n if (hasSymbols) {\n if (symToPrimitive) {\n return getMethod(value, symToPrimitive);\n }\n\n if (isSymbol(value)) {\n return symValueOf;\n }\n }\n\n return UNDEFINED;\n};\n\nconst evalExotic = function evalExotic(obj) {\n const {exoticToPrim, input, hint} = obj;\n const result = exoticToPrim.call(input, hint);\n\n if (isPrimitive(result)) {\n return result;\n }\n\n throw new TypeError('unable to convert exotic object to primitive');\n};\n\nconst evalPrimitive = function evalPrimitive(input, hint) {\n const newHint = hint === DEFAULT && (isDate(input) || isSymbol(input)) ? STRING : hint;\n\n return ordinaryToPrimitive(input, newHint === DEFAULT ? NUMBER : newHint);\n};\n\n/**\n * This method converts a JavaScript object to a primitive value.\n * Note: When toPrimitive is called with no hint, then it generally behaves as\n * if the hint were Number. However, objects may over-ride this behaviour by\n * defining a @@toPrimitive method. Of the objects defined in this specification\n * only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.4) over-ride\n * the default ToPrimitive behaviour. Date objects treat no hint as if the hint\n * were String.\n *\n * @param {*} input - The input to convert.\n * @param {Function} [preferredType] - The preferred type (String or Number).\n * @throws {TypeError} If unable to convert input to a primitive.\n * @returns {string|number} The converted input as a primitive.\n * @see {http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive}\n */\nconst toPrimitive = function toPrimitive(input, preferredType) {\n if (isPrimitive(input)) {\n return input;\n }\n\n const hint = getHint(preferredType, arguments.length > ONE);\n const exoticToPrim = getExoticToPrim(input);\n\n return typeof exoticToPrim === 'undefined' ? evalPrimitive(input, hint) : evalExotic({exoticToPrim, input, hint});\n};\n\nexport default toPrimitive;\n","import NAN from 'nan-x';\nimport toStr from 'to-string-x';\nimport trimLeft from 'trim-left-x';\n\nconst nativeParseInt = parseInt;\n/** @type {Function} */\nconst castNumber = (0).constructor;\n// noinspection JSPotentiallyInvalidConstructorUsage\nconst {charAt} = '';\nconst hexRegex = /^[-+]?0[xX]/;\nconst {test} = hexRegex;\n\n/**\n * This method parses a string argument and returns an integer of the specified\n * radix (the base in mathematical numeral systems). (ES2019).\n *\n * @param {string} [string] - The value to parse. If the string argument is not a\n * string, then it is converted to a string (using the ToString abstract\n * operation). Leading whitespace in the string argument is ignored.\n * @param {number} [radix] - An integer between 2 and 36 that represents the radix\n * (the base in mathematical numeral systems) of the above mentioned string.\n * Specify 10 for the decimal numeral system commonly used by humans. Always\n * specify this parameter to eliminate reader confusion and to guarantee\n * predictable behavior. Different implementations produce different results\n * when a radix is not specified, usually defaulting the value to 10.\n * @throws {TypeError} If target is a Symbol or is not coercible.\n * @returns {number} An integer number parsed from the given string. If the first\n * character cannot be converted to a number, NaN is returned.\n */\nconst $parseInt = function $parseInt(string, radix) {\n const str = trimLeft(toStr(string));\n\n if (charAt.call(str, 0) === '\\u180E') {\n return NAN;\n }\n\n return nativeParseInt(str, castNumber(radix) || (test.call(hexRegex, str) ? 16 : 10));\n};\n\nexport default $parseInt;\n","/**\n * The constant NaN derived mathematically by 0 / 0.\n *\n * @type number\n */\nconst constantNAN = 0 / 0;\n\nexport default constantNAN;\n","import isSymbol from 'is-symbol';\nimport toPrimitive from 'to-primitive-x';\nimport trim from 'trim-x';\nimport $parseInt from 'parse-int-x';\nimport NAN from 'nan-x';\n\nconst binaryRadix = 2;\nconst octalRadix = 8;\nconst testCharsCount = 2;\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a number';\n\nconst castNumber = testCharsCount.constructor;\nconst pStrSlice = ERROR_MESSAGE.slice;\n\nconst binaryRegex = /^0b[01]+$/i;\nconst RegExpConstructor = binaryRegex.constructor;\n// Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is\n// an own property of regexes. wtf.\nconst {test} = binaryRegex;\nconst isBinary = function isBinary(value) {\n return test.call(binaryRegex, value);\n};\n\nconst octalRegex = /^0o[0-7]+$/i;\nconst isOctal = function isOctal(value) {\n return test.call(octalRegex, value);\n};\n\nconst nonWSregex = new RegExpConstructor('[\\u0085\\u180e\\u200b\\ufffe]', 'g');\nconst hasNonWS = function hasNonWS(value) {\n return test.call(nonWSregex, value);\n};\n\nconst invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i;\nconst isInvalidHexLiteral = function isInvalidHexLiteral(value) {\n return test.call(invalidHexLiteral, value);\n};\n\nconst assertNotSymbol = function assertNotSymbol(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return value;\n};\n\nconst parseBase = function parseBase(value, radix) {\n return $parseInt(pStrSlice.call(value, testCharsCount), radix);\n};\n\nconst parseString = function parseString(toNum, value) {\n if (isBinary(value)) {\n return toNum(parseBase(value, binaryRadix));\n }\n\n if (isOctal(value)) {\n return toNum(parseBase(value, octalRadix));\n }\n\n return null;\n};\n\nconst convertString = function convertString(toNum, value) {\n const val = parseString(toNum, value);\n\n if (val !== null) {\n return val;\n }\n\n if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n return NAN;\n }\n\n const trimmed = trim(value);\n\n if (trimmed !== value) {\n return toNum(trimmed);\n }\n\n return null;\n};\n\n/**\n * This method converts argument to a value of type Number. (ES2019).\n *\n * @param {*} [argument] - The argument to convert to a number.\n * @throws {TypeError} - If argument is a Symbol or not coercible.\n * @returns {*} The argument converted to a number.\n */\nconst toNumber = function toNumber(argument) {\n const value = assertNotSymbol(toPrimitive(argument, castNumber));\n\n if (typeof value === 'string') {\n const val = convertString(toNumber, value);\n\n if (val !== null) {\n return val;\n }\n }\n\n return castNumber(value);\n};\n\nexport default toNumber;\n","/**\n * This method determines whether the passed value is NaN and its type is\n * `Number`. It is a more robust version of the original, global isNaN().\n *\n * @param {*} [value] - The value to be tested for NaN.\n * @returns {boolean} `true` if the given value is NaN and its type is Number;\n * otherwise, `false`.\n */\nconst isNaN = function isNaN(value) {\n /* eslint-disable-next-line no-self-compare */\n return value !== value;\n};\n\nexport default isNaN;\n","import toNumber from 'to-number-x';\nimport numberIsNaN from 'is-nan-x';\n\n/**\n * This method returns the sign of a number, indicating whether the number is positive,\n * negative or zero. (ES2019).\n *\n * @param {*} x - A number.\n * @returns {number} A number representing the sign of the given argument. If the argument\n * is a positive number, negative number, positive zero or negative zero, the function will\n * return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned.\n */\nconst sign = function sign(x) {\n const n = toNumber(x);\n\n if (n === 0 || numberIsNaN(n)) {\n return n;\n }\n\n return n > 0 ? 1 : -1;\n};\n\nexport default sign;\n"],"sourceRoot":""} \ No newline at end of file +{"version":3,"sources":["webpack://mathSignX/webpack/universalModuleDefinition","webpack://mathSignX/webpack/bootstrap","webpack://mathSignX/./node_modules/is-symbol/index.js","webpack://mathSignX/./node_modules/is-string/index.js","webpack://mathSignX/./node_modules/is-date-object/index.js","webpack://mathSignX/./node_modules/has-symbols/index.js","webpack://mathSignX/(webpack)/buildin/global.js","webpack://mathSignX/./node_modules/has-symbols/shams.js","webpack://mathSignX/../src/is-primitive-x.js","webpack://mathSignX/../src/has-boxed-string-x.js","webpack://mathSignX/../src/has-working-bind-x.js","webpack://mathSignX/../src/noop-x.js","webpack://mathSignX/../src/util-pusher-x.js","webpack://mathSignX/../src/simple-bind-x.js","webpack://mathSignX/../src/simple-call-x.js","webpack://mathSignX/../src/attempt-x.js","webpack://mathSignX/../src/white-space-x.js","webpack://mathSignX/../src/has-symbol-support-x.js","webpack://mathSignX/../src/to-boolean-x.js","webpack://mathSignX/../src/simple-methodize-x.js","webpack://mathSignX/../src/to-string-tag-x.js","webpack://mathSignX/../src/has-to-string-tag-x.js","webpack://mathSignX/../src/is-nil-x.js","webpack://mathSignX/../src/require-object-coercible-x.js","webpack://mathSignX/../src/to-string-x.js","webpack://mathSignX/../src/require-coercible-to-string-x.js","webpack://mathSignX/../src/trim-left-x.js","webpack://mathSignX/../src/trim-right-x.js","webpack://mathSignX/../src/trim-x.js","webpack://mathSignX/../src/normalize-space-x.js","webpack://mathSignX/../src/replace-comments-x.js","webpack://mathSignX/../src/is-function-x.js","webpack://mathSignX/../src/to-primitive-x.js","webpack://mathSignX/../src/parse-int-x.js","webpack://mathSignX/../src/nan-x.js","webpack://mathSignX/../src/to-number-x.js","webpack://mathSignX/../src/is-nan-x.js","webpack://mathSignX/../src/math-sign-x.js"],"names":["root","factory","exports","module","define","amd","$globalThis","ObjectCtr","constructor","objectPrototype","prototype","defineProperty","getGlobalFallback","self","window","global","returnThis","this","get","configurable","__defineGetter__","$$globalThis$$","error","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","enumerable","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","hasOwnProperty","p","s","toStr","toString","symToStr","symStringRegex","valueOf","test","isSymbolObject","e","strValue","String","hasToStringTag","tryStringObject","getDay","Date","tryDateObject","origSymbol","hasSymbolSham","g","Function","getOwnPropertySymbols","iterator","obj","sym","symObj","keys","length","getOwnPropertyNames","syms","propertyIsEnumerable","getOwnPropertyDescriptor","descriptor","is_primitive_x_esm","val","_typeof","boxedString","has_boxed_string_x_esm","has_working_bind_x_esm_bind","has_working_bind_x_esm","a1","a2","context","testThis","boundFn","apply","arg1","arg2","arguments","args","test1","oracle","Ctr","BoundFn","returned","test2","split","max","Math","util_pusher_x_esm_bind","util_pusher_x_esm_call","$split","string","pattern","util_pusher_x_esm_getIterable","arrayLike","is_string_default","util_pusher_x_esm","from","target","iterable","nativeBind","simple_bind_x_esm_call","simple_bind_x_esm_object","getMax","a","b","simple_bind_x_esm_assertIsFunction","TypeError","boundFns","binder","boundLength","f","h","getBoundFn","_args","_slicedToArray","bindArgs","fn","Empty","getResult","boundArgs","result","simple_bind_x_esm","thisArg","bound","$TypeError","nativeApply","$apply","simple_call_x_esm_toStringTag","simple_call_x_esm_assertIsFunction","simple_call_x_esm","F","V","attempt_x_esm","threw","hasSymbolSupport","_newArrowCheck","is_symbol_default","undefined","has_symbol_support_x_esm","to_boolean_x_esm","simple_methodize_x_esm_toStringTag","simple_methodize_x_esm","prototypeMethod","simple_methodize_x_esm_assertIsFunction","methodizedToString","to_string_tag_x_esm","has_to_string_tag_x_esm","is_nil_x_esm","require_object_coercible_x_esm","concat","castString","to_string_x_esm","require_coercible_to_string_x_esm","list","code","description","es5","es2015","es2016","es2017","es2018","stringES2018","white_space_x_esm_length","white_space_x_esm_i","white_space_x_esm","reLeft","RegExpCtr","methodizedReplace","replace","trim_left_x_esm","reRight","trim_right_x_esm_RegExpCtr","trim_right_x_esm_methodizedReplace","trim_right_x_esm","trim_x_esm","reNormalize","normalize_space_x_esm_RegExpCtr","normalize_space_x_esm_methodizedReplace","normalize_space_x_esm","STRIP_COMMENTS","replace_comments_x_esm_methodizedReplace","replace_comments_x_esm","replacement","FunctionCtr","methodizedFunctionToString","ctrRx","methodizedTest","hasNativeClass","is_function_x_esm_testClassString","isES6ClassFn","is_function_x_esm","allowClass","tryFuncToString","strTag","is_function_x_esm_compareTags","StringCtr","NumberCtr","symToPrimitive","toPrimitive","symValueOf","toStringOrder","toNumberOrder","to_primitive_x_esm_ordinaryToPrimitive","ordinary","hint","assertHint","methodNames","method","getHint","supplied","to_primitive_x_esm_getExoticToPrim","func","to_primitive_x_esm_getMethod","to_primitive_x_esm_evalExotic","exoticToPrim","input","to_primitive_x_esm_evalPrimitive","newHint","is_date_object_default","to_primitive_x_esm","preferredType","nativeParseInt","parseInt","castNumber","methodizedCharAt","charAt","hexRegex","parse_int_x_esm_methodizedTest","parse_int_x_esm","radix","str","to_number_x_esm_castNumber","methodizedStringSlice","slice","binaryRegex","RegExpConstructor","to_number_x_esm_methodizedTest","octalRegex","nonWSregex","invalidHexLiteral","to_number_x_esm_parseBase","parseString","toNum","isBinary","isOctal","to_number_x_esm_convertString","hasNonWS","isInvalidHexLiteral","trimmed","to_number_x_esm","toNumber","argument","to_number_x_esm_assertNotSymbol","is_nan_x_esm","__webpack_exports__","x"],"mappings":"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","file":"math-sign-x.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mathSignX\"] = factory();\n\telse\n\t\troot[\"mathSignX\"] = factory();\n})((function () {\n 'use strict';\n\n var ObjectCtr = {}.constructor;\n var objectPrototype = ObjectCtr.prototype;\n var defineProperty = ObjectCtr.defineProperty;\n var $globalThis;\n var getGlobalFallback = function() {\n if (typeof self !== 'undefined') {\n return self;\n }\n\n if (typeof window !== 'undefined') {\n return window;\n }\n\n if (typeof global !== 'undefined') {\n return global;\n }\n\n return void 0;\n };\n\n var returnThis = function() {\n return this;\n };\n\n try {\n if (defineProperty) {\n defineProperty(objectPrototype, '$$globalThis$$', {\n get: returnThis,\n configurable: true\n });\n } else {\n objectPrototype.__defineGetter__('$$globalThis$$', returnThis);\n }\n\n $globalThis = typeof $$globalThis$$ === 'undefined' ? getGlobalFallback() : $$globalThis$$;\n\n delete objectPrototype.$$globalThis$$;\n\n return $globalThis;\n } catch (error) {\n return getGlobalFallback();\n }\n}()), function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 6);\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar hasSymbols = require('has-symbols')();\n\nif (hasSymbols) {\n\tvar symToStr = Symbol.prototype.toString;\n\tvar symStringRegex = /^Symbol\\(.*\\)$/;\n\tvar isSymbolObject = function isRealSymbolObject(value) {\n\t\tif (typeof value.valueOf() !== 'symbol') {\n\t\t\treturn false;\n\t\t}\n\t\treturn symStringRegex.test(symToStr.call(value));\n\t};\n\n\tmodule.exports = function isSymbol(value) {\n\t\tif (typeof value === 'symbol') {\n\t\t\treturn true;\n\t\t}\n\t\tif (toStr.call(value) !== '[object Symbol]') {\n\t\t\treturn false;\n\t\t}\n\t\ttry {\n\t\t\treturn isSymbolObject(value);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n} else {\n\n\tmodule.exports = function isSymbol(value) {\n\t\t// this environment does not support Symbols.\n\t\treturn false && value;\n\t};\n}\n","'use strict';\n\nvar strValue = String.prototype.valueOf;\nvar tryStringObject = function tryStringObject(value) {\n\ttry {\n\t\tstrValue.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar strClass = '[object String]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isString(value) {\n\tif (typeof value === 'string') { return true; }\n\tif (typeof value !== 'object') { return false; }\n\treturn hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass;\n};\n","'use strict';\n\nvar getDay = Date.prototype.getDay;\nvar tryDateObject = function tryDateObject(value) {\n\ttry {\n\t\tgetDay.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\n\nvar toStr = Object.prototype.toString;\nvar dateClass = '[object Date]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isDateObject(value) {\n\tif (typeof value !== 'object' || value === null) { return false; }\n\treturn hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;\n};\n","'use strict';\n\nvar origSymbol = global.Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","'use strict';\n\n/* eslint complexity: [2, 17], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","/**\n * Returns true if the value is a primitive.\n *\n * @param {*} [val] - The value to test.\n * @returns {boolean} True if a primitive, otherwise false..\n */\nconst isPrimitive = function isPrimitive(val) {\n return typeof val === 'object' ? val === null : typeof val !== 'function';\n};\n\nexport default isPrimitive;\n","const string = 'a';\nconst boxedString = {}.constructor(string);\n\n/**\n * Check failure of by-index access of string characters (IE < 9)\n * and failure of `0 in boxedString` (Rhino).\n *\n * `true` if no failure; otherwise `false`.\n *\n * @type boolean\n */\nconst hasBoxed = boxedString[0] === string && 0 in boxedString;\n\nexport default hasBoxed;\n","import noop from 'noop-x';\n\nconst {bind} = noop;\n\nconst test1 = function test1() {\n let a1 = null;\n let a2 = null;\n let context = null;\n const testThis = [];\n\n const test1Fn = function test1Fn(arg1, arg2) {\n /* eslint-disable-next-line babel/no-invalid-this */\n context = this;\n a1 = arg1;\n a2 = arg2;\n\n /* eslint-disable-next-line prefer-rest-params */\n return arguments;\n };\n\n try {\n const boundFn = bind.apply(test1Fn, [testThis, 1]);\n const args = boundFn(2);\n\n return boundFn.length === 1 && args.length === 2 && a1 === 1 && a2 === 2 && context === testThis;\n } catch (e) {\n return false;\n }\n};\n\nconst test2 = function test2() {\n let a1 = null;\n let a2 = null;\n let context = null;\n const oracle = [1, 2, 3];\n\n const Ctr = function Ctr(arg1, arg2) {\n a1 = arg1;\n a2 = arg2;\n context = this;\n\n return oracle;\n };\n\n try {\n const BoundFn = bind.apply(Ctr, [null]);\n const returned = new BoundFn(1, 2);\n\n return BoundFn.length === Ctr.length && returned === oracle && a1 === 1 && a2 === 2 && context !== oracle;\n } catch (e) {\n return false;\n }\n};\n\n/**\n * Indicates if the engine has a working bind function.\n *\n * @type {boolean}\n */\nconst isWorking = typeof bind === 'function' && test1() && test2();\n\nexport default isWorking;\n","/**\n * This method returns undefined.\n *\n * @returns {undefined} Always undefined.\n */\nconst noop = function noop() {}; /* eslint-disable-line lodash/prefer-noop */\n\nexport default noop;\n","import isPrimitive from 'is-primitive-x';\nimport isString from 'is-string';\nimport hasBoxed from 'has-boxed-string-x';\nimport hasWorkingBind from 'has-working-bind-x';\n\nconst EMPTY_STRING = '';\nconst {split} = EMPTY_STRING;\nconst {max} = Math;\nconst {bind, call} = isPrimitive;\nexport const stringSplit = function stringSplit(string, pattern) {\n // noinspection JSUnresolvedFunction\n return split.call(string, pattern);\n};\n\nexport const $split = hasWorkingBind ? bind.call(call, split) : stringSplit;\n\nexport const getIterable = function getIterable(arrayLike) {\n // noinspection JSUnresolvedFunction\n return isString(arrayLike) ? $split(arrayLike, EMPTY_STRING) : arrayLike;\n};\n\n// eslint-disable jsdoc/no-undefined-types\n// noinspection JSCommentMatchesSignature\n/**\n * This pushes or concatenates into a new or existing array.\n *\n * @param {Array} arrayLike - The source.\n * @param {number} [from=0] - The from source index.\n * @param {Array} [target=[]] - The target array.\n * @returns {*} The target array.\n */\n// eslint-enable jsdoc/no-undefined-types\nconst pusher = function pusher(arrayLike, from) {\n /* eslint-disable-next-line prefer-rest-params */\n const target = arguments.length > 2 ? arguments[2] : [];\n\n if (typeof arrayLike !== 'string' && isPrimitive(arrayLike)) {\n return target;\n }\n\n const iterable = hasBoxed ? arrayLike : getIterable(arrayLike);\n const {length} = iterable;\n for (let i = max(0, from) || 0; i < length; i += 1) {\n target[target.length] = arrayLike[i];\n }\n\n return target;\n};\n\nexport default pusher;\n","import hasWorkingBind from 'has-working-bind-x';\nimport pusher from 'util-pusher-x';\n\nconst {bind: nativeBind, call} = pusher;\nconst ERROR_MESSAGE = 'bind called on incompatible ';\nconst object = {};\nconst ObjectCtr = object.constructor;\nconst toStringTag = object.toString;\nconst funcType = '[object Function]';\nconst ZERO = 0;\nconst argsOffset = 2;\n\nconst getMax = function getMax(a, b) {\n return a >= b ? a : b;\n};\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && toStringTag.apply(value) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + value);\n }\n};\n\nconst boundFns = [\n function zero(binder) {\n return function boundFn() {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments));\n };\n },\n function one(binder, boundLength) {\n return function boundFn(a) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a]));\n };\n },\n function two(binder, boundLength) {\n return function boundFn(a, b) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b]));\n };\n },\n function three(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c]));\n };\n },\n function four(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d]));\n };\n },\n function five(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e]));\n };\n },\n function six(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f]));\n };\n },\n function seven(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f, g) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f, g]));\n };\n },\n function eight(binder, boundLength) {\n /* eslint-disable-next-line max-params */\n return function boundFn(a, b, c, d, e, f, g, h) {\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n return binder.apply(this, pusher(arguments, boundLength, [a, b, c, d, e, f, g, h]));\n };\n },\n];\n\nconst getBoundFn = function getBoundFn(args) {\n const [binder, target, bindArgs] = args;\n const boundLength = getMax(ZERO, target.length - getMax(ZERO, bindArgs.length - argsOffset));\n const fn = boundFns[boundLength];\n const boundFn = fn ? fn(binder, boundLength) : boundFns[ZERO](binder);\n\n if (target.prototype) {\n /* eslint-disable-next-line lodash/prefer-noop */\n const Empty = function Empty() {};\n\n Empty.prototype = target.prototype;\n boundFn.prototype = new Empty();\n Empty.prototype = null;\n }\n\n return boundFn;\n};\n\nconst getResult = function getResult(target, boundArgs) {\n /* eslint-disable-next-line babel/no-invalid-this */\n const result = target.apply(this, boundArgs);\n\n /* eslint-disable-next-line babel/no-invalid-this,babel/new-cap */\n return ObjectCtr(result) === result ? result : this;\n};\n\nexport const implementation = function bind(target, thisArg) {\n assertIsFunction(target);\n /* eslint-disable-next-line prefer-rest-params */\n const bindArgs = arguments;\n\n let bound;\n const binder = function binder() {\n /* eslint-disable-next-line prefer-rest-params */\n const boundArgs = pusher(arguments, ZERO, pusher(bindArgs, argsOffset));\n\n /* eslint-disable-next-line babel/no-invalid-this */\n return this instanceof bound ? getResult.apply(this, [target, boundArgs]) : target.apply(thisArg, boundArgs);\n };\n\n bound = getBoundFn([binder, target, bindArgs]);\n\n return bound;\n};\n\n/**\n * The bind() method creates a new function that, when called, has its this\n * keyword set to the provided value, with a given sequence of arguments\n * preceding any provided when the new function is called.\n *\n * @function bind\n * @param {Function} target - The target function.\n * @param {*} [thisArg] - The value to be passed as the this parameter to the target\n * function when the bound function is called. The value is ignored if the\n * bound function is constructed using the new operator.\n * @param {...*} [args] - Arguments to prepend to arguments provided to the bound\n * function when invoking the target function.\n * @throws {TypeError} If target is not a function.\n * @returns {Function} The bound function.\n */\nconst $bind = hasWorkingBind ? call.bind(nativeBind) : implementation;\n\nexport default $bind;\n","import pusher from 'util-pusher-x';\nimport bind from 'simple-bind-x';\n\nconst $TypeError = TypeError;\nconst {apply: nativeApply, call: nativeCall} = bind;\nconst $apply = bind(nativeCall, nativeApply);\nconst toStringTag = bind(nativeApply, {}.toString);\nconst ERROR_MESSAGE = ' is not a function';\nconst funcType = '[object Function]';\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && toStringTag(value) !== funcType) {\n throw new $TypeError(value + ERROR_MESSAGE);\n }\n\n return value;\n};\n\n// eslint-disable jsdoc/check-param-names\n// noinspection JSCommentMatchesSignature\n/**\n * The abstract operation Call is used to call the [[Call]] internal method of a function object.\n *\n * @function call\n * @param {Function} F - The target function.\n * @param {*} [V] - The context.\n * @param {Array} [args] - Argument to call the function with.\n * @throws {TypeError} If target is not a function.\n * @returns {*} The the result of invoking the function.\n * @see https://www.ecma-international.org/ecma-262/6.0/#sec-call\n */\n// eslint-enable jsdoc/check-param-names\nconst call = function call(F, V) {\n /* eslint-disable-next-line prefer-rest-params */\n return $apply(assertIsFunction(F), V, pusher(arguments[2]));\n};\n\nexport default call;\n","import pusher from 'util-pusher-x';\nimport call from 'simple-call-x';\n\n// eslint-disable jsdoc/check-param-names\n// noinspection JSCommentMatchesSignature\n/**\n * This method attempts to invoke the function, returning either the result or\n * the caught error object. Any additional arguments are provided to the\n * function when it's invoked.\n *\n * @function attempt\n * @param {Function} [fn] - The function to attempt.\n * @param {...*} [args] - The arguments to invoke the function with.\n * @returns {object} Returns an object of the result.\n */\n// eslint-disable jsdoc/check-param-names\nconst attempt = function attempt(fn) {\n try {\n return {\n threw: false,\n /* eslint-disable-next-line babel/no-invalid-this,prefer-rest-params */\n value: call(fn, this, pusher(arguments, 1)),\n };\n } catch (e) {\n return {\n threw: true,\n value: e,\n };\n }\n};\n\nexport default attempt;\n","/**\n * A record of a white space character.\n *\n * @typedef {object} CharRecord\n * @property {number} code - The character code.\n * @property {string} description - A description of the character.\n * @property {boolean} es5 - Whether the spec lists this as a white space.\n * @property {boolean} es2015 - Whether the spec lists this as a white space.\n * @property {boolean} es2016 - Whether the spec lists this as a white space.\n * @property {boolean} es2017 - Whether the spec lists this as a white space.\n * @property {boolean} es2018 - Whether the spec lists this as a white space.\n * @property {string} string - The character string.\n */\n\n/**\n * An array of the whitespace char codes, string, descriptions and language\n * presence in the specifications.\n *\n * @type Array.\n */\nexport const list = [\n {\n code: 0x0009,\n description: 'Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0009',\n },\n {\n code: 0x000a,\n description: 'Line Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000a',\n },\n {\n code: 0x000b,\n description: 'Vertical Tab',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000b',\n },\n {\n code: 0x000c,\n description: 'Form Feed',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000c',\n },\n {\n code: 0x000d,\n description: 'Carriage Return',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u000d',\n },\n {\n code: 0x0020,\n description: 'Space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u0020',\n },\n /*\n {\n code: 0x0085,\n description: 'Next line',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u0085'\n }\n */\n {\n code: 0x00a0,\n description: 'No-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u00a0',\n },\n {\n code: 0x1680,\n description: 'Ogham space mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u1680',\n },\n {\n code: 0x180e,\n description: 'Mongolian vowel separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: false,\n es2018: false,\n string: '\\u180e',\n },\n {\n code: 0x2000,\n description: 'En quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2000',\n },\n {\n code: 0x2001,\n description: 'Em quad',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2001',\n },\n {\n code: 0x2002,\n description: 'En space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2002',\n },\n {\n code: 0x2003,\n description: 'Em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2003',\n },\n {\n code: 0x2004,\n description: 'Three-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2004',\n },\n {\n code: 0x2005,\n description: 'Four-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2005',\n },\n {\n code: 0x2006,\n description: 'Six-per-em space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2006',\n },\n {\n code: 0x2007,\n description: 'Figure space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2007',\n },\n {\n code: 0x2008,\n description: 'Punctuation space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2008',\n },\n {\n code: 0x2009,\n description: 'Thin space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2009',\n },\n {\n code: 0x200a,\n description: 'Hair space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u200a',\n },\n /*\n {\n code: 0x200b,\n description: 'Zero width space',\n es5: false,\n es2015: false,\n es2016: false,\n es2017: false,\n es2018: false,\n string: '\\u200b'\n },\n */\n {\n code: 0x2028,\n description: 'Line separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2028',\n },\n {\n code: 0x2029,\n description: 'Paragraph separator',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u2029',\n },\n {\n code: 0x202f,\n description: 'Narrow no-break space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u202f',\n },\n {\n code: 0x205f,\n description: 'Medium mathematical space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u205f',\n },\n {\n code: 0x3000,\n description: 'Ideographic space',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\u3000',\n },\n {\n code: 0xfeff,\n description: 'Byte Order Mark',\n es5: true,\n es2015: true,\n es2016: true,\n es2017: true,\n es2018: true,\n string: '\\ufeff',\n },\n];\n\n/**\n * A string of the ES5 to ES2016 whitespace characters.\n *\n * @type string\n */\nlet stringES2016 = '';\n\n/**\n * A string of the ES2017 to ES2018 whitespace characters.\n *\n * @type string\n */\nlet stringES2018 = '';\nconst {length} = list;\nfor (let i = 0; i < length; i += 1) {\n if (list[i].es2016) {\n stringES2016 += list[i].string;\n }\n\n if (list[i].es2018) {\n stringES2018 += list[i].string;\n }\n}\n\nconst string2018 = stringES2018;\n\nexport default string2018;\nexport const string2016 = stringES2016;\n","import attempt from 'attempt-x';\nimport isSymbol from 'is-symbol';\n\nconst hasSymbolSupport = attempt(() => {\n /* eslint-disable-next-line compat/compat */\n return typeof Symbol === 'function' && isSymbol(Symbol(''));\n});\n\n/**\n * Indicates if `Symbol`exists and creates the correct type.\n * `true`, if it exists and creates the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbolSupport.threw === false && hasSymbolSupport.value === true;\n","/**\n * The abstract operation ToBoolean converts argument to a value of type Boolean.\n *\n * @param {*} [value] - The value to be converted.\n * @returns {boolean} 'true' if value is truthy; otherwise 'false'.\n */\nconst toBoolean = function toBoolean(value) {\n return !!value;\n};\n\nexport default toBoolean;\n","import call from 'simple-call-x';\nimport pusher from 'util-pusher-x';\n\nconst toStringTag = {}.toString;\nconst ERROR_MESSAGE = 'methodize called on incompatible ';\nconst funcType = '[object Function]';\n\nconst assertIsFunction = function assertIsFunction(value) {\n if (typeof value !== 'function' && call(toStringTag, value) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + value);\n }\n\n return value;\n};\n\n/**\n * Methodize a prototype method. Compliant to 8 arguments.\n *\n * @param {Function} prototypeMethod - The prototype method to methodize.\n * @throws {TypeError} If target is not a function.\n * @returns {Function} The static method.\n */\nconst methodize = function methodize(prototypeMethod) {\n assertIsFunction(prototypeMethod);\n\n return function methodized() {\n /* eslint-disable-next-line prefer-rest-params */\n return call(prototypeMethod, arguments[0], pusher(arguments, 1));\n };\n};\n\nexport default methodize;\n","import methodize from 'simple-methodize-x';\n\nconst methodizedToString = methodize({}.toString);\n\n/**\n * The `toStringTag` method returns \"[object type]\", where type is the\n * object type.\n *\n * @param {*} [value] - The object of which to get the object type string.\n * @returns {string} The object type string.\n */\nconst toStringTag = function toStringTag(value) {\n if (value === null) {\n return '[object Null]';\n }\n\n if (typeof value === 'undefined') {\n return '[object Undefined]';\n }\n\n return methodizedToString(value);\n};\n\nexport default toStringTag;\n","import hasSymbols from 'has-symbol-support-x';\nimport isSymbol from 'is-symbol';\n\n/**\n * Indicates if `Symbol.toStringTag`exists and is the correct type.\n * `true`, if it exists and is the correct type, otherwise `false`.\n *\n * @type boolean\n */\nexport default hasSymbols &&\n /* eslint-disable-next-line compat/compat */\n isSymbol(Symbol.toStringTag);\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @param {*} [value] - The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n */\nconst isNil = function isNil(value) {\n /* eslint-disable-next-line lodash/prefer-is-nil */\n return value === null || typeof value === 'undefined';\n};\n\nexport default isNil;\n","import isNil from 'is-nil-x';\n\n/**\n * The abstract operation RequireObjectCoercible throws an error if argument\n * is a value that cannot be converted to an Object using ToObject.\n *\n * @param {*} [value] - The `value` to check.\n * @throws {TypeError} If `value` is a `null` or `undefined`.\n * @returns {string} The `value`.\n */\nconst requireObjectCoercible = function requireObjectCoercible(value) {\n if (isNil(value)) {\n throw new TypeError(`Cannot call method on ${value}`);\n }\n\n return value;\n};\n\nexport default requireObjectCoercible;\n","import isSymbol from 'is-symbol';\n\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a string';\nconst castString = ERROR_MESSAGE.constructor;\n/**\n * The abstract operation ToString converts argument to a value of type String.\n *\n * @param {*} [value] - The value to convert to a string.\n * @throws {TypeError} If `value` is a Symbol.\n * @returns {string} The converted value.\n */\nconst ToString = function ToString(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return castString(value);\n};\n\nexport default ToString;\n","import requireObjectCoercible from 'require-object-coercible-x';\nimport toStr from 'to-string-x';\n\n/**\n * This method requires an argument is corecible then converts using ToString.\n *\n * @param {*} [value] - The value to converted to a string.\n * @throws {TypeError} If value is null or undefined.\n * @returns {string} The value as a string.\n */\nconst requireCoercibleToString = function requireCoercibleToString(value) {\n return toStr(requireObjectCoercible(value));\n};\n\nexport default requireCoercibleToString;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reLeft = new RegExpCtr(`^[${whiteSpace}]+`);\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method removes whitespace from the start of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the left end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The left trimmed string.\n */\nconst trimStart = function trimStart(string) {\n return methodizedReplace(requireCoercibleToString(string), reLeft, EMPTY_STRING);\n};\n\nexport default trimStart;\n","import requireCoercibleToString from 'require-coercible-to-string-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst RegExpCtr = /none/.constructor;\nconst reRight = new RegExpCtr(`[${whiteSpace}]+$`);\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method removes whitespace from the end of a string. (ES2019).\n *\n * @param {string} [string] - The string to trim the right end whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The right trimmed string.\n */\nconst trimEnd = function trimEnd(string) {\n return methodizedReplace(requireCoercibleToString(string), reRight, EMPTY_STRING);\n};\n\nexport default trimEnd;\n","import trimStart from 'trim-left-x';\nimport trimEnd from 'trim-right-x';\n\n/**\n * This method removes whitespace from the start and end of a string.\n * (ES2019).\n *\n * @param {string} [string] - The string to trim the whitespace from.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @returns {string} The trimmed string.\n */\nconst trim = function trim(string) {\n return trimStart(trimEnd(string));\n};\n\nexport default trim;\n","import trim from 'trim-x';\nimport whiteSpace from 'white-space-x';\nimport methodize from 'simple-methodize-x';\n\nconst SPACE = ' ';\nconst RegExpCtr = /none/.constructor;\nconst reNormalize = new RegExpCtr(`[${whiteSpace}]+`, 'g');\nconst methodizedReplace = methodize(SPACE.replace);\n\n/**\n * This method strips leading and trailing white-space from a string,\n * replaces sequences of whitespace characters by a single space,\n * and returns the resulting string. (ES2019).\n *\n * @param {string} [string] - The string to be normalized.\n * @throws {TypeError} If string is null or undefined or not coercible.\n */\nconst normalizeSpace = function normalizeSpace(string) {\n return methodizedReplace(trim(string), reNormalize, SPACE);\n};\n\nexport default normalizeSpace;\n","import toStr from 'to-string-x';\nimport requireCoercibleToString from 'require-coercible-to-string-x';\nimport methodize from 'simple-methodize-x';\n\nconst EMPTY_STRING = '';\nconst STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/gm;\nconst methodizedReplace = methodize(EMPTY_STRING.replace);\n\n/**\n * This method replaces comments in a string.\n *\n * @param {string} [string] - The string to be stripped.\n * @param {string} [replacement=''] - The string to be used as a replacement.\n * @throws {TypeError} If string is null or undefined or not coercible.\n * @throws {TypeError} If replacement is not coercible.\n * @returns {string} The new string with the comments replaced.\n */\nconst replaceComments = function replaceComments(string, replacement) {\n return methodizedReplace(\n requireCoercibleToString(string),\n STRIP_COMMENTS,\n arguments.length > 1 ? toStr(replacement) : EMPTY_STRING,\n );\n};\n\nexport default replaceComments;\n","import attempt from 'attempt-x';\nimport toBoolean from 'to-boolean-x';\nimport toStringTag from 'to-string-tag-x';\nimport hasToStringTag from 'has-to-string-tag-x';\nimport isPrimitive from 'is-primitive-x';\nimport normalise from 'normalize-space-x';\nimport deComment from 'replace-comments-x';\nimport methodize from 'simple-methodize-x';\n\nconst FunctionCtr = attempt.constructor;\nconst SPACE = ' ';\nconst methodizedFunctionToString = methodize(attempt.toString);\nconst funcTag = '[object Function]';\nconst genTag = '[object GeneratorFunction]';\nconst asyncTag = '[object AsyncFunction]';\nconst ctrRx = /^class /;\nconst methodizedTest = methodize(ctrRx.test);\n\nconst hasNativeClass =\n attempt(function attemptee() {\n /* eslint-disable-next-line babel/new-cap */\n return FunctionCtr('\"use strict\"; return class My {};')();\n }).threw === false;\n\nconst testClassString = function testClassString(value) {\n return methodizedTest(ctrRx, normalise(deComment(methodizedFunctionToString(value), SPACE)));\n};\n\nconst isES6ClassFn = function isES6ClassFunc(value) {\n const result = attempt(testClassString, value);\n\n return result.threw === false && result.value;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @private\n * @param {*} value - The value to check.\n * @param {boolean} allowClass - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst tryFuncToString = function funcToString(value, allowClass) {\n if (hasNativeClass && allowClass === false && isES6ClassFn(value)) {\n return false;\n }\n\n return (\n attempt(function attemptee() {\n return methodizedFunctionToString(value);\n }).threw === false\n );\n};\n\nconst compareTags = function compareTags(value) {\n const strTag = toStringTag(value);\n\n return strTag === funcTag || strTag === genTag || strTag === asyncTag;\n};\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @param {*} value - The value to check.\n * @param {boolean} [allowClass=false] - Whether to filter ES6 classes.\n * @returns {boolean} Returns `true` if `value` is correctly classified,\n * else `false`.\n */\nconst isFunction = function isFunction(value, allowClass) {\n if (isPrimitive(value)) {\n return false;\n }\n\n if (hasToStringTag) {\n return tryFuncToString(value, toBoolean(allowClass));\n }\n\n if (hasNativeClass && toBoolean(allowClass) === false && isES6ClassFn(value)) {\n return false;\n }\n\n return compareTags(value);\n};\n\nexport default isFunction;\n","import hasSymbols from 'has-symbol-support-x';\nimport isPrimitive from 'is-primitive-x';\nimport isDate from 'is-date-object';\nimport isSymbol from 'is-symbol';\nimport isFunction from 'is-function-x';\nimport requireObjectCoercible from 'require-object-coercible-x';\nimport isNil from 'is-nil-x';\nimport call from 'simple-call-x';\n\nconst ZERO = 0;\nconst ONE = 1;\n/* eslint-disable-next-line no-void */\nconst UNDEFINED = void ZERO;\nconst NUMBER = 'number';\nconst STRING = 'string';\nconst DEFAULT = 'default';\nconst StringCtr = STRING.constructor;\nconst NumberCtr = ZERO.constructor;\n/* eslint-disable-next-line compat/compat */\nconst symToPrimitive = hasSymbols && Symbol.toPrimitive;\n/* eslint-disable-next-line compat/compat */\nconst symValueOf = hasSymbols && Symbol.prototype.valueOf;\n\nconst toStringOrder = ['toString', 'valueOf'];\nconst toNumberOrder = ['valueOf', 'toString'];\nconst orderLength = 2;\n\nconst assertHint = function assertHint(hint) {\n if (typeof hint !== 'string' || (hint !== NUMBER && hint !== STRING)) {\n throw new TypeError('hint must be \"string\" or \"number\"');\n }\n\n return hint;\n};\n\n/**\n * @param {*} ordinary - The ordinary to convert.\n * @param {*} hint - The hint.\n * @returns {*} - The primitive.\n */\nconst ordinaryToPrimitive = function ordinaryToPrimitive(ordinary, hint) {\n requireObjectCoercible(ordinary);\n assertHint(hint);\n\n const methodNames = hint === STRING ? toStringOrder : toNumberOrder;\n for (let i = ZERO; i < orderLength; i += ONE) {\n const method = ordinary[methodNames[i]];\n\n if (isFunction(method)) {\n const result = call(method, ordinary);\n\n if (isPrimitive(result)) {\n return result;\n }\n }\n }\n\n throw new TypeError('No default value');\n};\n\n/**\n * @param {*} object - The object.\n * @param {*} property - The property.\n * @returns {undefined|Function} - The method.\n */\nconst getMethod = function getMethod(object, property) {\n const func = object[property];\n\n if (isNil(func) === false) {\n if (isFunction(func) === false) {\n throw new TypeError(`${func} returned for property ${property} of object ${object} is not a function`);\n }\n\n return func;\n }\n\n return UNDEFINED;\n};\n\n/**\n * Get the hint.\n *\n * @param {*} value - The value to compare.\n * @param {boolean} supplied - Was a value supplied.\n * @returns {string} - The hint string.\n */\nconst getHint = function getHint(value, supplied) {\n if (supplied) {\n if (value === StringCtr) {\n return STRING;\n }\n\n if (value === NumberCtr) {\n return NUMBER;\n }\n }\n\n return DEFAULT;\n};\n\n/**\n * Get the primitive from the exotic.\n *\n * @param {*} value - The exotic.\n * @returns {*} - The primitive.\n */\nconst getExoticToPrim = function getExoticToPrim(value) {\n if (hasSymbols) {\n if (symToPrimitive) {\n return getMethod(value, symToPrimitive);\n }\n\n if (isSymbol(value)) {\n return symValueOf;\n }\n }\n\n return UNDEFINED;\n};\n\nconst evalExotic = function evalExotic(obj) {\n const {exoticToPrim, input, hint} = obj;\n const result = call(exoticToPrim, input, [hint]);\n\n if (isPrimitive(result)) {\n return result;\n }\n\n throw new TypeError('unable to convert exotic object to primitive');\n};\n\nconst evalPrimitive = function evalPrimitive(input, hint) {\n const newHint = hint === DEFAULT && (isDate(input) || isSymbol(input)) ? STRING : hint;\n\n return ordinaryToPrimitive(input, newHint === DEFAULT ? NUMBER : newHint);\n};\n\n/**\n * This method converts a JavaScript object to a primitive value.\n * Note: When toPrimitive is called with no hint, then it generally behaves as\n * if the hint were Number. However, objects may over-ride this behaviour by\n * defining a @@toPrimitive method. Of the objects defined in this specification\n * only Date objects (see 20.3.4.45) and Symbol objects (see 19.4.3.4) over-ride\n * the default ToPrimitive behaviour. Date objects treat no hint as if the hint\n * were String.\n *\n * @param {*} input - The input to convert.\n * @param {Function} [preferredType] - The preferred type (String or Number).\n * @throws {TypeError} If unable to convert input to a primitive.\n * @returns {string|number} The converted input as a primitive.\n * @see {http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive}\n */\nconst toPrimitive = function toPrimitive(input, preferredType) {\n if (isPrimitive(input)) {\n return input;\n }\n\n const hint = getHint(preferredType, arguments.length > ONE);\n const exoticToPrim = getExoticToPrim(input);\n\n return typeof exoticToPrim === 'undefined' ? evalPrimitive(input, hint) : evalExotic({exoticToPrim, input, hint});\n};\n\nexport default toPrimitive;\n","import NAN from 'nan-x';\nimport toStr from 'to-string-x';\nimport trimLeft from 'trim-left-x';\nimport methodize from 'simple-methodize-x';\n\nconst nativeParseInt = parseInt;\n/** @type {Function} */\nconst castNumber = (0).constructor;\nconst BAD_CHAR = '\\u180E';\nconst methodizedCharAt = methodize(BAD_CHAR.charAt);\nconst hexRegex = /^[-+]?0[xX]/;\nconst methodizedTest = methodize(hexRegex.test);\n\n/**\n * This method parses a string argument and returns an integer of the specified\n * radix (the base in mathematical numeral systems). (ES2019).\n *\n * @param {string} [string] - The value to parse. If the string argument is not a\n * string, then it is converted to a string (using the ToString abstract\n * operation). Leading whitespace in the string argument is ignored.\n * @param {number} [radix] - An integer between 2 and 36 that represents the radix\n * (the base in mathematical numeral systems) of the above mentioned string.\n * Specify 10 for the decimal numeral system commonly used by humans. Always\n * specify this parameter to eliminate reader confusion and to guarantee\n * predictable behavior. Different implementations produce different results\n * when a radix is not specified, usually defaulting the value to 10.\n * @throws {TypeError} If target is a Symbol or is not coercible.\n * @returns {number} An integer number parsed from the given string. If the first\n * character cannot be converted to a number, NaN is returned.\n */\nconst $parseInt = function $parseInt(string, radix) {\n const str = trimLeft(toStr(string));\n\n if (methodizedCharAt(str, 0) === BAD_CHAR) {\n return NAN;\n }\n\n return nativeParseInt(str, castNumber(radix) || (methodizedTest(hexRegex, str) ? 16 : 10));\n};\n\nexport default $parseInt;\n","/**\n * The constant NaN derived mathematically by 0 / 0.\n *\n * @type number\n */\nconst constantNAN = 0 / 0;\n\nexport default constantNAN;\n","import isSymbol from 'is-symbol';\nimport toPrimitive from 'to-primitive-x';\nimport trim from 'trim-x';\nimport $parseInt from 'parse-int-x';\nimport NAN from 'nan-x';\nimport methodize from 'simple-methodize-x';\n\nconst binaryRadix = 2;\nconst octalRadix = 8;\nconst testCharsCount = 2;\nconst ERROR_MESSAGE = 'Cannot convert a Symbol value to a number';\n\nconst castNumber = testCharsCount.constructor;\nconst methodizedStringSlice = methodize(ERROR_MESSAGE.slice);\n\nconst binaryRegex = /^0b[01]+$/i;\nconst RegExpConstructor = binaryRegex.constructor;\n// Note that in IE 8, RegExp.prototype.test doesn't seem to exist: ie, \"test\" is\n// an own property of regexes. wtf.\nconst methodizedTest = methodize(binaryRegex.test);\nconst isBinary = function isBinary(value) {\n return methodizedTest(binaryRegex, value);\n};\n\nconst octalRegex = /^0o[0-7]+$/i;\nconst isOctal = function isOctal(value) {\n return methodizedTest(octalRegex, value);\n};\n\nconst nonWSregex = new RegExpConstructor('[\\u0085\\u180e\\u200b\\ufffe]', 'g');\nconst hasNonWS = function hasNonWS(value) {\n return methodizedTest(nonWSregex, value);\n};\n\nconst invalidHexLiteral = /^[-+]0x[0-9a-f]+$/i;\nconst isInvalidHexLiteral = function isInvalidHexLiteral(value) {\n return methodizedTest(invalidHexLiteral, value);\n};\n\nconst assertNotSymbol = function assertNotSymbol(value) {\n if (isSymbol(value)) {\n throw new TypeError(ERROR_MESSAGE);\n }\n\n return value;\n};\n\nconst parseBase = function parseBase(value, radix) {\n return $parseInt(methodizedStringSlice(value, testCharsCount), radix);\n};\n\nconst parseString = function parseString(toNum, value) {\n if (isBinary(value)) {\n return toNum(parseBase(value, binaryRadix));\n }\n\n if (isOctal(value)) {\n return toNum(parseBase(value, octalRadix));\n }\n\n return null;\n};\n\nconst convertString = function convertString(toNum, value) {\n const val = parseString(toNum, value);\n\n if (val !== null) {\n return val;\n }\n\n if (hasNonWS(value) || isInvalidHexLiteral(value)) {\n return NAN;\n }\n\n const trimmed = trim(value);\n\n if (trimmed !== value) {\n return toNum(trimmed);\n }\n\n return null;\n};\n\n/**\n * This method converts argument to a value of type Number. (ES2019).\n *\n * @param {*} [argument] - The argument to convert to a number.\n * @throws {TypeError} - If argument is a Symbol or not coercible.\n * @returns {*} The argument converted to a number.\n */\nconst toNumber = function toNumber(argument) {\n const value = assertNotSymbol(toPrimitive(argument, castNumber));\n\n if (typeof value === 'string') {\n const val = convertString(toNumber, value);\n\n if (val !== null) {\n return val;\n }\n }\n\n return castNumber(value);\n};\n\nexport default toNumber;\n","/**\n * This method determines whether the passed value is NaN and its type is\n * `Number`. It is a more robust version of the original, global isNaN().\n *\n * @param {*} [value] - The value to be tested for NaN.\n * @returns {boolean} `true` if the given value is NaN and its type is Number;\n * otherwise, `false`.\n */\nconst isNaN = function isNaN(value) {\n /* eslint-disable-next-line no-self-compare */\n return value !== value;\n};\n\nexport default isNaN;\n","import toNumber from 'to-number-x';\nimport numberIsNaN from 'is-nan-x';\n\n/**\n * This method returns the sign of a number, indicating whether the number is positive,\n * negative or zero. (ES2019).\n *\n * @param {*} x - A number.\n * @returns {number} A number representing the sign of the given argument. If the argument\n * is a positive number, negative number, positive zero or negative zero, the function will\n * return 1, -1, 0 or -0 respectively. Otherwise, NaN is returned.\n */\nconst sign = function sign(x) {\n const n = toNumber(x);\n\n if (n === 0 || numberIsNaN(n)) {\n return n;\n }\n\n return n > 0 ? 1 : -1;\n};\n\nexport default sign;\n"],"sourceRoot":""} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 06a8335..53c8af5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "math-sign-x", - "version": "4.2.0", + "version": "4.2.1", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -2150,9 +2150,13 @@ "dev": true }, "attempt-x": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/attempt-x/-/attempt-x-2.1.0.tgz", - "integrity": "sha512-6uEwpmnyxZbzZWGwDyvbEEZY1mNWMpMZsLmvBm9sx8WVK2AjT+QWsNVTJe4dS0pE4BXMyPHcX1DD84Rcw2GUEg==" + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/attempt-x/-/attempt-x-2.1.1.tgz", + "integrity": "sha512-mcwu+LMK5Nc/+64aix4Wn3Ujl3tAY+5SVLteD83ypo822dx8Cg+gDRggOxA+NKikulbn7/FSNE53hnxmLo+Pvg==", + "requires": { + "simple-call-x": "^1.0.2", + "util-pusher-x": "^1.0.2" + } }, "aws-sign2": { "version": "0.7.0", @@ -5569,6 +5573,11 @@ "function-bind": "^1.1.1" } }, + "has-boxed-string-x": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/has-boxed-string-x/-/has-boxed-string-x-2.1.0.tgz", + "integrity": "sha512-3NPBl7EodeD1y/6fSUliQlfMIl7v9sY/CKmrIxe27Hr4PjCtKY9wXIDJCejTugQNn2U5a7/jfLNSw/my3hrcLg==" + }, "has-flag": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", @@ -5576,11 +5585,11 @@ "dev": true }, "has-symbol-support-x": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-2.1.0.tgz", - "integrity": "sha512-W+CLT3KPPgWfBPIFovyONfzafrGtl9mwsrxVgit7M8uKASIzJFyU0T+6xRwlTz+me6xHstRWaHZa7HWoAnghBw==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-2.1.1.tgz", + "integrity": "sha512-pgnuC8pSEQQNOq69BGNW+Z8dKHrZbPI3PvzElA4e5n1E5dygqAjJVx358LVySDPLykq4D8WLnCciySv4gMA4jQ==", "requires": { - "attempt-x": "^2.1.0", + "attempt-x": "^2.1.1", "is-symbol": "^1.0.2" } }, @@ -5590,11 +5599,11 @@ "integrity": "sha1-uhqPGvKg/DllD1yFA2dwQSIGO0Q=" }, "has-to-string-tag-x": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-2.1.0.tgz", - "integrity": "sha512-EgUnsXY7dzPPH2F1zeVDtcPzHDy3tTQtG17WTw/PU6o1P7pJNAulNEj4nSyj6fs9dX9K2RlXC/tolyo5oMYPLw==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-2.1.1.tgz", + "integrity": "sha512-FxA7uJfP4CU9S2exqn+IhQQRiERx7jDwo3b+R38auiGKTs3Uzbyx7+fEe739Hs7DhruwWVFtl3DGvXU4VnF8Pg==", "requires": { - "has-symbol-support-x": "^2.1.0", + "has-symbol-support-x": "^2.1.1", "is-symbol": "^1.0.2" } }, @@ -5630,6 +5639,14 @@ } } }, + "has-working-bind-x": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-working-bind-x/-/has-working-bind-x-1.0.0.tgz", + "integrity": "sha512-Z4KjFE3r1KAO5vqZWg2epVp2XbK1rI6Z5/e3XDHLrK4MyjESNWRNCVdrzxaKdux0nOziSFT9ZAU89opyHfJIUw==", + "requires": { + "noop-x": "^1.2.0" + } + }, "hash-base": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", @@ -6035,17 +6052,18 @@ "dev": true }, "is-function-x": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/is-function-x/-/is-function-x-4.1.0.tgz", - "integrity": "sha512-7wj4VvUEc/UOFLfT1j5b8I3rzTaQMXMUR5I1bkVJSJWRymW5kJrt/g/K/PeyhuUI9ENbXfXGCTziPmQBA6KcQQ==", - "requires": { - "attempt-x": "^2.1.0", - "has-to-string-tag-x": "^2.1.0", - "is-primitive": "^3.0.1", - "normalize-space-x": "^4.1.0", - "replace-comments-x": "^3.1.0", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/is-function-x/-/is-function-x-4.1.1.tgz", + "integrity": "sha512-kMgKQzLTt1qFiLB1LwjFSeFOQaSBcofOKtDHk5upyDBnAy7uf4E5a7zZW0xuVyEWPSUq5k154YsJr0sFkf6yJw==", + "requires": { + "attempt-x": "^2.1.1", + "has-to-string-tag-x": "^2.1.1", + "is-primitive-x": "^1.0.0", + "normalize-space-x": "^4.1.1", + "replace-comments-x": "^3.1.1", + "simple-methodize-x": "^1.0.3", "to-boolean-x": "^2.1.0", - "to-string-tag-x": "^2.1.0" + "to-string-tag-x": "^2.1.1" } }, "is-generator-fn": { @@ -6168,10 +6186,10 @@ "isobject": "^3.0.1" } }, - "is-primitive": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-3.0.1.tgz", - "integrity": "sha512-GljRxhWvlCNRfZyORiH77FwdFwGcMO620o37EOYC0ORWdq+WYNVqW0w2Juzew4M+L81l6/QS3t5gkkihyRqv9w==" + "is-primitive-x": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-primitive-x/-/is-primitive-x-1.0.0.tgz", + "integrity": "sha512-gm52Qtf8wYdQByvcim3wPqAMa+mTcuueaQu6d6DSPkzoxynrXzvwiU4BYQNjUTis/1WL6TmczgKGHMdU/IdwnQ==" }, "is-promise": { "version": "2.1.0", @@ -6216,6 +6234,11 @@ "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=", "dev": true }, + "is-string": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.4.tgz", + "integrity": "sha1-zDqbaYV9Yh6WNyWiTK7shzuCbmQ=" + }, "is-symbol": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.2.tgz", @@ -7703,6 +7726,11 @@ } } }, + "noop-x": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/noop-x/-/noop-x-1.2.0.tgz", + "integrity": "sha512-82hTlOqDe53iTIpf5h1phTkskjaVPXtAPsMBJnTZMu1A6hwLVpEqxQkowIdELDdZLdFsNMXq4zi4hi+XShQnIQ==" + }, "nopt": { "version": "1.0.10", "resolved": "https://registry.npmjs.org/nopt/-/nopt-1.0.10.tgz", @@ -7739,11 +7767,12 @@ "dev": true }, "normalize-space-x": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/normalize-space-x/-/normalize-space-x-4.1.0.tgz", - "integrity": "sha512-teUSSrTafvFVlLOYU1qvuL7sG0WomB1dhet01dgMNIJFBtJnXndSHQmT3DQ/uJ9c16lCWIE9ydQkoaYSLg3TLw==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/normalize-space-x/-/normalize-space-x-4.1.1.tgz", + "integrity": "sha512-/ykM/zBoMRHXQGTief5lQkuUbt16l2WqCwtg+JIfXaNE9acgkQV69syHDgvEPPU351QpxWyGr+lpQlDhOvqySg==", "requires": { - "trim-x": "^4.1.0", + "simple-methodize-x": "^1.0.3", + "trim-x": "^4.1.1", "white-space-x": "^4.1.0" } }, @@ -8110,13 +8139,14 @@ } }, "parse-int-x": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/parse-int-x/-/parse-int-x-3.2.0.tgz", - "integrity": "sha512-8WPt8jwUpeQxF+OPgBuwA3vJVycZRXaQ7+W3ol7XShjD5okO2I8ZQUfdrJdy0gxlcF4TKcPF7mVxwJDM8DcFiw==", + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/parse-int-x/-/parse-int-x-3.2.1.tgz", + "integrity": "sha512-I/q1rZCXnstsVsp9dlM0QPI00yhdmHr2dsOCsUTRKcmAZDFb357Ujp1ySSNmACtfpiGmDNBpNAJC/SWdFgm59w==", "requires": { "nan-x": "^2.2.0", + "simple-methodize-x": "^1.0.3", "to-string-x": "^2.1.0", - "trim-left-x": "^4.1.0" + "trim-left-x": "^4.1.1" } }, "parse-json": { @@ -8823,11 +8853,12 @@ "dev": true }, "replace-comments-x": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/replace-comments-x/-/replace-comments-x-3.1.0.tgz", - "integrity": "sha512-I9ds9gOpj0UHyabyWdvQQ3BJAMCZf5fdtCHfD4QtV78s+Ve/fyGIyS9CsF69beVPsROREXQJ8INVOGn1vEulYA==", + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/replace-comments-x/-/replace-comments-x-3.1.1.tgz", + "integrity": "sha512-rvDbWDzleokK3zRb7u4/VbkGcgXxZvcYx1PZTkouJ7YVknDGTigs4mj93V2kAQIepHDOEhOnC1U1GDHQkx4pLA==", "requires": { "require-coercible-to-string-x": "^2.1.0", + "simple-methodize-x": "^1.0.3", "to-string-x": "^2.1.0" } }, @@ -9272,6 +9303,33 @@ "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", "dev": true }, + "simple-bind-x": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/simple-bind-x/-/simple-bind-x-1.0.2.tgz", + "integrity": "sha512-97fOo8CRKVC89ELu1YJuCeeZp3RWQp5taB8ryT+C4NupBimrXzez0tvLccEvwImUlXU3r/ohbRJApXio4KHCVA==", + "requires": { + "has-working-bind-x": "^1.0.0", + "util-pusher-x": "^1.0.2" + } + }, + "simple-call-x": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/simple-call-x/-/simple-call-x-1.0.2.tgz", + "integrity": "sha512-mdutrZPVfe0ub82f13FCyaH+IYl6LCQif/Zg4emgCBszTjvFeHxD7RNUQ14q1Dx0BBncYEtlWdTrnBBqD6wMlA==", + "requires": { + "simple-bind-x": "^1.0.2", + "util-pusher-x": "^1.0.2" + } + }, + "simple-methodize-x": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/simple-methodize-x/-/simple-methodize-x-1.0.3.tgz", + "integrity": "sha512-BkngaW/mzvc5vYbjP5eJ7/1ai9jxx4e8M16ZDU9qydxUJukumNmcyNRIgyln6E5pgkIEfKCNwRpiZXOgIbgc8w==", + "requires": { + "simple-call-x": "^1.0.2", + "util-pusher-x": "^1.0.2" + } + }, "sisteransi": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.3.tgz", @@ -9959,15 +10017,16 @@ "dev": true }, "to-number-x": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/to-number-x/-/to-number-x-3.2.0.tgz", - "integrity": "sha512-iFkuktGkWLFsWoYC1i1ebVwZBP0X0EOhMJw8Wl36zCkNR/lMVL3OHMpk5HxL2L+ErtDpCgz3wjI2tl2GpPWk7A==", + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/to-number-x/-/to-number-x-3.2.1.tgz", + "integrity": "sha512-2OkCd3LUc5zInuRbhs1LVUAGms4KZ87ZdIpyImx7IMOr6hYl1B/oEnOYYRg70jyh4r8lHWSUCPM4WxGjmXtVaA==", "requires": { "is-symbol": "^1.0.2", "nan-x": "^2.2.0", - "parse-int-x": "^3.2.0", - "to-primitive-x": "^2.1.0", - "trim-x": "^4.1.0" + "parse-int-x": "^3.2.1", + "simple-methodize-x": "^1.0.3", + "to-primitive-x": "^2.1.1", + "trim-x": "^4.1.1" } }, "to-object-path": { @@ -9991,17 +10050,18 @@ } }, "to-primitive-x": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/to-primitive-x/-/to-primitive-x-2.1.0.tgz", - "integrity": "sha512-ST5X+tVskm+lEIPamAVfZRrKvbdFwZ3bj14RIhdaVs68cq2taJqYg09ymQeUk/L04M5ASIbvyE86PoEI/uGmrA==", + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-primitive-x/-/to-primitive-x-2.1.1.tgz", + "integrity": "sha512-OFxNbJlM+fb+xsygh/dVWpfpIfq8Q4n4tAhByE/fcv/SxK1GljYFE6jEH3ToThzQ45e3MvB8aFX3ycyR97y5Xg==", "requires": { - "has-symbol-support-x": "^2.1.0", + "has-symbol-support-x": "^2.1.1", "is-date-object": "^1.0.1", - "is-function-x": "^4.1.0", + "is-function-x": "^4.1.1", "is-nil-x": "^2.1.0", - "is-primitive": "^3.0.1", + "is-primitive-x": "^1.0.0", "is-symbol": "^1.0.2", - "require-object-coercible-x": "^2.1.0" + "require-object-coercible-x": "^2.1.0", + "simple-call-x": "^1.0.2" } }, "to-regex": { @@ -10027,9 +10087,12 @@ } }, "to-string-tag-x": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/to-string-tag-x/-/to-string-tag-x-2.1.0.tgz", - "integrity": "sha512-DrjW0guAGniY8jN5VRl9rBuuv2aQzeIdV1SP57cKFU7bpZessZRIkSnwjdjTGWjttqvzjlNTBpiCY64nlnBhKg==" + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/to-string-tag-x/-/to-string-tag-x-2.1.1.tgz", + "integrity": "sha512-9SRWEhOexcpxkQwBSMV8coivaQ+6HcwWSUiru//HPRr+CM5JyYcMaFH7jMgukcMUzaAWHMZuwLFYblChCBj69g==", + "requires": { + "simple-methodize-x": "^1.0.3" + } }, "to-string-x": { "version": "2.1.0", @@ -10074,11 +10137,12 @@ } }, "trim-left-x": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/trim-left-x/-/trim-left-x-4.1.0.tgz", - "integrity": "sha512-uVWUuX0cSnlDPaeR/mvjNLny7Da4T6DUKRxnYDtu/dgNZakXmm/eRYmyqoJesAwS7iTGDyVTAg9lbQ4SdxZAFQ==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/trim-left-x/-/trim-left-x-4.1.1.tgz", + "integrity": "sha512-xHHKFXP8WaW9ReR4ECwnTxtsOHiuP95WhqZyWQOC/ghsrSn/MF/xWeGK/AU6MGv0VwGxq4EuYNvMzxZzvafMcQ==", "requires": { "require-coercible-to-string-x": "^2.1.0", + "simple-methodize-x": "^1.0.3", "white-space-x": "^4.1.0" } }, @@ -10089,21 +10153,22 @@ "dev": true }, "trim-right-x": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/trim-right-x/-/trim-right-x-4.1.0.tgz", - "integrity": "sha512-B6EWSocfh7ATa+YUUW0Ql6pFHyoPRRVF/OeyxVfU7VUzp4RRuN21ZQ3KLqDpDlFrZpMGOkqX8pM1liG8ZTGAXA==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/trim-right-x/-/trim-right-x-4.1.1.tgz", + "integrity": "sha512-e3sirp+ZNMXx1u8HJEtlKae4DVx3FUi+w0/ra+SDHQlGF9R5W1TYCVsYANiPMmFByOwgrEWRFJw7W2a1pWcbqA==", "requires": { "require-coercible-to-string-x": "^2.1.0", + "simple-methodize-x": "^1.0.3", "white-space-x": "^4.1.0" } }, "trim-x": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/trim-x/-/trim-x-4.1.0.tgz", - "integrity": "sha512-Bhoa45qGDlQkjcK+UdRkqgEfkh5v/KxBMDYj51Z7vL2esW226yNBd4K3GBJKxUPvg+9rbGMLmOG2ujPoYAbnPw==", + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/trim-x/-/trim-x-4.1.1.tgz", + "integrity": "sha512-Ab8TR+gw3NLeQNINY4t8ngafJmgNFhTZuPHiLzq69bAIz99JrhrV9wVJ6MeO6fLryPxYHUrQ7OF5vhAYBu9d/w==", "requires": { - "trim-left-x": "^4.1.0", - "trim-right-x": "^4.1.0" + "trim-left-x": "^4.1.1", + "trim-right-x": "^4.1.1" } }, "tryer": { @@ -10436,6 +10501,17 @@ "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=", "dev": true }, + "util-pusher-x": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-pusher-x/-/util-pusher-x-1.0.2.tgz", + "integrity": "sha512-Sk/h7ZVVh+edhgAHzgOln53qhY63V2N+T/KEwUBfs0biatPzAfwhhWSbHzUEEF1Ywn4tIjczCZcPiNv5ezNqSg==", + "requires": { + "has-boxed-string-x": "^2.1.0", + "has-working-bind-x": "^1.0.0", + "is-primitive-x": "^1.0.0", + "is-string": "^1.0.4" + } + }, "util.promisify": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.0.tgz", diff --git a/package.json b/package.json index dddda19..3b97a4d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "math-sign-x", - "version": "4.2.0", + "version": "4.2.1", "description": "Shim for Math.sign.", "homepage": "https://github.com/Xotic750/math-sign-x", "author": { @@ -52,7 +52,7 @@ }, "dependencies": { "is-nan-x": "^2.1.0", - "to-number-x": "^3.2.0" + "to-number-x": "^3.2.1" }, "devDependencies": { "@babel/cli": "^7.5.5",