balmet.com

is-shallow-equal.js (6686B)

---

 this["wp"] = this["wp"] || {}; this["wp"]["isShallowEqual"] =
 /******/ (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 = "waYt");
 /******/ })
 /************************************************************************/
 /******/ ({
 
 /***/ "waYt":
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, "isShallowEqualObjects", function() { return /* reexport */ isShallowEqualObjects; });
 __webpack_require__.d(__webpack_exports__, "isShallowEqualArrays", function() { return /* reexport */ isShallowEqualArrays; });
 __webpack_require__.d(__webpack_exports__, "default", function() { return /* binding */ isShallowEqual; });
 
 // CONCATENATED MODULE: ./node_modules/@wordpress/is-shallow-equal/build-module/objects.js
 /**
  * Returns true if the two objects are shallow equal, or false otherwise.
  *
  * @param {import('.').ComparableObject} a First object to compare.
  * @param {import('.').ComparableObject} b Second object to compare.
  *
  * @return {boolean} Whether the two objects are shallow equal.
  */
 function isShallowEqualObjects(a, b) {
   if (a === b) {
     return true;
   }
 
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
 
   if (aKeys.length !== bKeys.length) {
     return false;
   }
 
   let i = 0;
 
   while (i < aKeys.length) {
     const key = aKeys[i];
     const aValue = a[key];
 
     if ( // In iterating only the keys of the first object after verifying
     // equal lengths, account for the case that an explicit `undefined`
     // value in the first is implicitly undefined in the second.
     //
     // Example: isShallowEqualObjects( { a: undefined }, { b: 5 } )
     aValue === undefined && !b.hasOwnProperty(key) || aValue !== b[key]) {
       return false;
     }
 
     i++;
   }
 
   return true;
 }
 
 // CONCATENATED MODULE: ./node_modules/@wordpress/is-shallow-equal/build-module/arrays.js
 /**
  * Returns true if the two arrays are shallow equal, or false otherwise.
  *
  * @param {any[]} a First array to compare.
  * @param {any[]} b Second array to compare.
  *
  * @return {boolean} Whether the two arrays are shallow equal.
  */
 function isShallowEqualArrays(a, b) {
   if (a === b) {
     return true;
   }
 
   if (a.length !== b.length) {
     return false;
   }
 
   for (let i = 0, len = a.length; i < len; i++) {
     if (a[i] !== b[i]) {
       return false;
     }
   }
 
   return true;
 }
 
 // CONCATENATED MODULE: ./node_modules/@wordpress/is-shallow-equal/build-module/index.js
 /**
  * Internal dependencies
  */
 
 
 
 
 /**
  * @typedef {Record<string, any>} ComparableObject
  */
 
 /**
  * Returns true if the two arrays or objects are shallow equal, or false
  * otherwise.
  *
  * @param {any[]|ComparableObject} a First object or array to compare.
  * @param {any[]|ComparableObject} b Second object or array to compare.
  *
  * @return {boolean} Whether the two values are shallow equal.
  */
 
 function isShallowEqual(a, b) {
   if (a && b) {
     if (a.constructor === Object && b.constructor === Object) {
       return isShallowEqualObjects(a, b);
     } else if (Array.isArray(a) && Array.isArray(b)) {
       return isShallowEqualArrays(a, b);
     }
   }
 
   return a === b;
 }
 
 
 /***/ })
 
 /******/ });