@plasmicapp/react-web 0.2.294 → 0.2.296

package/dist/react-web.esm.js

@@ -13,7 +13,6 @@ import { SSRProvider, useIsSSR as useIsSSR$1 } from '@react-aria/ssr';
 import { useFocusRing, useFocusable, FocusScope } from '@react-aria/focus';
 import { proxy, useSnapshot, ref, getVersion, subscribe } from 'valtio';
 import clone from 'clone';
-import deepEqual from 'fast-deep-equal';
 import { useCheckbox as useCheckbox$1 } from '@react-aria/checkbox';
 import { VisuallyHidden } from '@react-aria/visually-hidden';
 import { useToggleState } from '@react-stately/toggle';
@@ -2641,6 +2640,132 @@ function assignValue(object, key, value) {
         baseAssignValue(object, key, value);
     }
 }
+var isInstanceOfMap = function (a) {
+    return a != null &&
+        typeof a === "object" &&
+        "size" in a &&
+        typeof a.entries === "function" &&
+        typeof a.get === "function" &&
+        typeof a.set === "function" &&
+        typeof a.has === "function";
+};
+var isInstanceOfSet = function (a) {
+    return a != null &&
+        typeof a === "object" &&
+        "size" in a &&
+        typeof a.entries === "function" &&
+        typeof a.add === "function" &&
+        typeof a.has === "function" &&
+        typeof a.delete === "function";
+};
+var isRegExp = function (a) {
+    return Object.prototype.toString.call(a) === "[object RegExp]";
+};
+/**
+ * Forked from https://github.com/jamesfoster/DeepEqual
+ * Changes: removed the comparison between constructors and instanceof objects
+ * because they are dependent on the window object
+ */
+function deepEqual(a, b) {
+    var e_4, _a, e_5, _b, e_6, _c;
+    if (a === b)
+        return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+        // if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (!deepEqual(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        // if ((a instanceof Map) && (b instanceof Map)) {
+        if (isInstanceOfMap(a) && isInstanceOfMap(b)) {
+            if (a.size !== b.size)
+                return false;
+            try {
+                for (var _d = __values(a.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    i = _e.value;
+                    if (!b.has(i[0]))
+                        return false;
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            try {
+                for (var _f = __values(a.entries()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    i = _g.value;
+                    if (!deepEqual(i[1], b.get(i[0])))
+                        return false;
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            return true;
+        }
+        // if ((a instanceof Set) && (b instanceof Set)) {
+        if (isInstanceOfSet(a) && isInstanceOfSet(b)) {
+            if (a.size !== b.size)
+                return false;
+            try {
+                for (var _h = __values(a.entries()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    i = _j.value;
+                    if (!b.has(i[0]))
+                        return false;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return true;
+        }
+        // if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (isRegExp(a) && isRegExp(b))
+            return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+            return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+            return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+                return false;
+        for (i = length; i-- !== 0;) {
+            var key = keys[i];
+            if (key === "_owner" && a.$$typeof) {
+                // React-specific: avoid traversing React elements' _owner.
+                //  _owner contains circular references
+                // and is not needed when comparing the actual elements (and not their owners)
+                continue;
+            }
+            if (!deepEqual(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    // true if both NaN, false otherwise
+    return a !== a && b !== b;
+}
 
 // Utilities used by generated code
 var classNames = classNames$1;