# gutenberg/22.4.4/build/scripts/react-refresh-entry/index.min.js

Gutenberg, version 22.4.4. 1,355 lines.

- Page: https://pluginprobe.com/plugins/gutenberg/22.4.4/code/build/scripts/react-refresh-entry/index.min.js
- Raw: https://pluginprobe.com/plugins/gutenberg/22.4.4/raw/build/scripts/react-refresh-entry/index.min.js
- Modified: 2026-01-20T14:42:56+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/gutenberg/22.4.4/code/build/scripts/react-refresh-entry/index.min.js#L10-L20`.

```javascript
(() => {
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };

  // node_modules/core-js-pure/internals/global.js
  var require_global = __commonJS({
    "node_modules/core-js-pure/internals/global.js"(exports, module) {
      var check = function(it) {
        return it && it.Math == Math && it;
      };
      module.exports = // eslint-disable-next-line es/no-global-this -- safe
      check(typeof globalThis == "object" && globalThis) || check(typeof window == "object" && window) || // eslint-disable-next-line no-restricted-globals -- safe
      check(typeof self == "object" && self) || check(typeof global == "object" && global) || // eslint-disable-next-line no-new-func -- fallback
      /* @__PURE__ */ (function() {
        return this;
      })() || exports || Function("return this")();
    }
  });

  // node_modules/core-js-pure/internals/fails.js
  var require_fails = __commonJS({
    "node_modules/core-js-pure/internals/fails.js"(exports, module) {
      module.exports = function(exec) {
        try {
          return !!exec();
        } catch (error) {
          return true;
        }
      };
    }
  });

  // node_modules/core-js-pure/internals/function-bind-native.js
  var require_function_bind_native = __commonJS({
    "node_modules/core-js-pure/internals/function-bind-native.js"(exports, module) {
      var fails = require_fails();
      module.exports = !fails(function() {
        var test = (function() {
        }).bind();
        return typeof test != "function" || test.hasOwnProperty("prototype");
      });
    }
  });

  // node_modules/core-js-pure/internals/function-apply.js
  var require_function_apply = __commonJS({
    "node_modules/core-js-pure/internals/function-apply.js"(exports, module) {
      var NATIVE_BIND = require_function_bind_native();
      var FunctionPrototype = Function.prototype;
      var apply = FunctionPrototype.apply;
      var call = FunctionPrototype.call;
      module.exports = typeof Reflect == "object" && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function() {
        return call.apply(apply, arguments);
      });
    }
  });

  // node_modules/core-js-pure/internals/function-uncurry-this.js
  var require_function_uncurry_this = __commonJS({
    "node_modules/core-js-pure/internals/function-uncurry-this.js"(exports, module) {
      var NATIVE_BIND = require_function_bind_native();
      var FunctionPrototype = Function.prototype;
      var call = FunctionPrototype.call;
      var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
      module.exports = NATIVE_BIND ? uncurryThisWithBind : function(fn) {
        return function() {
          return call.apply(fn, arguments);
        };
      };
    }
  });

  // node_modules/core-js-pure/internals/classof-raw.js
  var require_classof_raw = __commonJS({
    "node_modules/core-js-pure/internals/classof-raw.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this();
      var toString = uncurryThis({}.toString);
      var stringSlice = uncurryThis("".slice);
      module.exports = function(it) {
        return stringSlice(toString(it), 8, -1);
      };
    }
  });

  // node_modules/core-js-pure/internals/function-uncurry-this-clause.js
  var require_function_uncurry_this_clause = __commonJS({
    "node_modules/core-js-pure/internals/function-uncurry-this-clause.js"(exports, module) {
      var classofRaw = require_classof_raw();
      var uncurryThis = require_function_uncurry_this();
      module.exports = function(fn) {
        if (classofRaw(fn) === "Function") return uncurryThis(fn);
      };
    }
  });

  // node_modules/core-js-pure/internals/document-all.js
  var require_document_all = __commonJS({
    "node_modules/core-js-pure/internals/document-all.js"(exports, module) {
      var documentAll = typeof document == "object" && document.all;
      var IS_HTMLDDA = typeof documentAll == "undefined" && documentAll !== void 0;
      module.exports = {
        all: documentAll,
        IS_HTMLDDA
      };
    }
  });

  // node_modules/core-js-pure/internals/is-callable.js
  var require_is_callable = __commonJS({
    "node_modules/core-js-pure/internals/is-callable.js"(exports, module) {
      var $documentAll = require_document_all();
      var documentAll = $documentAll.all;
      module.exports = $documentAll.IS_HTMLDDA ? function(argument) {
        return typeof argument == "function" || argument === documentAll;
      } : function(argument) {
        return typeof argument == "function";
      };
    }
  });

  // node_modules/core-js-pure/internals/descriptors.js
  var require_descriptors = __commonJS({
    "node_modules/core-js-pure/internals/descriptors.js"(exports, module) {
      var fails = require_fails();
      module.exports = !fails(function() {
        return Object.defineProperty({}, 1, { get: function() {
          return 7;
        } })[1] != 7;
      });
    }
  });

  // node_modules/core-js-pure/internals/function-call.js
  var require_function_call = __commonJS({
    "node_modules/core-js-pure/internals/function-call.js"(exports, module) {
      var NATIVE_BIND = require_function_bind_native();
      var call = Function.prototype.call;
      module.exports = NATIVE_BIND ? call.bind(call) : function() {
        return call.apply(call, arguments);
      };
    }
  });

  // node_modules/core-js-pure/internals/object-property-is-enumerable.js
  var require_object_property_is_enumerable = __commonJS({
    "node_modules/core-js-pure/internals/object-property-is-enumerable.js"(exports) {
      "use strict";
      var $propertyIsEnumerable = {}.propertyIsEnumerable;
      var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
      var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
      exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
        var descriptor = getOwnPropertyDescriptor(this, V);
        return !!descriptor && descriptor.enumerable;
      } : $propertyIsEnumerable;
    }
  });

  // node_modules/core-js-pure/internals/create-property-descriptor.js
  var require_create_property_descriptor = __commonJS({
    "node_modules/core-js-pure/internals/create-property-descriptor.js"(exports, module) {
      module.exports = function(bitmap, value) {
        return {
          enumerable: !(bitmap & 1),
          configurable: !(bitmap & 2),
          writable: !(bitmap & 4),
          value
        };
      };
    }
  });

  // node_modules/core-js-pure/internals/indexed-object.js
  var require_indexed_object = __commonJS({
    "node_modules/core-js-pure/internals/indexed-object.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this();
      var fails = require_fails();
      var classof = require_classof_raw();
      var $Object = Object;
      var split = uncurryThis("".split);
      module.exports = fails(function() {
        return !$Object("z").propertyIsEnumerable(0);
      }) ? function(it) {
        return classof(it) == "String" ? split(it, "") : $Object(it);
      } : $Object;
    }
  });

  // node_modules/core-js-pure/internals/is-null-or-undefined.js
  var require_is_null_or_undefined = __commonJS({
    "node_modules/core-js-pure/internals/is-null-or-undefined.js"(exports, module) {
      module.exports = function(it) {
        return it === null || it === void 0;
      };
    }
  });

  // node_modules/core-js-pure/internals/require-object-coercible.js
  var require_require_object_coercible = __commonJS({
    "node_modules/core-js-pure/internals/require-object-coercible.js"(exports, module) {
      var isNullOrUndefined = require_is_null_or_undefined();
      var $TypeError = TypeError;
      module.exports = function(it) {
        if (isNullOrUndefined(it)) throw $TypeError("Can't call method on " + it);
        return it;
      };
    }
  });

  // node_modules/core-js-pure/internals/to-indexed-object.js
  var require_to_indexed_object = __commonJS({
    "node_modules/core-js-pure/internals/to-indexed-object.js"(exports, module) {
      var IndexedObject = require_indexed_object();
      var requireObjectCoercible = require_require_object_coercible();
      module.exports = function(it) {
        return IndexedObject(requireObjectCoercible(it));
      };
    }
  });

  // node_modules/core-js-pure/internals/is-object.js
  var require_is_object = __commonJS({
    "node_modules/core-js-pure/internals/is-object.js"(exports, module) {
      var isCallable = require_is_callable();
      var $documentAll = require_document_all();
      var documentAll = $documentAll.all;
      module.exports = $documentAll.IS_HTMLDDA ? function(it) {
        return typeof it == "object" ? it !== null : isCallable(it) || it === documentAll;
      } : function(it) {
        return typeof it == "object" ? it !== null : isCallable(it);
      };
    }
  });

  // node_modules/core-js-pure/internals/path.js
  var require_path = __commonJS({
    "node_modules/core-js-pure/internals/path.js"(exports, module) {
      module.exports = {};
    }
  });

  // node_modules/core-js-pure/internals/get-built-in.js
  var require_get_built_in = __commonJS({
    "node_modules/core-js-pure/internals/get-built-in.js"(exports, module) {
      var path = require_path();
      var global2 = require_global();
      var isCallable = require_is_callable();
      var aFunction = function(variable) {
        return isCallable(variable) ? variable : void 0;
      };
      module.exports = function(namespace, method) {
        return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global2[namespace]) : path[namespace] && path[namespace][method] || global2[namespace] && global2[namespace][method];
      };
    }
  });

  // node_modules/core-js-pure/internals/object-is-prototype-of.js
  var require_object_is_prototype_of = __commonJS({
    "node_modules/core-js-pure/internals/object-is-prototype-of.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this();
      module.exports = uncurryThis({}.isPrototypeOf);
    }
  });

  // node_modules/core-js-pure/internals/engine-user-agent.js
  var require_engine_user_agent = __commonJS({
    "node_modules/core-js-pure/internals/engine-user-agent.js"(exports, module) {
      module.exports = typeof navigator != "undefined" && String(navigator.userAgent) || "";
    }
  });

  // node_modules/core-js-pure/internals/engine-v8-version.js
  var require_engine_v8_version = __commonJS({
    "node_modules/core-js-pure/internals/engine-v8-version.js"(exports, module) {
      var global2 = require_global();
      var userAgent = require_engine_user_agent();
      var process2 = global2.process;
      var Deno = global2.Deno;
      var versions = process2 && process2.versions || Deno && Deno.version;
      var v8 = versions && versions.v8;
      var match;
      var version;
      if (v8) {
        match = v8.split(".");
        version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
      }
      if (!version && userAgent) {
        match = userAgent.match(/Edge\/(\d+)/);
        if (!match || match[1] >= 74) {
          match = userAgent.match(/Chrome\/(\d+)/);
          if (match) version = +match[1];
        }
      }
      module.exports = version;
    }
  });

  // node_modules/core-js-pure/internals/symbol-constructor-detection.js
  var require_symbol_constructor_detection = __commonJS({
    "node_modules/core-js-pure/internals/symbol-constructor-detection.js"(exports, module) {
      var V8_VERSION = require_engine_v8_version();
      var fails = require_fails();
      var global2 = require_global();
      var $String = global2.String;
      module.exports = !!Object.getOwnPropertySymbols && !fails(function() {
        var symbol = /* @__PURE__ */ Symbol();
        return !$String(symbol) || !(Object(symbol) instanceof Symbol) || // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
        !Symbol.sham && V8_VERSION && V8_VERSION < 41;
      });
    }
  });

  // node_modules/core-js-pure/internals/use-symbol-as-uid.js
  var require_use_symbol_as_uid = __commonJS({
    "node_modules/core-js-pure/internals/use-symbol-as-uid.js"(exports, module) {
      var NATIVE_SYMBOL = require_symbol_constructor_detection();
      module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == "symbol";
    }
  });

  // node_modules/core-js-pure/internals/is-symbol.js
  var require_is_symbol = __commonJS({
    "node_modules/core-js-pure/internals/is-symbol.js"(exports, module) {
      var getBuiltIn = require_get_built_in();
      var isCallable = require_is_callable();
      var isPrototypeOf = require_object_is_prototype_of();
      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
      var $Object = Object;
      module.exports = USE_SYMBOL_AS_UID ? function(it) {
        return typeof it == "symbol";
      } : function(it) {
        var $Symbol = getBuiltIn("Symbol");
        return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
      };
    }
  });

  // node_modules/core-js-pure/internals/try-to-string.js
  var require_try_to_string = __commonJS({
    "node_modules/core-js-pure/internals/try-to-string.js"(exports, module) {
      var $String = String;
      module.exports = function(argument) {
        try {
          return $String(argument);
        } catch (error) {
          return "Object";
        }
      };
    }
  });

  // node_modules/core-js-pure/internals/a-callable.js
  var require_a_callable = __commonJS({
    "node_modules/core-js-pure/internals/a-callable.js"(exports, module) {
      var isCallable = require_is_callable();
      var tryToString = require_try_to_string();
      var $TypeError = TypeError;
      module.exports = function(argument) {
        if (isCallable(argument)) return argument;
        throw $TypeError(tryToString(argument) + " is not a function");
      };
    }
  });

  // node_modules/core-js-pure/internals/get-method.js
  var require_get_method = __commonJS({
    "node_modules/core-js-pure/internals/get-method.js"(exports, module) {
      var aCallable = require_a_callable();
      var isNullOrUndefined = require_is_null_or_undefined();
      module.exports = function(V, P) {
        var func = V[P];
        return isNullOrUndefined(func) ? void 0 : aCallable(func);
      };
    }
  });

  // node_modules/core-js-pure/internals/ordinary-to-primitive.js
  var require_ordinary_to_primitive = __commonJS({
    "node_modules/core-js-pure/internals/ordinary-to-primitive.js"(exports, module) {
      var call = require_function_call();
      var isCallable = require_is_callable();
      var isObject = require_is_object();
      var $TypeError = TypeError;
      module.exports = function(input, pref) {
        var fn, val;
        if (pref === "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
        if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
        if (pref !== "string" && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
        throw $TypeError("Can't convert object to primitive value");
      };
    }
  });

  // node_modules/core-js-pure/internals/is-pure.js
  var require_is_pure = __commonJS({
    "node_modules/core-js-pure/internals/is-pure.js"(exports, module) {
      module.exports = true;
    }
  });

  // node_modules/core-js-pure/internals/define-global-property.js
  var require_define_global_property = __commonJS({
    "node_modules/core-js-pure/internals/define-global-property.js"(exports, module) {
      var global2 = require_global();
      var defineProperty = Object.defineProperty;
      module.exports = function(key, value) {
        try {
          defineProperty(global2, key, { value, configurable: true, writable: true });
        } catch (error) {
          global2[key] = value;
        }
        return value;
      };
    }
  });

  // node_modules/core-js-pure/internals/shared-store.js
  var require_shared_store = __commonJS({
    "node_modules/core-js-pure/internals/shared-store.js"(exports, module) {
      var global2 = require_global();
      var defineGlobalProperty = require_define_global_property();
      var SHARED = "__core-js_shared__";
      var store = global2[SHARED] || defineGlobalProperty(SHARED, {});
      module.exports = store;
    }
  });

  // node_modules/core-js-pure/internals/shared.js
  var require_shared = __commonJS({
    "node_modules/core-js-pure/internals/shared.js"(exports, module) {
      var IS_PURE = require_is_pure();
      var store = require_shared_store();
      (module.exports = function(key, value) {
        return store[key] || (store[key] = value !== void 0 ? value : {});
      })("versions", []).push({
        version: "3.31.0",
        mode: IS_PURE ? "pure" : "global",
        copyright: "\xA9 2014-2023 Denis Pushkarev (zloirock.ru)",
        license: "https://github.com/zloirock/core-js/blob/v3.31.0/LICENSE",
        source: "https://github.com/zloirock/core-js"
      });
    }
  });

  // node_modules/core-js-pure/internals/to-object.js
  var require_to_object = __commonJS({
    "node_modules/core-js-pure/internals/to-object.js"(exports, module) {
      var requireObjectCoercible = require_require_object_coercible();
      var $Object = Object;
      module.exports = function(argument) {
        return $Object(requireObjectCoercible(argument));
      };
    }
  });

  // node_modules/core-js-pure/internals/has-own-property.js
  var require_has_own_property = __commonJS({
    "node_modules/core-js-pure/internals/has-own-property.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this();
      var toObject = require_to_object();
      var hasOwnProperty = uncurryThis({}.hasOwnProperty);
      module.exports = Object.hasOwn || function hasOwn(it, key) {
        return hasOwnProperty(toObject(it), key);
      };
    }
  });

  // node_modules/core-js-pure/internals/uid.js
  var require_uid = __commonJS({
    "node_modules/core-js-pure/internals/uid.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this();
      var id = 0;
      var postfix = Math.random();
      var toString = uncurryThis(1 .toString);
      module.exports = function(key) {
        return "Symbol(" + (key === void 0 ? "" : key) + ")_" + toString(++id + postfix, 36);
      };
    }
  });

  // node_modules/core-js-pure/internals/well-known-symbol.js
  var require_well_known_symbol = __commonJS({
    "node_modules/core-js-pure/internals/well-known-symbol.js"(exports, module) {
      var global2 = require_global();
      var shared = require_shared();
      var hasOwn = require_has_own_property();
      var uid = require_uid();
      var NATIVE_SYMBOL = require_symbol_constructor_detection();
      var USE_SYMBOL_AS_UID = require_use_symbol_as_uid();
      var Symbol2 = global2.Symbol;
      var WellKnownSymbolsStore = shared("wks");
      var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol2["for"] || Symbol2 : Symbol2 && Symbol2.withoutSetter || uid;
      module.exports = function(name) {
        if (!hasOwn(WellKnownSymbolsStore, name)) {
          WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol2, name) ? Symbol2[name] : createWellKnownSymbol("Symbol." + name);
        }
        return WellKnownSymbolsStore[name];
      };
    }
  });

  // node_modules/core-js-pure/internals/to-primitive.js
  var require_to_primitive = __commonJS({
    "node_modules/core-js-pure/internals/to-primitive.js"(exports, module) {
      var call = require_function_call();
      var isObject = require_is_object();
      var isSymbol = require_is_symbol();
      var getMethod = require_get_method();
      var ordinaryToPrimitive = require_ordinary_to_primitive();
      var wellKnownSymbol = require_well_known_symbol();
      var $TypeError = TypeError;
      var TO_PRIMITIVE = wellKnownSymbol("toPrimitive");
      module.exports = function(input, pref) {
        if (!isObject(input) || isSymbol(input)) return input;
        var exoticToPrim = getMethod(input, TO_PRIMITIVE);
        var result;
        if (exoticToPrim) {
          if (pref === void 0) pref = "default";
          result = call(exoticToPrim, input, pref);
          if (!isObject(result) || isSymbol(result)) return result;
          throw $TypeError("Can't convert object to primitive value");
        }
        if (pref === void 0) pref = "number";
        return ordinaryToPrimitive(input, pref);
      };
    }
  });

  // node_modules/core-js-pure/internals/to-property-key.js
  var require_to_property_key = __commonJS({
    "node_modules/core-js-pure/internals/to-property-key.js"(exports, module) {
      var toPrimitive = require_to_primitive();
      var isSymbol = require_is_symbol();
      module.exports = function(argument) {
        var key = toPrimitive(argument, "string");
        return isSymbol(key) ? key : key + "";
      };
    }
  });

  // node_modules/core-js-pure/internals/document-create-element.js
  var require_document_create_element = __commonJS({
    "node_modules/core-js-pure/internals/document-create-element.js"(exports, module) {
      var global2 = require_global();
      var isObject = require_is_object();
      var document2 = global2.document;
      var EXISTS = isObject(document2) && isObject(document2.createElement);
      module.exports = function(it) {
        return EXISTS ? document2.createElement(it) : {};
      };
    }
  });

  // node_modules/core-js-pure/internals/ie8-dom-define.js
  var require_ie8_dom_define = __commonJS({
    "node_modules/core-js-pure/internals/ie8-dom-define.js"(exports, module) {
      var DESCRIPTORS = require_descriptors();
      var fails = require_fails();
      var createElement = require_document_create_element();
      module.exports = !DESCRIPTORS && !fails(function() {
        return Object.defineProperty(createElement("div"), "a", {
          get: function() {
            return 7;
          }
        }).a != 7;
      });
    }
  });

  // node_modules/core-js-pure/internals/object-get-own-property-descriptor.js
  var require_object_get_own_property_descriptor = __commonJS({
    "node_modules/core-js-pure/internals/object-get-own-property-descriptor.js"(exports) {
      var DESCRIPTORS = require_descriptors();
      var call = require_function_call();
      var propertyIsEnumerableModule = require_object_property_is_enumerable();
      var createPropertyDescriptor = require_create_property_descriptor();
      var toIndexedObject = require_to_indexed_object();
      var toPropertyKey = require_to_property_key();
      var hasOwn = require_has_own_property();
      var IE8_DOM_DEFINE = require_ie8_dom_define();
      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
      exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
        O = toIndexedObject(O);
        P = toPropertyKey(P);
        if (IE8_DOM_DEFINE) try {
          return $getOwnPropertyDescriptor(O, P);
        } catch (error) {
        }
        if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
      };
    }
  });

  // node_modules/core-js-pure/internals/is-forced.js
  var require_is_forced = __commonJS({
    "node_modules/core-js-pure/internals/is-forced.js"(exports, module) {
      var fails = require_fails();
      var isCallable = require_is_callable();
      var replacement = /#|\.prototype\./;
      var isForced = function(feature, detection) {
        var value = data[normalize(feature)];
        return value == POLYFILL ? true : value == NATIVE ? false : isCallable(detection) ? fails(detection) : !!detection;
      };
      var normalize = isForced.normalize = function(string) {
        return String(string).replace(replacement, ".").toLowerCase();
      };
      var data = isForced.data = {};
      var NATIVE = isForced.NATIVE = "N";
      var POLYFILL = isForced.POLYFILL = "P";
      module.exports = isForced;
    }
  });

  // node_modules/core-js-pure/internals/function-bind-context.js
  var require_function_bind_context = __commonJS({
    "node_modules/core-js-pure/internals/function-bind-context.js"(exports, module) {
      var uncurryThis = require_function_uncurry_this_clause();
      var aCallable = require_a_callable();
      var NATIVE_BIND = require_function_bind_native();
      var bind = uncurryThis(uncurryThis.bind);
      module.exports = function(fn, that) {
        aCallable(fn);
        return that === void 0 ? fn : NATIVE_BIND ? bind(fn, that) : function() {
          return fn.apply(that, arguments);
        };
      };
    }
  });

  // node_modules/core-js-pure/internals/v8-prototype-define-bug.js
  var require_v8_prototype_define_bug = __commonJS({
    "node_modules/core-js-pure/internals/v8-prototype-define-bug.js"(exports, module) {
      var DESCRIPTORS = require_descriptors();
      var fails = require_fails();
      module.exports = DESCRIPTORS && fails(function() {
        return Object.defineProperty(function() {
        }, "prototype", {
          value: 42,
          writable: false
        }).prototype != 42;
      });
    }
  });

  // node_modules/core-js-pure/internals/an-object.js
  var require_an_object = __commonJS({
    "node_modules/core-js-pure/internals/an-object.js"(exports, module) {
      var isObject = require_is_object();
      var $String = String;
      var $TypeError = TypeError;
      module.exports = function(argument) {
        if (isObject(argument)) return argument;
        throw $TypeError($String(argument) + " is not an object");
      };
    }
  });

  // node_modules/core-js-pure/internals/object-define-property.js
  var require_object_define_property = __commonJS({
    "node_modules/core-js-pure/internals/object-define-property.js"(exports) {
      var DESCRIPTORS = require_descriptors();
      var IE8_DOM_DEFINE = require_ie8_dom_define();
      var V8_PROTOTYPE_DEFINE_BUG = require_v8_prototype_define_bug();
      var anObject = require_an_object();
      var toPropertyKey = require_to_property_key();
      var $TypeError = TypeError;
      var $defineProperty = Object.defineProperty;
      var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
      var ENUMERABLE = "enumerable";
      var CONFIGURABLE = "configurable";
      var WRITABLE = "writable";
      exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
        anObject(O);
        P = toPropertyKey(P);
        anObject(Attributes);
        if (typeof O === "function" && P === "prototype" && "value" in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
          var current = $getOwnPropertyDescriptor(O, P);
          if (current && current[WRITABLE]) {
            O[P] = Attributes.value;
            Attributes = {
              configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
              enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
              writable: false
            };
          }
        }
        return $defineProperty(O, P, Attributes);
      } : $defineProperty : function defineProperty(O, P, Attributes) {
        anObject(O);
        P = toPropertyKey(P);
        anObject(Attributes);
        if (IE8_DOM_DEFINE) try {
          return $defineProperty(O, P, Attributes);
        } catch (error) {
        }
        if ("get" in Attributes || "set" in Attributes) throw $TypeError("Accessors not supported");
        if ("value" in Attributes) O[P] = Attributes.value;
        return O;
      };
    }
  });

  // node_modules/core-js-pure/internals/create-non-enumerable-property.js
  var require_create_non_enumerable_property = __commonJS({
    "node_modules/core-js-pure/internals/create-non-enumerable-property.js"(exports, module) {
      var DESCRIPTORS = require_descriptors();
      var definePropertyModule = require_object_define_property();
      var createPropertyDescriptor = require_create_property_descriptor();
      module.exports = DESCRIPTORS ? function(object, key, value) {
        return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
      } : function(object, key, value) {
        object[key] = value;
        return object;
      };
    }
  });

  // node_modules/core-js-pure/internals/export.js
  var require_export = __commonJS({
    "node_modules/core-js-pure/internals/export.js"(exports, module) {
      "use strict";
      var global2 = require_global();
      var apply = require_function_apply();
      var uncurryThis = require_function_uncurry_this_clause();
      var isCallable = require_is_callable();
      var getOwnPropertyDescriptor = require_object_get_own_property_descriptor().f;
      var isForced = require_is_forced();
      var path = require_path();
      var bind = require_function_bind_context();
      var createNonEnumerableProperty = require_create_non_enumerable_property();
      var hasOwn = require_has_own_property();
      var wrapConstructor = function(NativeConstructor) {
        var Wrapper = function(a, b, c) {
          if (this instanceof Wrapper) {
            switch (arguments.length) {
              case 0:
                return new NativeConstructor();
              case 1:
                return new NativeConstructor(a);
              case 2:
                return new NativeConstructor(a, b);
            }
            return new NativeConstructor(a, b, c);
          }
          return apply(NativeConstructor, this, arguments);
        };
        Wrapper.prototype = NativeConstructor.prototype;
        return Wrapper;
      };
      module.exports = function(options, source) {
        var TARGET = options.target;
        var GLOBAL = options.global;
        var STATIC = options.stat;
        var PROTO = options.proto;
        var nativeSource = GLOBAL ? global2 : STATIC ? global2[TARGET] : (global2[TARGET] || {}).prototype;
        var target = GLOBAL ? path : path[TARGET] || createNonEnumerableProperty(path, TARGET, {})[TARGET];
        var targetPrototype = target.prototype;
        var FORCED, USE_NATIVE, VIRTUAL_PROTOTYPE;
        var key, sourceProperty, targetProperty, nativeProperty, resultProperty, descriptor;
        for (key in source) {
          FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? "." : "#") + key, options.forced);
          USE_NATIVE = !FORCED && nativeSource && hasOwn(nativeSource, key);
          targetProperty = target[key];
          if (USE_NATIVE) if (options.dontCallGetSet) {
            descriptor = getOwnPropertyDescriptor(nativeSource, key);
            nativeProperty = descriptor && descriptor.value;
          } else nativeProperty = nativeSource[key];
          sourceProperty = USE_NATIVE && nativeProperty ? nativeProperty : source[key];
          if (USE_NATIVE && typeof targetProperty == typeof sourceProperty) continue;
          if (options.bind && USE_NATIVE) resultProperty = bind(sourceProperty, global2);
          else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty);
          else if (PROTO && isCallable(sourceProperty)) resultProperty = uncurryThis(sourceProperty);
          else resultProperty = sourceProperty;
          if (options.sham || sourceProperty && sourceProperty.sham || targetProperty && targetProperty.sham) {
            createNonEnumerableProperty(resultProperty, "sham", true);
          }
          createNonEnumerableProperty(target, key, resultProperty);
          if (PROTO) {
            VIRTUAL_PROTOTYPE = TARGET + "Prototype";
            if (!hasOwn(path, VIRTUAL_PROTOTYPE)) {
              createNonEnumerableProperty(path, VIRTUAL_PROTOTYPE, {});
            }
            createNonEnumerableProperty(path[VIRTUAL_PROTOTYPE], key, sourceProperty);
            if (options.real && targetPrototype && (FORCED || !targetPrototype[key])) {
              createNonEnumerableProperty(targetPrototype, key, sourceProperty);
            }
          }
        }
      };
    }
  });

  // node_modules/core-js-pure/modules/es.global-this.js
  var require_es_global_this = __commonJS({
    "node_modules/core-js-pure/modules/es.global-this.js"() {
      var $ = require_export();
      var global2 = require_global();
      $({ global: true, forced: global2.globalThis !== global2 }, {
        globalThis: global2
      });
    }
  });

  // node_modules/core-js-pure/modules/esnext.global-this.js
  var require_esnext_global_this = __commonJS({
    "node_modules/core-js-pure/modules/esnext.global-this.js"() {
      require_es_global_this();
    }
  });

  // node_modules/core-js-pure/es/global-this.js
  var require_global_this = __commonJS({
    "node_modules/core-js-pure/es/global-this.js"(exports, module) {
      require_es_global_this();
      module.exports = require_global();
    }
  });

  // node_modules/core-js-pure/stable/global-this.js
  var require_global_this2 = __commonJS({
    "node_modules/core-js-pure/stable/global-this.js"(exports, module) {
      var parent = require_global_this();
      module.exports = parent;
    }
  });

  // node_modules/core-js-pure/actual/global-this.js
  var require_global_this3 = __commonJS({
    "node_modules/core-js-pure/actual/global-this.js"(exports, module) {
      var parent = require_global_this2();
      module.exports = parent;
    }
  });

  // node_modules/core-js-pure/full/global-this.js
  var require_global_this4 = __commonJS({
    "node_modules/core-js-pure/full/global-this.js"(exports, module) {
      require_esnext_global_this();
      var parent = require_global_this3();
      module.exports = parent;
    }
  });

  // node_modules/core-js-pure/features/global-this.js
  var require_global_this5 = __commonJS({
    "node_modules/core-js-pure/features/global-this.js"(exports, module) {
      module.exports = require_global_this4();
    }
  });

  // node_modules/react-refresh/cjs/react-refresh-runtime.development.js
  var require_react_refresh_runtime_development = __commonJS({
    "node_modules/react-refresh/cjs/react-refresh-runtime.development.js"(exports) {
      "use strict";
      if (true) {
        (function() {
          "use strict";
          var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
          var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
          var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
          var allFamiliesByID = /* @__PURE__ */ new Map();
          var allFamiliesByType = new PossiblyWeakMap();
          var allSignaturesByType = new PossiblyWeakMap();
          var updatedFamiliesByType = new PossiblyWeakMap();
          var pendingUpdates = [];
          var helpersByRendererID = /* @__PURE__ */ new Map();
          var helpersByRoot = /* @__PURE__ */ new Map();
          var mountedRoots = /* @__PURE__ */ new Set();
          var failedRoots = /* @__PURE__ */ new Set();
          var rootElements = (
            // $FlowIssue
            typeof WeakMap === "function" ? /* @__PURE__ */ new WeakMap() : null
          );
          var isPerformingRefresh = false;
          function computeFullKey(signature) {
            if (signature.fullKey !== null) {
              return signature.fullKey;
            }
            var fullKey = signature.ownKey;
            var hooks;
            try {
              hooks = signature.getCustomHooks();
            } catch (err) {
              signature.forceReset = true;
              signature.fullKey = fullKey;
              return fullKey;
            }
            for (var i = 0; i < hooks.length; i++) {
              var hook = hooks[i];
              if (typeof hook !== "function") {
                signature.forceReset = true;
                signature.fullKey = fullKey;
                return fullKey;
              }
              var nestedHookSignature = allSignaturesByType.get(hook);
              if (nestedHookSignature === void 0) {
                continue;
              }
              var nestedHookKey = computeFullKey(nestedHookSignature);
              if (nestedHookSignature.forceReset) {
                signature.forceReset = true;
              }
              fullKey += "\n---\n" + nestedHookKey;
            }
            signature.fullKey = fullKey;
            return fullKey;
          }
          function haveEqualSignatures(prevType, nextType) {
            var prevSignature = allSignaturesByType.get(prevType);
            var nextSignature = allSignaturesByType.get(nextType);
            if (prevSignature === void 0 && nextSignature === void 0) {
              return true;
            }
            if (prevSignature === void 0 || nextSignature === void 0) {
              return false;
            }
            if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
              return false;
            }
            if (nextSignature.forceReset) {
              return false;
            }
            return true;
          }
          function isReactClass(type) {
            return type.prototype && type.prototype.isReactComponent;
          }
          function canPreserveStateBetween(prevType, nextType) {
            if (isReactClass(prevType) || isReactClass(nextType)) {
              return false;
            }
            if (haveEqualSignatures(prevType, nextType)) {
              return true;
            }
            return false;
          }
          function resolveFamily(type) {
            return updatedFamiliesByType.get(type);
          }
          function cloneMap(map) {
            var clone = /* @__PURE__ */ new Map();
            map.forEach(function(value, key) {
              clone.set(key, value);
            });
            return clone;
          }
          function cloneSet(set) {
            var clone = /* @__PURE__ */ new Set();
            set.forEach(function(value) {
              clone.add(value);
            });
            return clone;
          }
          function getProperty(object, property) {
            try {
              return object[property];
            } catch (err) {
              return void 0;
            }
          }
          function performReactRefresh() {
            if (pendingUpdates.length === 0) {
              return null;
            }
            if (isPerformingRefresh) {
              return null;
            }
            isPerformingRefresh = true;
            try {
              var staleFamilies = /* @__PURE__ */ new Set();
              var updatedFamilies = /* @__PURE__ */ new Set();
              var updates = pendingUpdates;
              pendingUpdates = [];
              updates.forEach(function(_ref) {
                var family = _ref[0], nextType = _ref[1];
                var prevType = family.current;
                updatedFamiliesByType.set(prevType, family);
                updatedFamiliesByType.set(nextType, family);
                family.current = nextType;
                if (canPreserveStateBetween(prevType, nextType)) {
                  updatedFamilies.add(family);
                } else {
                  staleFamilies.add(family);
                }
              });
              var update = {
                updatedFamilies,
                // Families that will re-render preserving state
                staleFamilies
                // Families that will be remounted
              };
              helpersByRendererID.forEach(function(helpers) {
                helpers.setRefreshHandler(resolveFamily);
              });
              var didError = false;
              var firstError = null;
              var failedRootsSnapshot = cloneSet(failedRoots);
              var mountedRootsSnapshot = cloneSet(mountedRoots);
              var helpersByRootSnapshot = cloneMap(helpersByRoot);
              failedRootsSnapshot.forEach(function(root) {
                var helpers = helpersByRootSnapshot.get(root);
                if (helpers === void 0) {
                  throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");
                }
                if (!failedRoots.has(root)) {
                }
                if (rootElements === null) {
                  return;
                }
                if (!rootElements.has(root)) {
                  return;
                }
                var element = rootElements.get(root);
                try {
                  helpers.scheduleRoot(root, element);
                } catch (err) {
                  if (!didError) {
                    didError = true;
                    firstError = err;
                  }
                }
              });
              mountedRootsSnapshot.forEach(function(root) {
                var helpers = helpersByRootSnapshot.get(root);
                if (helpers === void 0) {
                  throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");
                }
                if (!mountedRoots.has(root)) {
                }
                try {
                  helpers.scheduleRefresh(root, update);
                } catch (err) {
                  if (!didError) {
                    didError = true;
                    firstError = err;
                  }
                }
              });
              if (didError) {
                throw firstError;
              }
              return update;
            } finally {
              isPerformingRefresh = false;
            }
          }
          function register(type, id) {
            {
              if (type === null) {
                return;
              }
              if (typeof type !== "function" && typeof type !== "object") {
                return;
              }
              if (allFamiliesByType.has(type)) {
                return;
              }
              var family = allFamiliesByID.get(id);
              if (family === void 0) {
                family = {
                  current: type
                };
                allFamiliesByID.set(id, family);
              } else {
                pendingUpdates.push([family, type]);
              }
              allFamiliesByType.set(type, family);
              if (typeof type === "object" && type !== null) {
                switch (getProperty(type, "$$typeof")) {
                  case REACT_FORWARD_REF_TYPE:
                    register(type.render, id + "$render");
                    break;
                  case REACT_MEMO_TYPE:
                    register(type.type, id + "$type");
                    break;
                }
              }
            }
          }
          function setSignature(type, key) {
            var forceReset = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
            var getCustomHooks = arguments.length > 3 ? arguments[3] : void 0;
            {
              if (!allSignaturesByType.has(type)) {
                allSignaturesByType.set(type, {
                  forceReset,
                  ownKey: key,
                  fullKey: null,
                  getCustomHooks: getCustomHooks || function() {
                    return [];
                  }
                });
              }
              if (typeof type === "object" && type !== null) {
                switch (getProperty(type, "$$typeof")) {
                  case REACT_FORWARD_REF_TYPE:
                    setSignature(type.render, key, forceReset, getCustomHooks);
                    break;
                  case REACT_MEMO_TYPE:
                    setSignature(type.type, key, forceReset, getCustomHooks);
                    break;
                }
              }
            }
          }
          function collectCustomHooksForSignature(type) {
            {
              var signature = allSignaturesByType.get(type);
              if (signature !== void 0) {
                computeFullKey(signature);
              }
            }
          }
          function getFamilyByID(id) {
            {
              return allFamiliesByID.get(id);
            }
          }
          function getFamilyByType(type) {
            {
              return allFamiliesByType.get(type);
            }
          }
          function findAffectedHostInstances(families) {
            {
              var affectedInstances = /* @__PURE__ */ new Set();
              mountedRoots.forEach(function(root) {
                var helpers = helpersByRoot.get(root);
                if (helpers === void 0) {
                  throw new Error("Could not find helpers for a root. This is a bug in React Refresh.");
                }
                var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
                instancesForRoot.forEach(function(inst) {
                  affectedInstances.add(inst);
                });
              });
              return affectedInstances;
            }
          }
          function injectIntoGlobalHook(globalObject) {
            {
              var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
              if (hook === void 0) {
                var nextID = 0;
                globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
                  renderers: /* @__PURE__ */ new Map(),
                  supportsFiber: true,
                  inject: function(injected) {
                    return nextID++;
                  },
                  onScheduleFiberRoot: function(id, root, children) {
                  },
                  onCommitFiberRoot: function(id, root, maybePriorityLevel, didError) {
                  },
                  onCommitFiberUnmount: function() {
                  }
                };
              }
              if (hook.isDisabled) {
                console["warn"]("Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled.");
                return;
              }
              var oldInject = hook.inject;
              hook.inject = function(injected) {
                var id = oldInject.apply(this, arguments);
                if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") {
                  helpersByRendererID.set(id, injected);
                }
                return id;
              };
              hook.renderers.forEach(function(injected, id) {
                if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") {
                  helpersByRendererID.set(id, injected);
                }
              });
              var oldOnCommitFiberRoot = hook.onCommitFiberRoot;
              var oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {
              };
              hook.onScheduleFiberRoot = function(id, root, children) {
                if (!isPerformingRefresh) {
                  failedRoots.delete(root);
                  if (rootElements !== null) {
                    rootElements.set(root, children);
                  }
                }
                return oldOnScheduleFiberRoot.apply(this, arguments);
              };
              hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
                var helpers = helpersByRendererID.get(id);
                if (helpers !== void 0) {
                  helpersByRoot.set(root, helpers);
                  var current = root.current;
                  var alternate = current.alternate;
                  if (alternate !== null) {
                    var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root);
                    var isMounted = current.memoizedState != null && current.memoizedState.element != null;
                    if (!wasMounted && isMounted) {
                      mountedRoots.add(root);
                      failedRoots.delete(root);
                    } else if (wasMounted && isMounted) ;
                    else if (wasMounted && !isMounted) {
                      mountedRoots.delete(root);
                      if (didError) {
                        failedRoots.add(root);
                      } else {
                        helpersByRoot.delete(root);
                      }
                    } else if (!wasMounted && !isMounted) {
                      if (didError) {
                        failedRoots.add(root);
                      }
                    }
                  } else {
                    mountedRoots.add(root);
                  }
                }
                return oldOnCommitFiberRoot.apply(this, arguments);
              };
            }
          }
          function hasUnrecoverableErrors() {
            return false;
          }
          function _getMountedRootCount() {
            {
              return mountedRoots.size;
            }
          }
          function createSignatureFunctionForTransform() {
            {
              var savedType;
              var hasCustomHooks;
              var didCollectHooks = false;
              return function(type, key, forceReset, getCustomHooks) {
                if (typeof key === "string") {
                  if (!savedType) {
                    savedType = type;
                    hasCustomHooks = typeof getCustomHooks === "function";
                  }
                  if (type != null && (typeof type === "function" || typeof type === "object")) {
                    setSignature(type, key, forceReset, getCustomHooks);
                  }
                  return type;
                } else {
                  if (!didCollectHooks && hasCustomHooks) {
                    didCollectHooks = true;
                    collectCustomHooksForSignature(savedType);
                  }
                }
              };
            }
          }
          function isLikelyComponentType(type) {
            {
              switch (typeof type) {
                case "function": {
                  if (type.prototype != null) {
                    if (type.prototype.isReactComponent) {
                      return true;
                    }
                    var ownNames = Object.getOwnPropertyNames(type.prototype);
                    if (ownNames.length > 1 || ownNames[0] !== "constructor") {
                      return false;
                    }
                    if (type.prototype.__proto__ !== Object.prototype) {
                      return false;
                    }
                  }
                  var name = type.name || type.displayName;
                  return typeof name === "string" && /^[A-Z]/.test(name);
                }
                case "object": {
                  if (type != null) {
                    switch (getProperty(type, "$$typeof")) {
                      case REACT_FORWARD_REF_TYPE:
                      case REACT_MEMO_TYPE:
                        return true;
                      default:
                        return false;
                    }
                  }
                  return false;
                }
                default: {
                  return false;
                }
              }
            }
          }
          exports._getMountedRootCount = _getMountedRootCount;
          exports.collectCustomHooksForSignature = collectCustomHooksForSignature;
          exports.createSignatureFunctionForTransform = createSignatureFunctionForTransform;
          exports.findAffectedHostInstances = findAffectedHostInstances;
          exports.getFamilyByID = getFamilyByID;
          exports.getFamilyByType = getFamilyByType;
          exports.hasUnrecoverableErrors = hasUnrecoverableErrors;
          exports.injectIntoGlobalHook = injectIntoGlobalHook;
          exports.isLikelyComponentType = isLikelyComponentType;
          exports.performReactRefresh = performReactRefresh;
          exports.register = register;
          exports.setSignature = setSignature;
        })();
      }
    }
  });

  // node_modules/react-refresh/runtime.js
  var require_runtime = __commonJS({
    "node_modules/react-refresh/runtime.js"(exports, module) {
      "use strict";
      if (false) {
        module.exports = null;
      } else {
        module.exports = require_react_refresh_runtime_development();
      }
    }
  });

  // node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js
  var require_ReactRefreshEntry = __commonJS({
    "node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js"() {
      var safeThis = require_global_this5();
      var RefreshRuntime = require_runtime();
      if (true) {
        if (typeof safeThis !== "undefined") {
          $RefreshInjected$ = "__reactRefreshInjected";
          if (typeof __react_refresh_library__ !== "undefined" && __react_refresh_library__) {
            $RefreshInjected$ += "_" + __react_refresh_library__;
          }
          if (!safeThis[$RefreshInjected$]) {
            RefreshRuntime.injectIntoGlobalHook(safeThis);
            safeThis[$RefreshInjected$] = true;
          }
        }
      }
      var $RefreshInjected$;
    }
  });
  require_ReactRefreshEntry();
})();
/*! Bundled license information:

react-refresh/cjs/react-refresh-runtime.development.js:
  (**
   * @license React
   * react-refresh-runtime.development.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)
*/

```