same-value-zero-x
Version:
ES6-compliant shim for SameValueZero.
230 lines (203 loc) • 7.5 kB
JavaScript
/*!
{
"author": "Graham Fairweather",
"copywrite": "Copyright (c) 2015-present",
"date": "2019-08-28T16:44:59.369Z",
"describe": "",
"description": "ES6-compliant shim for SameValueZero.",
"file": "same-value-zero-x.js",
"hash": "87e85ab7283374e5462b",
"license": "MIT",
"version": "2.1.1"
}
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["sameValueZeroX"] = factory();
else
root["sameValueZeroX"] = factory();
})((function () {
'use strict';
var ObjectCtr = {}.constructor;
var objectPrototype = ObjectCtr.prototype;
var defineProperty = ObjectCtr.defineProperty;
var $globalThis;
var getGlobalFallback = function() {
if (typeof self !== 'undefined') {
return self;
}
if (typeof window !== 'undefined') {
return window;
}
if (typeof global !== 'undefined') {
return global;
}
return void 0;
};
var returnThis = function() {
return this;
};
try {
if (defineProperty) {
defineProperty(objectPrototype, '$$globalThis$$', {
get: returnThis,
configurable: true
});
} else {
objectPrototype.__defineGetter__('$$globalThis$$', returnThis);
}
$globalThis = typeof $$globalThis$$ === 'undefined' ? getGlobalFallback() : $$globalThis$$;
delete objectPrototype.$$globalThis$$;
return $globalThis;
} catch (error) {
return getGlobalFallback();
}
}()), function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
// CONCATENATED MODULE: ./node_modules/is-nan-x/dist/is-nan-x.esm.js
/**
* This method determines whether the passed value is NaN and its type is
* `Number`. It is a more robust version of the original, global isNaN().
*
* @param {*} [value] - The value to be tested for NaN.
* @returns {boolean} `true` if the given value is NaN and its type is Number;
* otherwise, `false`.
*/
var is_nan_x_esm_isNaN = function isNaN(value) {
/* eslint-disable-next-line no-self-compare */
return value !== value;
};
/* harmony default export */ var is_nan_x_esm = (is_nan_x_esm_isNaN);
// CONCATENATED MODULE: ./node_modules/same-value-x/dist/same-value-x.esm.js
/**
* This method is the comparison abstract operation SameValue(x, y), where x
* and y are ECMAScript language values, produces true or false.
*
* @param {*} [value1] - The first value to compare.
* @param {*} [value2] - The second value to compare.
* @returns {boolean} A Boolean indicating whether or not the two arguments are
* the same value.
*/
var same_value_x_esm_sameValue = function sameValue(value1, value2) {
if (value1 === 0 && value2 === 0) {
return 1 / value1 === 1 / value2;
}
if (value1 === value2) {
return true;
}
return is_nan_x_esm(value1) && is_nan_x_esm(value2);
};
/* harmony default export */ var same_value_x_esm = (same_value_x_esm_sameValue);
// CONCATENATED MODULE: ./dist/same-value-zero-x.esm.js
/**
* This method determines whether two values are the same value.
* SameValueZero differs from SameValue (`Object.is`) only in its treatment
* of +0 and -0.
*
* @param {*} [x] - The first value to compare.
* @param {*} [y] - The second value to compare.
* @returns {boolean} A Boolean indicating whether or not the two arguments
* are the same value.
*/
var same_value_zero_x_esm_sameValueZero = function sameValueZero(x, y) {
return x === y || same_value_x_esm(x, y);
};
/* harmony default export */ var same_value_zero_x_esm = __webpack_exports__["default"] = (same_value_zero_x_esm_sameValueZero);
/***/ })
/******/ ]);
});
//# sourceMappingURL=same-value-zero-x.js.map