@kelet-ai/feedback-ui 0.4.1 → 0.5.1

package/dist/feedback-ui.es.js

@@ -1,32 +1,38 @@
-import Ae, { createContext as Ee, useContext as ae, useCallback as W, isValidElement as Z, cloneElement as Q, useState as X, useRef as U, useId as ce, useEffect as De } from "react";
-function _e(n) {
-  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+import require$$0$1, { createContext, useContext, useCallback, isValidElement, cloneElement, useState, useRef, useId, useEffect } from "react";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-function Se(n) {
+function getAugmentedNamespace(n) {
   if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
-  var e = n.default;
-  if (typeof e == "function") {
-    var t = function r() {
-      var o = !1;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      var isInstance = false;
       try {
-        o = this instanceof r;
+        isInstance = this instanceof a2;
       } catch {
       }
-      return o ? Reflect.construct(e, arguments, this.constructor) : e.apply(this, arguments);
+      if (isInstance) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
     };
-    t.prototype = e.prototype;
-  } else t = {};
-  return Object.defineProperty(t, "__esModule", { value: !0 }), Object.keys(n).forEach(function(r) {
-    var o = Object.getOwnPropertyDescriptor(n, r);
-    Object.defineProperty(t, r, o.get ? o : {
-      enumerable: !0,
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
       get: function() {
-        return n[r];
+        return n[k];
       }
     });
-  }), t;
+  });
+  return a;
 }
-var re = { exports: {} }, V = {};
+var jsxRuntime = { exports: {} };
+var reactJsxRuntime_production = {};
 /**
  * @license React
  * react-jsx-runtime.production.js
@@ -36,29 +42,35 @@ var re = { exports: {} }, V = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var fe;
-function je() {
-  if (fe) return V;
-  fe = 1;
-  var n = Symbol.for("react.transitional.element"), e = Symbol.for("react.fragment");
-  function t(r, o, u) {
-    var d = null;
-    if (u !== void 0 && (d = "" + u), o.key !== void 0 && (d = "" + o.key), "key" in o) {
-      u = {};
-      for (var f in o)
-        f !== "key" && (u[f] = o[f]);
-    } else u = o;
-    return o = u.ref, {
-      $$typeof: n,
-      type: r,
-      key: d,
-      ref: o !== void 0 ? o : null,
-      props: u
+var hasRequiredReactJsxRuntime_production;
+function requireReactJsxRuntime_production() {
+  if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  hasRequiredReactJsxRuntime_production = 1;
+  var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config)
+        "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type,
+      key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
     };
   }
-  return V.Fragment = e, V.jsx = t, V.jsxs = t, V;
+  reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_production.jsx = jsxProd;
+  reactJsxRuntime_production.jsxs = jsxProd;
+  return reactJsxRuntime_production;
 }
-var G = {};
+var reactJsxRuntime_development = {};
 /**
  * @license React
  * react-jsx-runtime.development.js
@@ -68,968 +80,1320 @@ var G = {};
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var de;
-function Ne() {
-  return de || (de = 1, process.env.NODE_ENV !== "production" && function() {
-    function n(a) {
-      if (a == null) return null;
-      if (typeof a == "function")
-        return a.$$typeof === s ? null : a.displayName || a.name || null;
-      if (typeof a == "string") return a;
-      switch (a) {
-        case g:
+var hasRequiredReactJsxRuntime_development;
+function requireReactJsxRuntime_development() {
+  if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+  hasRequiredReactJsxRuntime_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type)
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
           return "Fragment";
-        case P:
+        case REACT_PROFILER_TYPE:
           return "Profiler";
-        case C:
+        case REACT_STRICT_MODE_TYPE:
           return "StrictMode";
-        case R:
+        case REACT_SUSPENSE_TYPE:
           return "Suspense";
-        case I:
+        case REACT_SUSPENSE_LIST_TYPE:
           return "SuspenseList";
-        case l:
+        case REACT_ACTIVITY_TYPE:
           return "Activity";
       }
-      if (typeof a == "object")
-        switch (typeof a.tag == "number" && console.error(
+      if ("object" === typeof type)
+        switch ("number" === typeof type.tag && console.error(
           "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
-        ), a.$$typeof) {
-          case h:
+        ), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
             return "Portal";
-          case k:
-            return (a.displayName || "Context") + ".Provider";
-          case v:
-            return (a._context.displayName || "Context") + ".Consumer";
-          case O:
-            var T = a.render;
-            return a = a.displayName, a || (a = T.displayName || T.name || "", a = a !== "" ? "ForwardRef(" + a + ")" : "ForwardRef"), a;
-          case L:
-            return T = a.displayName || null, T !== null ? T : n(a.type) || "Memo";
-          case i:
-            T = a._payload, a = a._init;
+          case REACT_CONTEXT_TYPE:
+            return (type.displayName || "Context") + ".Provider";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
             try {
-              return n(a(T));
-            } catch {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {
             }
         }
       return null;
     }
-    function e(a) {
-      return "" + a;
+    function testStringCoercion(value) {
+      return "" + value;
     }
-    function t(a) {
+    function checkKeyStringCoercion(value) {
       try {
-        e(a);
-        var T = !1;
-      } catch {
-        T = !0;
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
       }
-      if (T) {
-        T = console;
-        var _ = T.error, S = typeof Symbol == "function" && Symbol.toStringTag && a[Symbol.toStringTag] || a.constructor.name || "Object";
-        return _.call(
-          T,
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(
+          JSCompiler_inline_result,
           "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
-          S
-        ), e(a);
+          JSCompiler_inline_result$jscomp$0
+        );
+        return testStringCoercion(value);
       }
     }
-    function r(a) {
-      if (a === g) return "<>";
-      if (typeof a == "object" && a !== null && a.$$typeof === i)
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
         return "<...>";
       try {
-        var T = n(a);
-        return T ? "<" + T + ">" : "<...>";
-      } catch {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
         return "<...>";
       }
     }
-    function o() {
-      var a = c.A;
-      return a === null ? null : a.getOwner();
+    function getOwner() {
+      var dispatcher = ReactSharedInternals.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
     }
-    function u() {
+    function UnknownOwner() {
       return Error("react-stack-top-frame");
     }
-    function d(a) {
-      if (b.call(a, "key")) {
-        var T = Object.getOwnPropertyDescriptor(a, "key").get;
-        if (T && T.isReactWarning) return !1;
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
       }
-      return a.key !== void 0;
+      return void 0 !== config.key;
     }
-    function f(a, T) {
-      function _() {
-        M || (M = !0, console.error(
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
           "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
-          T
+          displayName
         ));
       }
-      _.isReactWarning = !0, Object.defineProperty(a, "key", {
-        get: _,
-        configurable: !0
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
       });
     }
-    function p() {
-      var a = n(this.type);
-      return N[a] || (N[a] = !0, console.error(
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
         "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
-      )), a = this.props.ref, a !== void 0 ? a : null;
+      ));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
     }
-    function y(a, T, _, S, q, $, B, K) {
-      return _ = $.ref, a = {
-        $$typeof: E,
-        type: a,
-        key: T,
-        props: $,
-        _owner: q
-      }, (_ !== void 0 ? _ : null) !== null ? Object.defineProperty(a, "ref", {
-        enumerable: !1,
-        get: p
-      }) : Object.defineProperty(a, "ref", { enumerable: !1, value: null }), a._store = {}, Object.defineProperty(a._store, "validated", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !0,
+    function ReactElement(type, key, self2, source, owner, props, debugStack, debugTask) {
+      self2 = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      null !== (void 0 !== self2 ? self2 : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
         value: 0
-      }), Object.defineProperty(a, "_debugInfo", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !0,
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
         value: null
-      }), Object.defineProperty(a, "_debugStack", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !0,
-        value: B
-      }), Object.defineProperty(a, "_debugTask", {
-        configurable: !1,
-        enumerable: !1,
-        writable: !0,
-        value: K
-      }), Object.freeze && (Object.freeze(a.props), Object.freeze(a)), a;
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
     }
-    function m(a, T, _, S, q, $, B, K) {
-      var j = T.children;
-      if (j !== void 0)
-        if (S)
-          if (D(j)) {
-            for (S = 0; S < j.length; S++)
-              A(j[S]);
-            Object.freeze && Object.freeze(j);
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, source, self2, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
           } else
             console.error(
               "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
             );
-        else A(j);
-      if (b.call(T, "key")) {
-        j = n(a);
-        var Y = Object.keys(T).filter(function(Re) {
-          return Re !== "key";
+        else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return "key" !== k;
         });
-        S = 0 < Y.length ? "{key: someKey, " + Y.join(": ..., ") + ": ...}" : "{key: someKey}", ne[j + S] || (Y = 0 < Y.length ? "{" + Y.join(": ..., ") + ": ...}" : "{}", console.error(
-          `A props object containing a "key" prop is being spread into JSX:
-  let props = %s;
-  <%s {...props} />
-React keys must be passed directly to JSX without using spread:
-  let props = %s;
-  <%s key={someKey} {...props} />`,
-          S,
-          j,
-          Y,
-          j
-        ), ne[j + S] = !0);
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+          isStaticChildren,
+          children,
+          keys,
+          children
+        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
       }
-      if (j = null, _ !== void 0 && (t(_), j = "" + _), d(T) && (t(T.key), j = "" + T.key), "key" in T) {
-        _ = {};
-        for (var le in T)
-          le !== "key" && (_[le] = T[le]);
-      } else _ = T;
-      return j && f(
-        _,
-        typeof a == "function" ? a.displayName || a.name || "Unknown" : a
-      ), y(
-        a,
-        j,
-        $,
-        q,
-        o(),
-        _,
-        B,
-        K
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(
+        maybeKey,
+        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+      );
+      return ReactElement(
+        type,
+        children,
+        self2,
+        source,
+        getOwner(),
+        maybeKey,
+        debugStack,
+        debugTask
       );
     }
-    function A(a) {
-      typeof a == "object" && a !== null && a.$$typeof === E && a._store && (a._store.validated = 1);
+    function validateChildKeys(node) {
+      "object" === typeof node && null !== node && node.$$typeof === REACT_ELEMENT_TYPE && node._store && (node._store.validated = 1);
     }
-    var w = Ae, E = Symbol.for("react.transitional.element"), h = Symbol.for("react.portal"), g = Symbol.for("react.fragment"), C = Symbol.for("react.strict_mode"), P = Symbol.for("react.profiler"), v = Symbol.for("react.consumer"), k = Symbol.for("react.context"), O = Symbol.for("react.forward_ref"), R = Symbol.for("react.suspense"), I = Symbol.for("react.suspense_list"), L = Symbol.for("react.memo"), i = Symbol.for("react.lazy"), l = Symbol.for("react.activity"), s = Symbol.for("react.client.reference"), c = w.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, b = Object.prototype.hasOwnProperty, D = Array.isArray, x = console.createTask ? console.createTask : function() {
+    var React = require$$0$1, REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler");
+    var REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
       return null;
     };
-    w = {
-      react_stack_bottom_frame: function(a) {
-        return a();
+    React = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
       }
     };
-    var M, N = {}, H = w.react_stack_bottom_frame.bind(
-      w,
-      u
-    )(), J = x(r(u)), ne = {};
-    G.Fragment = g, G.jsx = function(a, T, _, S, q) {
-      var $ = 1e4 > c.recentlyCreatedOwnerStacks++;
-      return m(
-        a,
-        T,
-        _,
-        !1,
-        S,
-        q,
-        $ ? Error("react-stack-top-frame") : H,
-        $ ? x(r(a)) : J
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+      React,
+      UnknownOwner
+    )();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_development.jsx = function(type, config, maybeKey, source, self2) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        false,
+        source,
+        self2,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
       );
-    }, G.jsxs = function(a, T, _, S, q) {
-      var $ = 1e4 > c.recentlyCreatedOwnerStacks++;
-      return m(
-        a,
-        T,
-        _,
-        !0,
-        S,
-        q,
-        $ ? Error("react-stack-top-frame") : H,
-        $ ? x(r(a)) : J
+    };
+    reactJsxRuntime_development.jsxs = function(type, config, maybeKey, source, self2) {
+      var trackActualOwner = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        true,
+        source,
+        self2,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
       );
     };
-  }()), G;
+  }();
+  return reactJsxRuntime_development;
 }
-var pe;
-function Ie() {
-  return pe || (pe = 1, process.env.NODE_ENV === "production" ? re.exports = je() : re.exports = Ne()), re.exports;
+var hasRequiredJsxRuntime;
+function requireJsxRuntime() {
+  if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+  hasRequiredJsxRuntime = 1;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime.exports = requireReactJsxRuntime_production();
+  } else {
+    jsxRuntime.exports = requireReactJsxRuntime_development();
+  }
+  return jsxRuntime.exports;
 }
-var F = Ie();
-const se = Ee(null), Fe = "https://api.kelet.ai/api", pt = () => {
-  const n = ae(se);
-  if (!n)
+var jsxRuntimeExports = requireJsxRuntime();
+const KeletContext = createContext(null);
+const KeletBaseUrl = "https://api.kelet.ai/api";
+const useKelet = () => {
+  const context = useContext(KeletContext);
+  if (!context) {
     throw new Error("useKelet must be used within a KeletProvider");
-  return n;
-}, ke = () => {
-  const n = ae(se);
-  return n ? n.feedback : async () => {
-  };
-}, ht = ({ apiKey: n, project: e, children: t }) => {
-  const r = ae(se), o = n || r?.api_key;
-  if (!o)
+  }
+  return context;
+};
+const useDefaultFeedbackHandler = () => {
+  const context = useContext(KeletContext);
+  if (!context) {
+    return async () => {
+    };
+  } else {
+    return context.feedback;
+  }
+};
+const KeletProvider = ({ apiKey, project, children }) => {
+  const parentContext = useContext(KeletContext);
+  const resolvedApiKey = apiKey || parentContext?.api_key;
+  if (!resolvedApiKey) {
     throw new Error(
       "apiKey is required either directly or from a parent KeletProvider"
     );
-  const d = {
-    api_key: o,
-    project: e,
-    feedback: async (f) => {
-      const p = `${Fe}/projects/${e}/feedback`, y = {
-        tx_id: f.tx_id,
-        source: f.source || "EXPLICIT",
-        vote: f.vote,
-        explanation: f.explanation,
-        correction: f.correction,
-        selection: f.selection
-        // Include trigger_name if needed in the future
-      }, m = await fetch(p, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${o}`
-        },
-        body: JSON.stringify(y)
-      });
-      if (!m.ok)
-        throw new Error(`Failed to submit feedback: ${m.statusText}`);
+  }
+  const feedback = async (data) => {
+    const url = `${KeletBaseUrl}/projects/${project}/feedback`;
+    const req = {
+      tx_id: data.tx_id,
+      source: data.source || "EXPLICIT",
+      vote: data.vote,
+      explanation: data.explanation,
+      correction: data.correction,
+      selection: data.selection
+      // Include trigger_name if needed in the future
+    };
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${resolvedApiKey}`
+      },
+      body: JSON.stringify(req)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to submit feedback: ${response.statusText}`);
     }
   };
-  return /* @__PURE__ */ F.jsx(se.Provider, { value: d, children: t });
-}, ee = (n, e) => {
-  const t = { ...e };
-  for (const r in e) {
-    const o = n[r], u = e[r];
-    /^on[A-Z]/.test(r) ? o && u ? t[r] = (...f) => {
-      u(...f), o(...f);
-    } : o && (t[r] = o) : r === "style" ? t[r] = { ...o, ...u } : r === "className" ? t[r] = [o, u].filter(Boolean).join(" ") : t[r] = u !== void 0 ? u : o;
+  const value = {
+    api_key: resolvedApiKey,
+    project,
+    feedback
+  };
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(KeletContext.Provider, { value, children });
+};
+const mergeProps = (slotProps, childProps) => {
+  const overrideProps = { ...childProps };
+  for (const propName in childProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          childPropValue(...args);
+          slotPropValue(...args);
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    } else {
+      overrideProps[propName] = childPropValue !== void 0 ? childPropValue : slotPropValue;
+    }
   }
-  return { ...n, ...t };
-}, Pe = Ee(
+  return { ...slotProps, ...overrideProps };
+};
+const VoteFeedbackContext = createContext(
   null
-), te = () => {
-  const n = ae(Pe);
-  if (!n)
+);
+const useVoteFeedbackContext = () => {
+  const context = useContext(VoteFeedbackContext);
+  if (!context) {
     throw new Error(
       "VoteFeedback components must be used within VoteFeedback.Root"
     );
-  return n;
-}, Le = ({
-  children: n,
-  onFeedback: e,
-  defaultText: t = "",
-  tx_id: r,
-  extra_metadata: o,
-  trigger_name: u
+  }
+  return context;
+};
+const VoteFeedbackRoot = ({
+  children,
+  onFeedback,
+  defaultText = "",
+  tx_id: txIdProp,
+  extra_metadata,
+  trigger_name
 }) => {
-  const d = typeof r == "function" ? r() : r, [f, p] = X(!1), [y, m] = X(t), [A, w] = X(!1), [E, h] = X(null), g = U(null), C = U(null), P = ce(), v = ce(), k = ke(), O = e || k, R = W(async () => {
-    h("upvote");
-    const c = {
-      tx_id: d,
+  const tx_id = typeof txIdProp === "function" ? txIdProp() : txIdProp;
+  const [showPopover, setShowPopover] = useState(false);
+  const [feedbackText, setFeedbackText] = useState(defaultText);
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [vote, setVote] = useState(null);
+  const textareaRef = useRef(null);
+  const triggerRef = useRef(null);
+  const popoverId = useId();
+  const triggerId = useId();
+  const defaultHandler = useDefaultFeedbackHandler();
+  const handler = onFeedback || defaultHandler;
+  useEffect(() => {
+    setShowPopover(false);
+    setFeedbackText(defaultText);
+    setIsSubmitting(false);
+    setVote(null);
+    setTimeout(() => triggerRef.current?.focus(), 0);
+  }, [tx_id, defaultText]);
+  const handleUpvote = useCallback(async () => {
+    setVote("upvote");
+    const data = {
+      tx_id,
       vote: "upvote",
-      ...o && { extra_metadata: o },
-      ...u && { trigger_name: u }
+      ...extra_metadata && { extra_metadata },
+      ...trigger_name && { trigger_name }
     };
     try {
-      w(!0), await O(c);
+      setIsSubmitting(true);
+      await handler(data);
     } finally {
-      w(!1);
+      setIsSubmitting(false);
     }
-  }, [O, d, o, u]), I = W(async () => {
-    if (h("downvote"), O) {
-      const c = {
-        tx_id: d,
+  }, [handler, tx_id, extra_metadata, trigger_name]);
+  const handleDownvote = useCallback(async () => {
+    setVote("downvote");
+    if (handler) {
+      const data = {
+        tx_id,
         vote: "downvote",
-        ...o && { extra_metadata: o },
-        ...u && { trigger_name: u }
+        ...extra_metadata && { extra_metadata },
+        ...trigger_name && { trigger_name }
       };
       try {
-        w(!0), await O(c);
+        setIsSubmitting(true);
+        await handler(data);
       } finally {
-        w(!1);
+        setIsSubmitting(false);
       }
     }
-    p(!0), setTimeout(() => {
-      g.current?.focus();
-      const c = document.createElement("div");
-      c.setAttribute("aria-live", "polite"), c.setAttribute("aria-atomic", "true"), c.className = "sr-only", c.textContent = "Feedback dialog opened. You can provide additional details about your downvote.", document.body.appendChild(c), setTimeout(() => document.body.removeChild(c), 1e3);
+    setShowPopover(true);
+    setTimeout(() => {
+      textareaRef.current?.focus();
+      const announcement = document.createElement("div");
+      announcement.setAttribute("aria-live", "polite");
+      announcement.setAttribute("aria-atomic", "true");
+      announcement.className = "sr-only";
+      announcement.textContent = "Feedback dialog opened. You can provide additional details about your downvote.";
+      document.body.appendChild(announcement);
+      setTimeout(() => document.body.removeChild(announcement), 1e3);
     }, 0);
-  }, [O, d, o, u]), L = W(
-    (c) => {
-      m(c.target.value);
+  }, [handler, tx_id, extra_metadata, trigger_name]);
+  const handleTextareaChange = useCallback(
+    (e) => {
+      setFeedbackText(e.target.value);
     },
     []
-  ), i = W(async () => {
-    const c = y.trim().length > 0;
-    if (c) {
-      const b = {
-        tx_id: d,
+  );
+  const handleSubmit = useCallback(async () => {
+    const hasText = feedbackText.trim().length > 0;
+    if (hasText) {
+      const data = {
+        tx_id,
         vote: "downvote",
-        explanation: y,
-        ...o && { extra_metadata: o },
-        ...u && { trigger_name: u }
+        explanation: feedbackText,
+        ...extra_metadata && { extra_metadata },
+        ...trigger_name && { trigger_name }
       };
       try {
-        w(!0), await O(b);
+        setIsSubmitting(true);
+        await handler(data);
       } finally {
-        w(!1);
+        setIsSubmitting(false);
       }
     }
-    if (p(!1), m(t), C.current?.focus(), c) {
-      const b = document.createElement("div");
-      b.setAttribute("aria-live", "polite"), b.className = "sr-only", b.textContent = "Feedback submitted successfully.", document.body.appendChild(b), setTimeout(() => document.body.removeChild(b), 1e3);
+    setShowPopover(false);
+    setFeedbackText(defaultText);
+    triggerRef.current?.focus();
+    if (hasText) {
+      const announcement = document.createElement("div");
+      announcement.setAttribute("aria-live", "polite");
+      announcement.className = "sr-only";
+      announcement.textContent = "Feedback submitted successfully.";
+      document.body.appendChild(announcement);
+      setTimeout(() => document.body.removeChild(announcement), 1e3);
     }
-  }, [O, y, t, d, o, u]), l = W(
-    (c) => {
-      if (c.key === "Escape")
-        p(!1), m(t), C.current?.focus();
-      else if ((c.metaKey || c.ctrlKey) && c.key === "Enter")
-        c.preventDefault(), i().then((b) => {
+  }, [handler, feedbackText, defaultText, tx_id, extra_metadata, trigger_name]);
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (e.key === "Escape") {
+        setShowPopover(false);
+        setFeedbackText(defaultText);
+        triggerRef.current?.focus();
+      } else if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+        e.preventDefault();
+        handleSubmit().then((_) => {
         });
-      else if (c.key === "Tab" && f) {
-        const b = document.getElementById(P);
-        if (b) {
-          const D = b.querySelectorAll(
+      } else if (e.key === "Tab" && showPopover) {
+        const popoverElement = document.getElementById(popoverId);
+        if (popoverElement) {
+          const focusableElements = popoverElement.querySelectorAll(
             'button, textarea, input, select, a[href], [tabindex]:not([tabindex="-1"])'
-          ), x = D[0], M = D[D.length - 1];
-          c.shiftKey && document.activeElement === x ? (c.preventDefault(), M?.focus()) : !c.shiftKey && document.activeElement === M && (c.preventDefault(), x?.focus());
+          );
+          const firstElement = focusableElements[0];
+          const lastElement = focusableElements[focusableElements.length - 1];
+          if (e.shiftKey && document.activeElement === firstElement) {
+            e.preventDefault();
+            lastElement?.focus();
+          } else if (!e.shiftKey && document.activeElement === lastElement) {
+            e.preventDefault();
+            firstElement?.focus();
+          }
         }
       }
     },
-    [i, f, P, t]
-  ), s = {
-    onFeedback: O,
-    showPopover: f,
-    setShowPopover: p,
-    feedbackText: y,
-    setFeedbackText: m,
-    isSubmitting: A,
-    setIsSubmitting: w,
-    vote: E,
-    handleUpvote: R,
-    handleDownvote: I,
-    handleTextareaChange: L,
-    handleSubmit: i,
-    handleKeyDown: l,
-    textareaRef: g,
-    triggerRef: C,
-    popoverId: P,
-    triggerId: v,
-    tx_id: d,
-    extra_metadata: o,
-    trigger_name: u
+    [handleSubmit, showPopover, popoverId, defaultText]
+  );
+  const contextValue = {
+    onFeedback: handler,
+    showPopover,
+    setShowPopover,
+    feedbackText,
+    setFeedbackText,
+    isSubmitting,
+    setIsSubmitting,
+    vote,
+    handleUpvote,
+    handleDownvote,
+    handleTextareaChange,
+    handleSubmit,
+    handleKeyDown,
+    textareaRef,
+    triggerRef,
+    popoverId,
+    triggerId,
+    tx_id,
+    extra_metadata,
+    trigger_name
   };
-  return /* @__PURE__ */ F.jsx(Pe.Provider, { value: s, children: n });
-}, Me = ({
-  asChild: n,
-  children: e,
-  onClick: t,
-  ...r
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(VoteFeedbackContext.Provider, { value: contextValue, children });
+};
+const UpvoteButton = ({
+  asChild,
+  children,
+  onClick,
+  ...props
 }) => {
-  const { handleUpvote: o, isSubmitting: u, vote: d } = te(), f = W(
-    (m) => {
-      o(), t?.(m);
+  const { handleUpvote, isSubmitting, vote } = useVoteFeedbackContext();
+  const handleClick = useCallback(
+    (e) => {
+      handleUpvote();
+      onClick?.(e);
     },
-    [o, t]
-  ), p = {
-    ...r,
-    onClick: f,
-    disabled: u || r.disabled,
-    "aria-label": r["aria-label"] || "Upvote feedback",
+    [handleUpvote, onClick]
+  );
+  const slotProps = {
+    ...props,
+    onClick: handleClick,
+    disabled: isSubmitting || props.disabled,
+    "aria-label": props["aria-label"] || "Upvote feedback",
     type: "button"
-  }, y = d === "upvote";
-  if (n) {
-    const m = typeof e == "function" ? e({ isSelected: y }) : e;
-    if (Z(m))
-      return Q(
-        m,
-        ee(p, m.props)
+  };
+  const isSelected = vote === "upvote";
+  if (asChild) {
+    const child = typeof children === "function" ? children({ isSelected }) : children;
+    if (isValidElement(child)) {
+      return cloneElement(
+        child,
+        mergeProps(slotProps, child.props)
       );
+    }
   }
-  return /* @__PURE__ */ F.jsx("button", { ...p, children: typeof e == "function" ? e({ isSelected: y }) : e });
-}, $e = ({
-  asChild: n,
-  children: e,
-  onClick: t,
-  ...r
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("button", { ...slotProps, children: typeof children === "function" ? children({ isSelected }) : children });
+};
+const DownvoteButton = ({
+  asChild,
+  children,
+  onClick,
+  ...props
 }) => {
   const {
-    handleDownvote: o,
-    showPopover: u,
-    isSubmitting: d,
-    popoverId: f,
-    triggerId: p,
-    triggerRef: y,
-    vote: m
-  } = te(), A = W(
-    (h) => {
-      o(), t?.(h);
+    handleDownvote,
+    showPopover,
+    isSubmitting,
+    popoverId,
+    triggerId,
+    triggerRef,
+    vote
+  } = useVoteFeedbackContext();
+  const handleClick = useCallback(
+    (e) => {
+      handleDownvote();
+      onClick?.(e);
     },
-    [o, t]
-  ), w = {
-    ...r,
-    ref: y,
-    onClick: A,
-    disabled: d || r.disabled,
-    "aria-label": r["aria-label"] || "Downvote feedback",
-    "aria-expanded": u,
-    "aria-controls": f,
-    id: p,
+    [handleDownvote, onClick]
+  );
+  const slotProps = {
+    ...props,
+    ref: triggerRef,
+    onClick: handleClick,
+    disabled: isSubmitting || props.disabled,
+    "aria-label": props["aria-label"] || "Downvote feedback",
+    "aria-expanded": showPopover,
+    "aria-controls": popoverId,
+    id: triggerId,
     type: "button"
-  }, E = m === "downvote";
-  if (n) {
-    const h = typeof e == "function" ? e({ isSelected: E }) : e;
-    if (Z(h))
-      return Q(h, ee(w, h.props));
-    if (h)
-      return h;
+  };
+  const isSelected = vote === "downvote";
+  if (asChild) {
+    const child = typeof children === "function" ? children({ isSelected }) : children;
+    if (isValidElement(child)) {
+      return cloneElement(child, mergeProps(slotProps, child.props));
+    } else if (child) {
+      return child;
+    }
   }
-  return /* @__PURE__ */ F.jsx("button", { ...w, children: typeof e == "function" ? e({ isSelected: E }) : e });
-}, qe = ({ asChild: n, children: e, ...t }) => {
-  const { showPopover: r, handleKeyDown: o, popoverId: u, triggerId: d } = te();
-  if (!r)
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("button", { ...slotProps, children: typeof children === "function" ? children({ isSelected }) : children });
+};
+const Popover = ({ asChild, children, ...props }) => {
+  const { showPopover, handleKeyDown, popoverId, triggerId } = useVoteFeedbackContext();
+  if (!showPopover) {
     return null;
-  const f = {
-    ...t,
+  }
+  const slotProps = {
+    ...props,
     role: "dialog",
-    "aria-labelledby": d,
-    "aria-modal": !0,
-    "aria-describedby": `${u}-description`,
-    id: u,
-    onKeyDown: o,
+    "aria-labelledby": triggerId,
+    "aria-modal": true,
+    "aria-describedby": `${popoverId}-description`,
+    id: popoverId,
+    onKeyDown: handleKeyDown,
     tabIndex: -1
   };
-  return n && Z(e) ? /* @__PURE__ */ F.jsxs(F.Fragment, { children: [
-    Q(
-      e,
-      ee(f, e.props)
-    ),
-    /* @__PURE__ */ F.jsx("div", { id: `${u}-description`, className: "sr-only", children: "Provide additional feedback for your downvote" })
-  ] }) : /* @__PURE__ */ F.jsxs("div", { ...f, children: [
-    /* @__PURE__ */ F.jsx("div", { id: `${u}-description`, className: "sr-only", children: "Provide additional feedback for your downvote" }),
-    e
+  if (asChild && isValidElement(children)) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      cloneElement(
+        children,
+        mergeProps(slotProps, children.props)
+      ),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: `${popoverId}-description`, className: "sr-only", children: "Provide additional feedback for your downvote" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ...slotProps, children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { id: `${popoverId}-description`, className: "sr-only", children: "Provide additional feedback for your downvote" }),
+    children
   ] });
-}, We = ({ asChild: n, value: e, onChange: t, ...r }) => {
+};
+const Textarea = ({ asChild, value, onChange, ...props }) => {
   const {
-    feedbackText: o,
-    handleTextareaChange: u,
-    textareaRef: d,
-    handleKeyDown: f,
-    popoverId: p
-  } = te(), y = {
-    ...r,
-    ref: d,
-    value: e !== void 0 ? e : o,
-    onChange: t || u,
-    onKeyDown: f,
-    placeholder: r.placeholder || "What did we miss?",
-    "aria-label": r["aria-label"] || "Additional feedback",
-    "aria-describedby": `${p}-help`,
-    rows: r.rows || 3
+    feedbackText,
+    handleTextareaChange,
+    textareaRef,
+    handleKeyDown,
+    popoverId
+  } = useVoteFeedbackContext();
+  const slotProps = {
+    ...props,
+    ref: textareaRef,
+    value: value !== void 0 ? value : feedbackText,
+    onChange: onChange || handleTextareaChange,
+    onKeyDown: handleKeyDown,
+    placeholder: props.placeholder || "What did we miss?",
+    "aria-label": props["aria-label"] || "Additional feedback",
+    "aria-describedby": `${popoverId}-help`,
+    rows: props.rows || 3
   };
-  return n && Z(r.children) ? Q(
-    r.children,
-    ee(y, r.children.props)
-  ) : /* @__PURE__ */ F.jsx("textarea", { ...y });
-}, Ye = ({
-  asChild: n,
-  children: e,
-  onClick: t,
-  ...r
+  if (asChild && isValidElement(props.children)) {
+    return cloneElement(
+      props.children,
+      mergeProps(slotProps, props.children.props)
+    );
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("textarea", { ...slotProps });
+};
+const SubmitButton = ({
+  asChild,
+  children,
+  onClick,
+  ...props
 }) => {
-  const { handleSubmit: o, isSubmitting: u, feedbackText: d } = te(), f = W(
-    (A) => {
-      o(), t?.(A);
+  const { handleSubmit, isSubmitting, feedbackText } = useVoteFeedbackContext();
+  const handleClick = useCallback(
+    (e) => {
+      handleSubmit();
+      onClick?.(e);
     },
-    [o, t]
-  ), p = d.trim().length > 0, y = p ? "Submit feedback" : "Close without feedback", m = {
-    ...r,
-    onClick: f,
-    disabled: u || r.disabled,
+    [handleSubmit, onClick]
+  );
+  const hasText = feedbackText.trim().length > 0;
+  const buttonText = hasText ? "Submit feedback" : "Close without feedback";
+  const slotProps = {
+    ...props,
+    onClick: handleClick,
+    disabled: isSubmitting || props.disabled,
     type: "button",
-    "aria-label": r["aria-label"] || y,
-    "aria-describedby": p ? void 0 : "submit-help"
+    "aria-label": props["aria-label"] || buttonText,
+    "aria-describedby": hasText ? void 0 : "submit-help"
   };
-  return n && Z(e) ? /* @__PURE__ */ F.jsxs(F.Fragment, { children: [
-    Q(
-      e,
-      ee(m, e.props)
-    ),
-    !p && /* @__PURE__ */ F.jsx("span", { id: "submit-help", className: "sr-only", children: "This will close the dialog without submitting feedback" })
-  ] }) : /* @__PURE__ */ F.jsxs("button", { ...m, children: [
-    e,
-    !p && /* @__PURE__ */ F.jsx("span", { id: "submit-help", className: "sr-only", children: "This will close the dialog without submitting feedback" })
+  if (asChild && isValidElement(children)) {
+    return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      cloneElement(
+        children,
+        mergeProps(slotProps, children.props)
+      ),
+      !hasText && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { id: "submit-help", className: "sr-only", children: "This will close the dialog without submitting feedback" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { ...slotProps, children: [
+    children,
+    !hasText && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { id: "submit-help", className: "sr-only", children: "This will close the dialog without submitting feedback" })
   ] });
-}, mt = {
-  Root: Le,
-  UpvoteButton: Me,
-  DownvoteButton: $e,
-  Popover: qe,
-  Textarea: We,
-  SubmitButton: Ye
 };
-var ie = { exports: {} }, ze = ie.exports, he;
-function Ke() {
-  return he || (he = 1, function(n, e) {
-    (function(t, r) {
-      var o = r(t);
-      n.exports = o;
-    })(ze, function(t) {
-      var r = ["N", "E", "A", "D"];
-      function o(i, l) {
-        i.super_ = l, i.prototype = Object.create(l.prototype, {
+const VoteFeedback = {
+  Root: VoteFeedbackRoot,
+  UpvoteButton,
+  DownvoteButton,
+  Popover,
+  Textarea,
+  SubmitButton
+};
+var deepDiff$1 = { exports: {} };
+var deepDiff = deepDiff$1.exports;
+var hasRequiredDeepDiff;
+function requireDeepDiff() {
+  if (hasRequiredDeepDiff) return deepDiff$1.exports;
+  hasRequiredDeepDiff = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      var deepDiff2 = factory(root);
+      {
+        module.exports = deepDiff2;
+      }
+    })(deepDiff, function(root) {
+      var validKinds = ["N", "E", "A", "D"];
+      function inherits(ctor, superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
           constructor: {
-            value: i,
-            enumerable: !1,
-            writable: !0,
-            configurable: !0
+            value: ctor,
+            enumerable: false,
+            writable: true,
+            configurable: true
           }
         });
       }
-      function u(i, l) {
+      function Diff2(kind, path) {
         Object.defineProperty(this, "kind", {
-          value: i,
-          enumerable: !0
-        }), l && l.length && Object.defineProperty(this, "path", {
-          value: l,
-          enumerable: !0
+          value: kind,
+          enumerable: true
         });
+        if (path && path.length) {
+          Object.defineProperty(this, "path", {
+            value: path,
+            enumerable: true
+          });
+        }
       }
-      function d(i, l, s) {
-        d.super_.call(this, "E", i), Object.defineProperty(this, "lhs", {
-          value: l,
-          enumerable: !0
-        }), Object.defineProperty(this, "rhs", {
-          value: s,
-          enumerable: !0
+      function DiffEdit(path, origin, value) {
+        DiffEdit.super_.call(this, "E", path);
+        Object.defineProperty(this, "lhs", {
+          value: origin,
+          enumerable: true
+        });
+        Object.defineProperty(this, "rhs", {
+          value,
+          enumerable: true
         });
       }
-      o(d, u);
-      function f(i, l) {
-        f.super_.call(this, "N", i), Object.defineProperty(this, "rhs", {
-          value: l,
-          enumerable: !0
+      inherits(DiffEdit, Diff2);
+      function DiffNew(path, value) {
+        DiffNew.super_.call(this, "N", path);
+        Object.defineProperty(this, "rhs", {
+          value,
+          enumerable: true
         });
       }
-      o(f, u);
-      function p(i, l) {
-        p.super_.call(this, "D", i), Object.defineProperty(this, "lhs", {
-          value: l,
-          enumerable: !0
+      inherits(DiffNew, Diff2);
+      function DiffDeleted(path, value) {
+        DiffDeleted.super_.call(this, "D", path);
+        Object.defineProperty(this, "lhs", {
+          value,
+          enumerable: true
         });
       }
-      o(p, u);
-      function y(i, l, s) {
-        y.super_.call(this, "A", i), Object.defineProperty(this, "index", {
-          value: l,
-          enumerable: !0
-        }), Object.defineProperty(this, "item", {
-          value: s,
-          enumerable: !0
+      inherits(DiffDeleted, Diff2);
+      function DiffArray(path, index, item) {
+        DiffArray.super_.call(this, "A", path);
+        Object.defineProperty(this, "index", {
+          value: index,
+          enumerable: true
+        });
+        Object.defineProperty(this, "item", {
+          value: item,
+          enumerable: true
         });
       }
-      o(y, u);
-      function m(i, l, s) {
-        var c = i.slice(l + 1 || i.length);
-        return i.length = l < 0 ? i.length + l : l, i.push.apply(i, c), i;
+      inherits(DiffArray, Diff2);
+      function arrayRemove(arr, from, to) {
+        var rest = arr.slice(from + 1 || arr.length);
+        arr.length = from < 0 ? arr.length + from : from;
+        arr.push.apply(arr, rest);
+        return arr;
       }
-      function A(i) {
-        var l = typeof i;
-        return l !== "object" ? l : i === Math ? "math" : i === null ? "null" : Array.isArray(i) ? "array" : Object.prototype.toString.call(i) === "[object Date]" ? "date" : typeof i.toString == "function" && /^\/.*\//.test(i.toString()) ? "regexp" : "object";
+      function realTypeOf(subject) {
+        var type = typeof subject;
+        if (type !== "object") {
+          return type;
+        }
+        if (subject === Math) {
+          return "math";
+        } else if (subject === null) {
+          return "null";
+        } else if (Array.isArray(subject)) {
+          return "array";
+        } else if (Object.prototype.toString.call(subject) === "[object Date]") {
+          return "date";
+        } else if (typeof subject.toString === "function" && /^\/.*\//.test(subject.toString())) {
+          return "regexp";
+        }
+        return "object";
       }
-      function w(i) {
-        var l = 0;
-        if (i.length === 0)
-          return l;
-        for (var s = 0; s < i.length; s++) {
-          var c = i.charCodeAt(s);
-          l = (l << 5) - l + c, l = l & l;
+      function hashThisString(string) {
+        var hash = 0;
+        if (string.length === 0) {
+          return hash;
         }
-        return l;
+        for (var i = 0; i < string.length; i++) {
+          var char = string.charCodeAt(i);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return hash;
       }
-      function E(i) {
-        var l = 0, s = A(i);
-        if (s === "array") {
-          i.forEach(function(M) {
-            l += E(M);
+      function getOrderIndependentHash(object) {
+        var accum = 0;
+        var type = realTypeOf(object);
+        if (type === "array") {
+          object.forEach(function(item) {
+            accum += getOrderIndependentHash(item);
           });
-          var c = "[type: array, hash: " + l + "]";
-          return l + w(c);
+          var arrayString = "[type: array, hash: " + accum + "]";
+          return accum + hashThisString(arrayString);
         }
-        if (s === "object") {
-          for (var b in i)
-            if (i.hasOwnProperty(b)) {
-              var D = "[ type: object, key: " + b + ", value hash: " + E(i[b]) + "]";
-              l += w(D);
+        if (type === "object") {
+          for (var key in object) {
+            if (object.hasOwnProperty(key)) {
+              var keyValueString = "[ type: object, key: " + key + ", value hash: " + getOrderIndependentHash(object[key]) + "]";
+              accum += hashThisString(keyValueString);
             }
-          return l;
+          }
+          return accum;
         }
-        var x = "[ type: " + s + " ; value: " + i + "]";
-        return l + w(x);
+        var stringToHash = "[ type: " + type + " ; value: " + object + "]";
+        return accum + hashThisString(stringToHash);
       }
-      function h(i, l, s, c, b, D, x, M) {
-        s = s || [], b = b || [], x = x || [];
-        var N = b.slice(0);
-        if (typeof D < "u" && D !== null) {
-          if (c) {
-            if (typeof c == "function" && c(N, D))
+      function deepDiff2(lhs, rhs, changes, prefilter, path, key, stack, orderIndependent) {
+        changes = changes || [];
+        path = path || [];
+        stack = stack || [];
+        var currentPath = path.slice(0);
+        if (typeof key !== "undefined" && key !== null) {
+          if (prefilter) {
+            if (typeof prefilter === "function" && prefilter(currentPath, key)) {
               return;
-            if (typeof c == "object") {
-              if (c.prefilter && c.prefilter(N, D))
+            } else if (typeof prefilter === "object") {
+              if (prefilter.prefilter && prefilter.prefilter(currentPath, key)) {
                 return;
-              if (c.normalize) {
-                var H = c.normalize(N, D, i, l);
-                H && (i = H[0], l = H[1]);
+              }
+              if (prefilter.normalize) {
+                var alt = prefilter.normalize(currentPath, key, lhs, rhs);
+                if (alt) {
+                  lhs = alt[0];
+                  rhs = alt[1];
+                }
               }
             }
           }
-          N.push(D);
+          currentPath.push(key);
         }
-        A(i) === "regexp" && A(l) === "regexp" && (i = i.toString(), l = l.toString());
-        var J = typeof i, ne = typeof l, a, T, _, S, q = J !== "undefined" || x && x.length > 0 && x[x.length - 1].lhs && Object.getOwnPropertyDescriptor(x[x.length - 1].lhs, D), $ = ne !== "undefined" || x && x.length > 0 && x[x.length - 1].rhs && Object.getOwnPropertyDescriptor(x[x.length - 1].rhs, D);
-        if (!q && $)
-          s.push(new f(N, l));
-        else if (!$ && q)
-          s.push(new p(N, i));
-        else if (A(i) !== A(l))
-          s.push(new d(N, i, l));
-        else if (A(i) === "date" && i - l !== 0)
-          s.push(new d(N, i, l));
-        else if (J === "object" && i !== null && l !== null) {
-          for (a = x.length - 1; a > -1; --a)
-            if (x[a].lhs === i) {
-              S = !0;
+        if (realTypeOf(lhs) === "regexp" && realTypeOf(rhs) === "regexp") {
+          lhs = lhs.toString();
+          rhs = rhs.toString();
+        }
+        var ltype = typeof lhs;
+        var rtype = typeof rhs;
+        var i, j, k, other;
+        var ldefined = ltype !== "undefined" || stack && stack.length > 0 && stack[stack.length - 1].lhs && Object.getOwnPropertyDescriptor(stack[stack.length - 1].lhs, key);
+        var rdefined = rtype !== "undefined" || stack && stack.length > 0 && stack[stack.length - 1].rhs && Object.getOwnPropertyDescriptor(stack[stack.length - 1].rhs, key);
+        if (!ldefined && rdefined) {
+          changes.push(new DiffNew(currentPath, rhs));
+        } else if (!rdefined && ldefined) {
+          changes.push(new DiffDeleted(currentPath, lhs));
+        } else if (realTypeOf(lhs) !== realTypeOf(rhs)) {
+          changes.push(new DiffEdit(currentPath, lhs, rhs));
+        } else if (realTypeOf(lhs) === "date" && lhs - rhs !== 0) {
+          changes.push(new DiffEdit(currentPath, lhs, rhs));
+        } else if (ltype === "object" && lhs !== null && rhs !== null) {
+          for (i = stack.length - 1; i > -1; --i) {
+            if (stack[i].lhs === lhs) {
+              other = true;
               break;
             }
-          if (S)
-            i !== l && s.push(new d(N, i, l));
-          else {
-            if (x.push({ lhs: i, rhs: l }), Array.isArray(i)) {
-              for (M && (i.sort(function(j, Y) {
-                return E(j) - E(Y);
-              }), l.sort(function(j, Y) {
-                return E(j) - E(Y);
-              })), a = l.length - 1, T = i.length - 1; a > T; )
-                s.push(new y(N, a, new f(void 0, l[a--])));
-              for (; T > a; )
-                s.push(new y(N, T, new p(void 0, i[T--])));
-              for (; a >= 0; --a)
-                h(i[a], l[a], s, c, N, a, x, M);
+          }
+          if (!other) {
+            stack.push({ lhs, rhs });
+            if (Array.isArray(lhs)) {
+              if (orderIndependent) {
+                lhs.sort(function(a, b) {
+                  return getOrderIndependentHash(a) - getOrderIndependentHash(b);
+                });
+                rhs.sort(function(a, b) {
+                  return getOrderIndependentHash(a) - getOrderIndependentHash(b);
+                });
+              }
+              i = rhs.length - 1;
+              j = lhs.length - 1;
+              while (i > j) {
+                changes.push(new DiffArray(currentPath, i, new DiffNew(void 0, rhs[i--])));
+              }
+              while (j > i) {
+                changes.push(new DiffArray(currentPath, j, new DiffDeleted(void 0, lhs[j--])));
+              }
+              for (; i >= 0; --i) {
+                deepDiff2(lhs[i], rhs[i], changes, prefilter, currentPath, i, stack, orderIndependent);
+              }
             } else {
-              var B = Object.keys(i), K = Object.keys(l);
-              for (a = 0; a < B.length; ++a)
-                _ = B[a], S = K.indexOf(_), S >= 0 ? (h(i[_], l[_], s, c, N, _, x, M), K[S] = null) : h(i[_], void 0, s, c, N, _, x, M);
-              for (a = 0; a < K.length; ++a)
-                _ = K[a], _ && h(void 0, l[_], s, c, N, _, x, M);
+              var akeys = Object.keys(lhs);
+              var pkeys = Object.keys(rhs);
+              for (i = 0; i < akeys.length; ++i) {
+                k = akeys[i];
+                other = pkeys.indexOf(k);
+                if (other >= 0) {
+                  deepDiff2(lhs[k], rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
+                  pkeys[other] = null;
+                } else {
+                  deepDiff2(lhs[k], void 0, changes, prefilter, currentPath, k, stack, orderIndependent);
+                }
+              }
+              for (i = 0; i < pkeys.length; ++i) {
+                k = pkeys[i];
+                if (k) {
+                  deepDiff2(void 0, rhs[k], changes, prefilter, currentPath, k, stack, orderIndependent);
+                }
+              }
             }
-            x.length = x.length - 1;
+            stack.length = stack.length - 1;
+          } else if (lhs !== rhs) {
+            changes.push(new DiffEdit(currentPath, lhs, rhs));
+          }
+        } else if (lhs !== rhs) {
+          if (!(ltype === "number" && isNaN(lhs) && isNaN(rhs))) {
+            changes.push(new DiffEdit(currentPath, lhs, rhs));
           }
-        } else i !== l && (J === "number" && isNaN(i) && isNaN(l) || s.push(new d(N, i, l)));
+        }
       }
-      function g(i, l, s, c, b) {
-        var D = [];
-        if (h(i, l, D, c, null, null, null, b), s)
-          for (var x = 0; x < D.length; ++x)
-            s(D[x]);
-        return D;
+      function observableDiff(lhs, rhs, observer, prefilter, orderIndependent) {
+        var changes = [];
+        deepDiff2(lhs, rhs, changes, prefilter, null, null, null, orderIndependent);
+        if (observer) {
+          for (var i = 0; i < changes.length; ++i) {
+            observer(changes[i]);
+          }
+        }
+        return changes;
       }
-      function C(i, l, s, c, b, D, x) {
-        return h(i, l, s, c, b, D, x, !0);
+      function orderIndependentDeepDiff(lhs, rhs, changes, prefilter, path, key, stack) {
+        return deepDiff2(lhs, rhs, changes, prefilter, path, key, stack, true);
       }
-      function P(i, l, s, c) {
-        var b = c ? function(x) {
-          x && c.push(x);
-        } : void 0, D = g(i, l, b, s);
-        return c || (D.length ? D : void 0);
+      function accumulateDiff(lhs, rhs, prefilter, accum) {
+        var observer = accum ? function(difference) {
+          if (difference) {
+            accum.push(difference);
+          }
+        } : void 0;
+        var changes = observableDiff(lhs, rhs, observer, prefilter);
+        return accum ? accum : changes.length ? changes : void 0;
       }
-      function v(i, l, s, c) {
-        var b = c ? function(x) {
-          x && c.push(x);
-        } : void 0, D = g(i, l, b, s, !0);
-        return c || (D.length ? D : void 0);
+      function accumulateOrderIndependentDiff(lhs, rhs, prefilter, accum) {
+        var observer = accum ? function(difference) {
+          if (difference) {
+            accum.push(difference);
+          }
+        } : void 0;
+        var changes = observableDiff(lhs, rhs, observer, prefilter, true);
+        return accum ? accum : changes.length ? changes : void 0;
       }
-      function k(i, l, s) {
-        if (s.path && s.path.length) {
-          var c = i[l], b, D = s.path.length - 1;
-          for (b = 0; b < D; b++)
-            c = c[s.path[b]];
-          switch (s.kind) {
+      function applyArrayChange(arr, index, change) {
+        if (change.path && change.path.length) {
+          var it = arr[index], i, u = change.path.length - 1;
+          for (i = 0; i < u; i++) {
+            it = it[change.path[i]];
+          }
+          switch (change.kind) {
             case "A":
-              k(c[s.path[b]], s.index, s.item);
+              applyArrayChange(it[change.path[i]], change.index, change.item);
               break;
             case "D":
-              delete c[s.path[b]];
+              delete it[change.path[i]];
               break;
             case "E":
             case "N":
-              c[s.path[b]] = s.rhs;
+              it[change.path[i]] = change.rhs;
               break;
           }
-        } else
-          switch (s.kind) {
+        } else {
+          switch (change.kind) {
             case "A":
-              k(i[l], s.index, s.item);
+              applyArrayChange(arr[index], change.index, change.item);
               break;
             case "D":
-              i = m(i, l);
+              arr = arrayRemove(arr, index);
               break;
             case "E":
             case "N":
-              i[l] = s.rhs;
+              arr[index] = change.rhs;
               break;
           }
-        return i;
+        }
+        return arr;
       }
-      function O(i, l, s) {
-        if (typeof s > "u" && l && ~r.indexOf(l.kind) && (s = l), i && s && s.kind) {
-          for (var c = i, b = -1, D = s.path ? s.path.length - 1 : 0; ++b < D; )
-            typeof c[s.path[b]] > "u" && (c[s.path[b]] = typeof s.path[b + 1] < "u" && typeof s.path[b + 1] == "number" ? [] : {}), c = c[s.path[b]];
-          switch (s.kind) {
+      function applyChange(target, source, change) {
+        if (typeof change === "undefined" && source && ~validKinds.indexOf(source.kind)) {
+          change = source;
+        }
+        if (target && change && change.kind) {
+          var it = target, i = -1, last = change.path ? change.path.length - 1 : 0;
+          while (++i < last) {
+            if (typeof it[change.path[i]] === "undefined") {
+              it[change.path[i]] = typeof change.path[i + 1] !== "undefined" && typeof change.path[i + 1] === "number" ? [] : {};
+            }
+            it = it[change.path[i]];
+          }
+          switch (change.kind) {
             case "A":
-              s.path && typeof c[s.path[b]] > "u" && (c[s.path[b]] = []), k(s.path ? c[s.path[b]] : c, s.index, s.item);
+              if (change.path && typeof it[change.path[i]] === "undefined") {
+                it[change.path[i]] = [];
+              }
+              applyArrayChange(change.path ? it[change.path[i]] : it, change.index, change.item);
               break;
             case "D":
-              delete c[s.path[b]];
+              delete it[change.path[i]];
               break;
             case "E":
             case "N":
-              c[s.path[b]] = s.rhs;
+              it[change.path[i]] = change.rhs;
               break;
           }
         }
       }
-      function R(i, l, s) {
-        if (s.path && s.path.length) {
-          var c = i[l], b, D = s.path.length - 1;
-          for (b = 0; b < D; b++)
-            c = c[s.path[b]];
-          switch (s.kind) {
+      function revertArrayChange(arr, index, change) {
+        if (change.path && change.path.length) {
+          var it = arr[index], i, u = change.path.length - 1;
+          for (i = 0; i < u; i++) {
+            it = it[change.path[i]];
+          }
+          switch (change.kind) {
             case "A":
-              R(c[s.path[b]], s.index, s.item);
+              revertArrayChange(it[change.path[i]], change.index, change.item);
               break;
             case "D":
-              c[s.path[b]] = s.lhs;
+              it[change.path[i]] = change.lhs;
               break;
             case "E":
-              c[s.path[b]] = s.lhs;
+              it[change.path[i]] = change.lhs;
               break;
             case "N":
-              delete c[s.path[b]];
+              delete it[change.path[i]];
               break;
           }
-        } else
-          switch (s.kind) {
+        } else {
+          switch (change.kind) {
             case "A":
-              R(i[l], s.index, s.item);
+              revertArrayChange(arr[index], change.index, change.item);
               break;
             case "D":
-              i[l] = s.lhs;
+              arr[index] = change.lhs;
               break;
             case "E":
-              i[l] = s.lhs;
+              arr[index] = change.lhs;
               break;
             case "N":
-              i = m(i, l);
+              arr = arrayRemove(arr, index);
               break;
           }
-        return i;
+        }
+        return arr;
       }
-      function I(i, l, s) {
-        if (i && l && s && s.kind) {
-          var c = i, b, D;
-          for (D = s.path.length - 1, b = 0; b < D; b++)
-            typeof c[s.path[b]] > "u" && (c[s.path[b]] = {}), c = c[s.path[b]];
-          switch (s.kind) {
+      function revertChange(target, source, change) {
+        if (target && source && change && change.kind) {
+          var it = target, i, u;
+          u = change.path.length - 1;
+          for (i = 0; i < u; i++) {
+            if (typeof it[change.path[i]] === "undefined") {
+              it[change.path[i]] = {};
+            }
+            it = it[change.path[i]];
+          }
+          switch (change.kind) {
             case "A":
-              R(c[s.path[b]], s.index, s.item);
+              revertArrayChange(it[change.path[i]], change.index, change.item);
               break;
             case "D":
-              c[s.path[b]] = s.lhs;
+              it[change.path[i]] = change.lhs;
               break;
             case "E":
-              c[s.path[b]] = s.lhs;
+              it[change.path[i]] = change.lhs;
               break;
             case "N":
-              delete c[s.path[b]];
+              delete it[change.path[i]];
               break;
           }
         }
       }
-      function L(i, l, s) {
-        if (i && l) {
-          var c = function(b) {
-            (!s || s(i, l, b)) && O(i, l, b);
+      function applyDiff(target, source, filter) {
+        if (target && source) {
+          var onChange = function(change) {
+            if (!filter || filter(target, source, change)) {
+              applyChange(target, source, change);
+            }
           };
-          g(i, l, c);
+          observableDiff(target, source, onChange);
         }
       }
-      return Object.defineProperties(P, {
+      Object.defineProperties(accumulateDiff, {
         diff: {
-          value: P,
-          enumerable: !0
+          value: accumulateDiff,
+          enumerable: true
         },
         orderIndependentDiff: {
-          value: v,
-          enumerable: !0
+          value: accumulateOrderIndependentDiff,
+          enumerable: true
         },
         observableDiff: {
-          value: g,
-          enumerable: !0
+          value: observableDiff,
+          enumerable: true
         },
         orderIndependentObservableDiff: {
-          value: C,
-          enumerable: !0
+          value: orderIndependentDeepDiff,
+          enumerable: true
         },
         orderIndepHash: {
-          value: E,
-          enumerable: !0
+          value: getOrderIndependentHash,
+          enumerable: true
         },
         applyDiff: {
-          value: L,
-          enumerable: !0
+          value: applyDiff,
+          enumerable: true
         },
         applyChange: {
-          value: O,
-          enumerable: !0
+          value: applyChange,
+          enumerable: true
         },
         revertChange: {
-          value: I,
-          enumerable: !0
+          value: revertChange,
+          enumerable: true
         },
         isConflict: {
           value: function() {
-            return typeof $conflict < "u";
+            return typeof $conflict !== "undefined";
           },
-          enumerable: !0
+          enumerable: true
         }
-      }), P.DeepDiff = P, t && (t.DeepDiff = P), P;
+      });
+      accumulateDiff.DeepDiff = accumulateDiff;
+      if (root) {
+        root.DeepDiff = accumulateDiff;
+      }
+      return accumulateDiff;
     });
-  }(ie)), ie.exports;
+  })(deepDiff$1);
+  return deepDiff$1.exports;
 }
-var xe = Ke(), oe = { exports: {} };
-const z = new Uint32Array(65536), Ue = (n, e) => {
-  const t = n.length, r = e.length, o = 1 << t - 1;
-  let u = -1, d = 0, f = t, p = t;
-  for (; p--; )
-    z[n.charCodeAt(p)] |= 1 << p;
-  for (p = 0; p < r; p++) {
-    let y = z[e.charCodeAt(p)];
-    const m = y | d;
-    y |= (y & u) + u ^ u, d |= ~(y | u), u &= y, d & o && f++, u & o && f--, d = d << 1 | 1, u = u << 1 | ~(m | d), d &= m;
+var deepDiffExports = requireDeepDiff();
+var levenshtein$1 = { exports: {} };
+const peq = new Uint32Array(65536);
+const myers_32 = (a, b) => {
+  const n = a.length;
+  const m = b.length;
+  const lst = 1 << n - 1;
+  let pv = -1;
+  let mv = 0;
+  let sc = n;
+  let i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] |= 1 << i;
+  }
+  for (i = 0; i < m; i++) {
+    let eq = peq[b.charCodeAt(i)];
+    const xv = eq | mv;
+    eq |= (eq & pv) + pv ^ pv;
+    mv |= ~(eq | pv);
+    pv &= eq;
+    if (mv & lst) {
+      sc++;
+    }
+    if (pv & lst) {
+      sc--;
+    }
+    mv = mv << 1 | 1;
+    pv = pv << 1 | ~(xv | mv);
+    mv &= xv;
+  }
+  i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] = 0;
+  }
+  return sc;
+};
+const myers_x = (b, a) => {
+  const n = a.length;
+  const m = b.length;
+  const mhc = [];
+  const phc = [];
+  const hsize = Math.ceil(n / 32);
+  const vsize = Math.ceil(m / 32);
+  for (let i = 0; i < hsize; i++) {
+    phc[i] = -1;
+    mhc[i] = 0;
+  }
+  let j = 0;
+  for (; j < vsize - 1; j++) {
+    let mv2 = 0;
+    let pv2 = -1;
+    const start2 = j * 32;
+    const vlen2 = Math.min(32, m) + start2;
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] |= 1 << k;
+    }
+    for (let i = 0; i < n; i++) {
+      const eq = peq[a.charCodeAt(i)];
+      const pb = phc[i / 32 | 0] >>> i & 1;
+      const mb = mhc[i / 32 | 0] >>> i & 1;
+      const xv = eq | mv2;
+      const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
+      let ph = mv2 | ~(xh | pv2);
+      let mh = pv2 & xh;
+      if (ph >>> 31 ^ pb) {
+        phc[i / 32 | 0] ^= 1 << i;
+      }
+      if (mh >>> 31 ^ mb) {
+        mhc[i / 32 | 0] ^= 1 << i;
+      }
+      ph = ph << 1 | pb;
+      mh = mh << 1 | mb;
+      pv2 = mh | ~(xv | ph);
+      mv2 = ph & xv;
+    }
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] = 0;
+    }
   }
-  for (p = t; p--; )
-    z[n.charCodeAt(p)] = 0;
-  return f;
-}, He = (n, e) => {
-  const t = e.length, r = n.length, o = [], u = [], d = Math.ceil(t / 32), f = Math.ceil(r / 32);
-  for (let h = 0; h < d; h++)
-    u[h] = -1, o[h] = 0;
-  let p = 0;
-  for (; p < f - 1; p++) {
-    let h = 0, g = -1;
-    const C = p * 32, P = Math.min(32, r) + C;
-    for (let v = C; v < P; v++)
-      z[n.charCodeAt(v)] |= 1 << v;
-    for (let v = 0; v < t; v++) {
-      const k = z[e.charCodeAt(v)], O = u[v / 32 | 0] >>> v & 1, R = o[v / 32 | 0] >>> v & 1, I = k | h, L = ((k | R) & g) + g ^ g | k | R;
-      let i = h | ~(L | g), l = g & L;
-      i >>> 31 ^ O && (u[v / 32 | 0] ^= 1 << v), l >>> 31 ^ R && (o[v / 32 | 0] ^= 1 << v), i = i << 1 | O, l = l << 1 | R, g = l | ~(I | i), h = i & I;
+  let mv = 0;
+  let pv = -1;
+  const start = j * 32;
+  const vlen = Math.min(32, m - start) + start;
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] |= 1 << k;
+  }
+  let score = m;
+  for (let i = 0; i < n; i++) {
+    const eq = peq[a.charCodeAt(i)];
+    const pb = phc[i / 32 | 0] >>> i & 1;
+    const mb = mhc[i / 32 | 0] >>> i & 1;
+    const xv = eq | mv;
+    const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+    let ph = mv | ~(xh | pv);
+    let mh = pv & xh;
+    score += ph >>> m - 1 & 1;
+    score -= mh >>> m - 1 & 1;
+    if (ph >>> 31 ^ pb) {
+      phc[i / 32 | 0] ^= 1 << i;
+    }
+    if (mh >>> 31 ^ mb) {
+      mhc[i / 32 | 0] ^= 1 << i;
     }
-    for (let v = C; v < P; v++)
-      z[n.charCodeAt(v)] = 0;
+    ph = ph << 1 | pb;
+    mh = mh << 1 | mb;
+    pv = mh | ~(xv | ph);
+    mv = ph & xv;
   }
-  let y = 0, m = -1;
-  const A = p * 32, w = Math.min(32, r - A) + A;
-  for (let h = A; h < w; h++)
-    z[n.charCodeAt(h)] |= 1 << h;
-  let E = r;
-  for (let h = 0; h < t; h++) {
-    const g = z[e.charCodeAt(h)], C = u[h / 32 | 0] >>> h & 1, P = o[h / 32 | 0] >>> h & 1, v = g | y, k = ((g | P) & m) + m ^ m | g | P;
-    let O = y | ~(k | m), R = m & k;
-    E += O >>> r - 1 & 1, E -= R >>> r - 1 & 1, O >>> 31 ^ C && (u[h / 32 | 0] ^= 1 << h), R >>> 31 ^ P && (o[h / 32 | 0] ^= 1 << h), O = O << 1 | C, R = R << 1 | P, m = R | ~(v | O), y = O & v;
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] = 0;
   }
-  for (let h = A; h < w; h++)
-    z[n.charCodeAt(h)] = 0;
-  return E;
-}, Te = (n, e) => {
-  if (n.length < e.length) {
-    const t = e;
-    e = n, n = t;
+  return score;
+};
+const distance = (a, b) => {
+  if (a.length < b.length) {
+    const tmp = b;
+    b = a;
+    a = tmp;
+  }
+  if (b.length === 0) {
+    return a.length;
   }
-  return e.length === 0 ? n.length : n.length <= 32 ? Ue(n, e) : He(n, e);
-}, Je = (n, e) => {
-  let t = 1 / 0, r = 0;
-  for (let o = 0; o < e.length; o++) {
-    const u = Te(n, e[o]);
-    u < t && (t = u, r = o);
+  if (a.length <= 32) {
+    return myers_32(a, b);
   }
-  return e[r];
-}, Be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  return myers_x(a, b);
+};
+const closest = (str, arr) => {
+  let min_distance = Infinity;
+  let min_index = 0;
+  for (let i = 0; i < arr.length; i++) {
+    const dist = distance(str, arr[i]);
+    if (dist < min_distance) {
+      min_distance = dist;
+      min_index = i;
+    }
+  }
+  return arr[min_index];
+};
+const mod = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  closest: Je,
-  distance: Te
-}, Symbol.toStringTag, { value: "Module" })), Ve = /* @__PURE__ */ Se(Be);
-var me;
-function Ge() {
-  return me || (me = 1, function(n, e) {
+  closest,
+  distance
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(mod);
+var hasRequiredLevenshtein;
+function requireLevenshtein() {
+  if (hasRequiredLevenshtein) return levenshtein$1.exports;
+  hasRequiredLevenshtein = 1;
+  (function(module, exports) {
     (function() {
-      var t;
+      var collator;
       try {
-        t = typeof Intl < "u" && typeof Intl.Collator < "u" ? Intl.Collator("generic", { sensitivity: "base" }) : null;
-      } catch {
+        collator = typeof Intl !== "undefined" && typeof Intl.Collator !== "undefined" ? Intl.Collator("generic", { sensitivity: "base" }) : null;
+      } catch (err) {
         console.log("Collator could not be initialized and wouldn't be used");
       }
-      var r = Ve, o = [], u = [], d = {
+      var levenshtein2 = require$$0;
+      var prevRow = [], str2Char = [];
+      var Levenshtein = {
         /**
          * Calculate levenshtein distance of the two strings.
          *
@@ -1039,484 +1403,724 @@ function Ge() {
          * @param [options.useCollator] Use `Intl.Collator` for locale-sensitive string comparison.
          * @return Integer the levenshtein distance (0 and above).
          */
-        get: function(f, p, y) {
-          var m = y && t && y.useCollator;
-          if (m) {
-            var A = f.length, w = p.length;
-            if (A === 0) return w;
-            if (w === 0) return A;
-            var E, h, g, C, P;
-            for (g = 0; g < w; ++g)
-              o[g] = g, u[g] = p.charCodeAt(g);
-            o[w] = w;
-            var v;
-            for (g = 0; g < A; ++g) {
-              for (h = g + 1, C = 0; C < w; ++C)
-                E = h, v = t.compare(f.charAt(g), String.fromCharCode(u[C])) === 0, h = o[C] + (v ? 0 : 1), P = E + 1, h > P && (h = P), P = o[C + 1] + 1, h > P && (h = P), o[C] = E;
-              o[C] = h;
+        get: function(str1, str2, options) {
+          var useCollator = options && collator && options.useCollator;
+          if (useCollator) {
+            var str1Len = str1.length, str2Len = str2.length;
+            if (str1Len === 0) return str2Len;
+            if (str2Len === 0) return str1Len;
+            var curCol, nextCol, i, j, tmp;
+            for (i = 0; i < str2Len; ++i) {
+              prevRow[i] = i;
+              str2Char[i] = str2.charCodeAt(i);
+            }
+            prevRow[str2Len] = str2Len;
+            var strCmp;
+            for (i = 0; i < str1Len; ++i) {
+              nextCol = i + 1;
+              for (j = 0; j < str2Len; ++j) {
+                curCol = nextCol;
+                strCmp = 0 === collator.compare(str1.charAt(i), String.fromCharCode(str2Char[j]));
+                nextCol = prevRow[j] + (strCmp ? 0 : 1);
+                tmp = curCol + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                tmp = prevRow[j + 1] + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                prevRow[j] = curCol;
+              }
+              prevRow[j] = nextCol;
             }
-            return h;
+            return nextCol;
           }
-          return r.distance(f, p);
+          return levenshtein2.distance(str1, str2);
         }
       };
-      n !== null && n.exports === e ? n.exports = d : typeof self < "u" && typeof self.postMessage == "function" && typeof self.importScripts == "function" ? self.Levenshtein = d : typeof window < "u" && window !== null && (window.Levenshtein = d);
+      if (module !== null && true && module.exports === exports) {
+        module.exports = Levenshtein;
+      } else if (typeof self !== "undefined" && typeof self.postMessage === "function" && typeof self.importScripts === "function") {
+        self.Levenshtein = Levenshtein;
+      } else if (typeof window !== "undefined" && window !== null) {
+        window.Levenshtein = Levenshtein;
+      }
     })();
-  }(oe, oe.exports)), oe.exports;
+  })(levenshtein$1, levenshtein$1.exports);
+  return levenshtein$1.exports;
 }
-var Xe = Ge();
-const Ze = /* @__PURE__ */ _e(Xe);
-class Qe {
-  diff(e, t, r = {}) {
-    let o;
-    typeof r == "function" ? (o = r, r = {}) : "callback" in r && (o = r.callback);
-    const u = this.castInput(e, r), d = this.castInput(t, r), f = this.removeEmpty(this.tokenize(u, r)), p = this.removeEmpty(this.tokenize(d, r));
-    return this.diffWithOptionsObj(f, p, r, o);
+var levenshteinExports = requireLevenshtein();
+const levenshtein = /* @__PURE__ */ getDefaultExportFromCjs(levenshteinExports);
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
   }
-  diffWithOptionsObj(e, t, r, o) {
-    var u;
-    const d = (v) => {
-      if (v = this.postProcess(v, r), o) {
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
         setTimeout(function() {
-          o(v);
+          callback(value);
         }, 0);
-        return;
-      } else
-        return v;
-    }, f = t.length, p = e.length;
-    let y = 1, m = f + p;
-    r.maxEditLength != null && (m = Math.min(m, r.maxEditLength));
-    const A = (u = r.timeout) !== null && u !== void 0 ? u : 1 / 0, w = Date.now() + A, E = [{ oldPos: -1, lastComponent: void 0 }];
-    let h = this.extractCommon(E[0], t, e, 0, r);
-    if (E[0].oldPos + 1 >= p && h + 1 >= f)
-      return d(this.buildValues(E[0].lastComponent, t, e));
-    let g = -1 / 0, C = 1 / 0;
-    const P = () => {
-      for (let v = Math.max(g, -y); v <= Math.min(C, y); v += 2) {
-        let k;
-        const O = E[v - 1], R = E[v + 1];
-        O && (E[v - 1] = void 0);
-        let I = !1;
-        if (R) {
-          const i = R.oldPos - v;
-          I = R && 0 <= i && i < f;
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
         }
-        const L = O && O.oldPos + 1 < p;
-        if (!I && !L) {
-          E[v] = void 0;
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
           continue;
         }
-        if (!L || I && O.oldPos < R.oldPos ? k = this.addToPath(R, !0, !1, 0, r) : k = this.addToPath(O, !1, !0, 1, r), h = this.extractCommon(k, t, e, v, r), k.oldPos + 1 >= p && h + 1 >= f)
-          return d(this.buildValues(k.lastComponent, t, e)) || !0;
-        E[v] = k, k.oldPos + 1 >= p && (C = Math.min(C, v - 1)), h + 1 >= f && (g = Math.max(g, v + 1));
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
       }
-      y++;
+      editLength++;
     };
-    if (o)
-      (function v() {
+    if (callback) {
+      (function exec() {
         setTimeout(function() {
-          if (y > m || Date.now() > w)
-            return o(void 0);
-          P() || v();
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
         }, 0);
       })();
-    else
-      for (; y <= m && Date.now() <= w; ) {
-        const v = P();
-        if (v)
-          return v;
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
       }
+    }
   }
-  addToPath(e, t, r, o, u) {
-    const d = e.lastComponent;
-    return d && !u.oneChangePerToken && d.added === t && d.removed === r ? {
-      oldPos: e.oldPos + o,
-      lastComponent: { count: d.count + 1, added: t, removed: r, previousComponent: d.previousComponent }
-    } : {
-      oldPos: e.oldPos + o,
-      lastComponent: { count: 1, added: t, removed: r, previousComponent: d }
-    };
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
   }
-  extractCommon(e, t, r, o, u) {
-    const d = t.length, f = r.length;
-    let p = e.oldPos, y = p - o, m = 0;
-    for (; y + 1 < d && p + 1 < f && this.equals(r[p + 1], t[y + 1], u); )
-      y++, p++, m++, u.oneChangePerToken && (e.lastComponent = { count: 1, previousComponent: e.lastComponent, added: !1, removed: !1 });
-    return m && !u.oneChangePerToken && (e.lastComponent = { count: m, previousComponent: e.lastComponent, added: !1, removed: !1 }), e.oldPos = p, y;
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
   }
-  equals(e, t, r) {
-    return r.comparator ? r.comparator(e, t) : e === t || !!r.ignoreCase && e.toLowerCase() === t.toLowerCase();
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
   }
-  removeEmpty(e) {
-    const t = [];
-    for (let r = 0; r < e.length; r++)
-      e[r] && t.push(e[r]);
-    return t;
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(e, t) {
-    return e;
+  castInput(value, options) {
+    return value;
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(e, t) {
-    return Array.from(e);
+  tokenize(value, options) {
+    return Array.from(value);
   }
-  join(e) {
-    return e.join("");
+  join(chars) {
+    return chars.join("");
   }
-  postProcess(e, t) {
-    return e;
+  postProcess(changeObjects, options) {
+    return changeObjects;
   }
   get useLongestToken() {
-    return !1;
+    return false;
   }
-  buildValues(e, t, r) {
-    const o = [];
-    let u;
-    for (; e; )
-      o.push(e), u = e.previousComponent, delete e.previousComponent, e = u;
-    o.reverse();
-    const d = o.length;
-    let f = 0, p = 0, y = 0;
-    for (; f < d; f++) {
-      const m = o[f];
-      if (m.removed)
-        m.value = this.join(r.slice(y, y + m.count)), y += m.count;
-      else {
-        if (!m.added && this.useLongestToken) {
-          let A = t.slice(p, p + m.count);
-          A = A.map(function(w, E) {
-            const h = r[y + E];
-            return h.length > w.length ? h : w;
-          }), m.value = this.join(A);
-        } else
-          m.value = this.join(t.slice(p, p + m.count));
-        p += m.count, m.added || (y += m.count);
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
       }
     }
-    return o;
+    return components;
   }
 }
-class et extends Qe {
+class LineDiff extends Diff {
   constructor() {
-    super(...arguments), this.tokenize = nt;
+    super(...arguments);
+    this.tokenize = tokenize;
   }
-  equals(e, t, r) {
-    return r.ignoreWhitespace ? ((!r.newlineIsToken || !e.includes(`
-`)) && (e = e.trim()), (!r.newlineIsToken || !t.includes(`
-`)) && (t = t.trim())) : r.ignoreNewlineAtEof && !r.newlineIsToken && (e.endsWith(`
-`) && (e = e.slice(0, -1)), t.endsWith(`
-`) && (t = t.slice(0, -1))), super.equals(e, t, r);
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
   }
 }
-const tt = new et();
-function ve(n, e, t) {
-  return tt.diff(n, e, t);
+const lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
 }
-function nt(n, e) {
-  e.stripTrailingCr && (n = n.replace(/\r\n/g, `
-`));
-  const t = [], r = n.split(/(\n|\r\n)/);
-  r[r.length - 1] || r.pop();
-  for (let o = 0; o < r.length; o++) {
-    const u = r[o];
-    o % 2 && !e.newlineIsToken ? t[t.length - 1] += u : t.push(u);
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
   }
-  return t;
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
 }
-function be(n, e, t, r, o, u, d) {
-  let f;
-  d ? typeof d == "function" ? f = { callback: d } : f = d : f = {}, typeof f.context > "u" && (f.context = 4);
-  const p = f.context;
-  if (f.newlineIsToken)
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
     throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
-  if (f.callback) {
-    const { callback: m } = f;
-    ve(t, r, Object.assign(Object.assign({}, f), { callback: (A) => {
-      const w = y(A);
-      m(w);
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
     } }));
-  } else
-    return y(ve(t, r, f));
-  function y(m) {
-    if (!m)
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
       return;
-    m.push({ value: "", lines: [] });
-    function A(v) {
-      return v.map(function(k) {
-        return " " + k;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
       });
     }
-    const w = [];
-    let E = 0, h = 0, g = [], C = 1, P = 1;
-    for (let v = 0; v < m.length; v++) {
-      const k = m[v], O = k.lines || ot(k.value);
-      if (k.lines = O, k.added || k.removed) {
-        if (!E) {
-          const R = m[v - 1];
-          E = C, h = P, R && (g = p > 0 ? A(R.lines.slice(-p)) : [], E -= g.length, h -= g.length);
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
         }
-        for (const R of O)
-          g.push((k.added ? "+" : "-") + R);
-        k.added ? P += O.length : C += O.length;
       } else {
-        if (E)
-          if (O.length <= p * 2 && v < m.length - 2)
-            for (const R of A(O))
-              g.push(R);
-          else {
-            const R = Math.min(O.length, p);
-            for (const L of A(O.slice(0, R)))
-              g.push(L);
-            const I = {
-              oldStart: E,
-              oldLines: C - E + R,
-              newStart: h,
-              newLines: P - h + R,
-              lines: g
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
             };
-            w.push(I), E = 0, h = 0, g = [];
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
           }
-        C += O.length, P += O.length;
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
       }
     }
-    for (const v of w)
-      for (let k = 0; k < v.lines.length; k++)
-        v.lines[k].endsWith(`
-`) ? v.lines[k] = v.lines[k].slice(0, -1) : (v.lines.splice(k + 1, 0, "\"), k++);
     return {
-      oldFileName: n,
-      newFileName: e,
-      oldHeader: o,
-      newHeader: u,
-      hunks: w
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
     };
   }
 }
-function ue(n) {
-  if (Array.isArray(n))
-    return n.map(ue).join(`
-`);
-  const e = [];
-  n.oldFileName == n.newFileName && e.push("Index: " + n.oldFileName), e.push("==================================================================="), e.push("--- " + n.oldFileName + (typeof n.oldHeader > "u" ? "" : "	" + n.oldHeader)), e.push("+++ " + n.newFileName + (typeof n.newHeader > "u" ? "" : "	" + n.newHeader));
-  for (let t = 0; t < n.hunks.length; t++) {
-    const r = n.hunks[t];
-    r.oldLines === 0 && (r.oldStart -= 1), r.newLines === 0 && (r.newStart -= 1), e.push("@@ -" + r.oldStart + "," + r.oldLines + " +" + r.newStart + "," + r.newLines + " @@");
-    for (const o of r.lines)
-      e.push(o);
+function formatPatch(patch) {
+  if (Array.isArray(patch)) {
+    return patch.map(formatPatch).join("\n");
+  }
+  const ret = [];
+  if (patch.oldFileName == patch.newFileName) {
+    ret.push("Index: " + patch.oldFileName);
+  }
+  ret.push("===================================================================");
+  ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader === "undefined" ? "" : "	" + patch.oldHeader));
+  ret.push("+++ " + patch.newFileName + (typeof patch.newHeader === "undefined" ? "" : "	" + patch.newHeader));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    if (hunk.oldLines === 0) {
+      hunk.oldStart -= 1;
+    }
+    if (hunk.newLines === 0) {
+      hunk.newStart -= 1;
+    }
+    ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
   }
-  return e.join(`
-`) + `
-`;
+  return ret.join("\n") + "\n";
 }
-function rt(n, e, t, r, o, u, d) {
-  if (typeof d == "function" && (d = { callback: d }), d?.callback) {
-    const { callback: f } = d;
-    be(n, e, t, r, o, u, Object.assign(Object.assign({}, d), { callback: (p) => {
-      f(p ? ue(p) : void 0);
-    } }));
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj);
   } else {
-    const f = be(n, e, t, r, o, u, d);
-    return f ? ue(f) : void 0;
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj));
+      }
+    } }));
   }
 }
-function ot(n) {
-  const e = n.endsWith(`
-`), t = n.split(`
-`).map((r) => r + `
-`);
-  return e ? t.pop() : t.push(t.pop().slice(0, -1)), t;
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
 }
-function it(n, e, t = "git", r = 3) {
-  switch (t) {
+function formatDiff(oldValue, newValue, diffType = "git", context = 3) {
+  switch (diffType) {
     case "git":
-      return ye(n, e, r);
+      return formatGitDiff(oldValue, newValue, context);
     case "object":
-      return st(n, e);
+      return formatObjectDiff(oldValue, newValue);
     case "json":
-      return at(n, e);
+      return formatJsonDiff(oldValue, newValue);
     default:
-      return ye(n, e, r);
+      return formatGitDiff(oldValue, newValue, context);
   }
 }
-function ye(n, e, t = 3) {
-  const r = ge(n), o = ge(e);
-  return rt(
+function formatGitDiff(oldValue, newValue, context = 3) {
+  const oldStr = stringify(oldValue);
+  const newStr = stringify(newValue);
+  const patch = createTwoFilesPatch(
     /* oldFilename */
     "",
     /* newFilename */
     "",
-    r,
-    o,
+    oldStr,
+    newStr,
     /* oldHeader   */
     "",
     /* newHeader   */
     "",
-    { context: t }
-  ).split(`
-`).slice(2).join(`
-`);
+    { context }
+  );
+  return patch.split("\n").slice(2).join("\n");
 }
-function st(n, e) {
-  const t = xe.diff(n, e) || [];
-  return JSON.stringify(t, null, 2);
+function formatObjectDiff(oldValue, newValue) {
+  const differences = deepDiffExports.diff(oldValue, newValue) || [];
+  return JSON.stringify(differences, null, 2);
 }
-function at(n, e) {
+function formatJsonDiff(oldValue, newValue) {
   return JSON.stringify(
     {
-      before: n,
-      after: e
+      before: oldValue,
+      after: newValue
     },
     null,
     2
   );
 }
-function lt(n, e) {
-  return typeof n == "string" && typeof e == "string" ? Ce(n, e) : typeof n == "number" && typeof e == "number" ? Oe(n, e) : ut(n, e);
+function calculateDiffPercentage(oldValue, newValue) {
+  if (typeof oldValue === "string" && typeof newValue === "string") {
+    return calculateStringDiffPercentage(oldValue, newValue);
+  } else if (typeof oldValue === "number" && typeof newValue === "number") {
+    return calculateNumberDiffPercentage(oldValue, newValue);
+  } else {
+    return calculateObjectDiffPercentage(oldValue, newValue);
+  }
 }
-function Ce(n, e) {
-  if (n === e) return 0;
-  if (n.length === 0 || e.length === 0) return 1;
-  const t = Ze.get(n, e), r = Math.max(n.length, e.length);
-  return t / r;
+function calculateStringDiffPercentage(oldStr, newStr) {
+  if (oldStr === newStr) return 0;
+  if (oldStr.length === 0) return 1;
+  if (newStr.length === 0) return 1;
+  const distance2 = levenshtein.get(oldStr, newStr);
+  const maxLength = Math.max(oldStr.length, newStr.length);
+  return distance2 / maxLength;
 }
-function Oe(n, e) {
-  if (n === e) return 0;
-  if (n === 0) return 1;
-  const t = Math.abs(e - n), r = Math.max(Math.abs(n), Math.abs(e));
-  return Math.min(t / r, 1);
+function calculateNumberDiffPercentage(oldNum, newNum) {
+  if (oldNum === newNum) return 0;
+  if (oldNum === 0) return 1;
+  const change = Math.abs(newNum - oldNum);
+  const base = Math.max(Math.abs(oldNum), Math.abs(newNum));
+  return Math.min(change / base, 1);
 }
-function ut(n, e) {
-  if (n === e) return 0;
-  const t = xe.diff(n, e) || [];
-  if (t.length === 0) return 0;
-  const r = we(n), o = we(e), u = Math.max(r, o);
-  if (u === 0) return 0;
-  let d = 0;
-  for (const f of t)
-    switch (f.kind) {
+function calculateObjectDiffPercentage(oldObj, newObj) {
+  if (oldObj === newObj) return 0;
+  const differences = deepDiffExports.diff(oldObj, newObj) || [];
+  if (differences.length === 0) return 0;
+  const oldProps = countObjectProperties(oldObj);
+  const newProps = countObjectProperties(newObj);
+  const totalProps = Math.max(oldProps, newProps);
+  if (totalProps === 0) return 0;
+  let changeWeight = 0;
+  for (const difference of differences) {
+    switch (difference.kind) {
       case "N":
-        d += 1;
+        changeWeight += 1;
         break;
       case "D":
-        d += 1;
+        changeWeight += 1;
         break;
       case "E":
-        if (typeof f.lhs == "string" && typeof f.rhs == "string") {
-          const p = Ce(
-            f.lhs,
-            f.rhs
+        if (typeof difference.lhs === "string" && typeof difference.rhs === "string") {
+          const stringChangeRatio = calculateStringDiffPercentage(
+            difference.lhs,
+            difference.rhs
           );
-          d += p;
-        } else if (typeof f.lhs == "number" && typeof f.rhs == "number") {
-          const p = Oe(
-            f.lhs,
-            f.rhs
+          changeWeight += stringChangeRatio;
+        } else if (typeof difference.lhs === "number" && typeof difference.rhs === "number") {
+          const numberChangeRatio = calculateNumberDiffPercentage(
+            difference.lhs,
+            difference.rhs
           );
-          d += p;
-        } else
-          d += 1;
+          changeWeight += numberChangeRatio;
+        } else {
+          changeWeight += 1;
+        }
         break;
       case "A":
-        d += 0.5;
+        changeWeight += 0.5;
         break;
     }
-  return Math.min(d / u, 1);
+  }
+  return Math.min(changeWeight / totalProps, 1);
 }
-function we(n) {
-  if (n == null) return 0;
-  if (typeof n != "object") return 1;
-  if (Array.isArray(n)) return n.length;
-  let e = 0;
-  for (const t in n)
-    Object.prototype.hasOwnProperty.call(n, t) && (e += 1);
-  return e;
+function countObjectProperties(obj) {
+  if (obj === null || obj === void 0) return 0;
+  if (typeof obj !== "object") return 1;
+  if (Array.isArray(obj)) return obj.length;
+  let count = 0;
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      count += 1;
+    }
+  }
+  return count;
 }
-function ge(n) {
+function stringify(value) {
   try {
     return JSON.stringify(
-      n,
-      (e, t) => typeof t == "function" ? "[Function]" : t === void 0 ? "[undefined]" : t === 1 / 0 ? "[Infinity]" : Number.isNaN(t) ? "[NaN]" : t,
+      value,
+      (_key, val) => {
+        if (typeof val === "function") return "[Function]";
+        if (val === void 0) return "[undefined]";
+        if (val === Infinity) return "[Infinity]";
+        if (Number.isNaN(val)) return "[NaN]";
+        return val;
+      },
       2
     );
-  } catch {
-    return String(n);
+  } catch (_) {
+    return String(value);
   }
 }
-function ct(n, e, t) {
-  const r = ke(), o = t?.onFeedback || r, u = t?.debounceMs ?? 1500, d = t?.diffType ?? "git", f = t?.compareWith, p = t?.default_trigger_name ?? "auto_state_change", y = U(n), m = U(n), A = U(!0), w = U(null), E = U(void 0), h = W(
-    (C, P, v) => {
-      const k = lt(C, P), O = it(C, P, d);
-      let R;
-      t?.vote ? typeof t.vote == "function" ? R = t.vote(C, P, k) : R = t.vote : R = k > 0.5 ? "downvote" : "upvote";
-      const I = typeof e == "function" ? e(P) : e;
-      o({
-        tx_id: I,
-        vote: R,
-        explanation: `State change with diff percentage: ${(k * 100).toFixed(1)}%`,
-        correction: O,
+function useStateChangeTracking(currentState, tx_id, options) {
+  const defaultFeedbackHandler = useDefaultFeedbackHandler();
+  const feedbackHandler = options?.onFeedback || defaultFeedbackHandler;
+  const debounceMs = options?.debounceMs ?? 1500;
+  const diffType = options?.diffType ?? "git";
+  const compareWith = options?.compareWith;
+  const defaultTriggerName = options?.default_trigger_name ?? "auto_state_change";
+  const prevStateRef = useRef(currentState);
+  const changeStartStateRef = useRef(currentState);
+  const isFirstRenderRef = useRef(true);
+  const timeoutRef = useRef(null);
+  const currentTriggerNameRef = useRef(void 0);
+  const sendFeedback = useCallback(
+    (startState, endState, triggerName) => {
+      const diffPercentage = calculateDiffPercentage(startState, endState);
+      const diffString = formatDiff(startState, endState, diffType);
+      let vote;
+      if (options?.vote) {
+        if (typeof options.vote === "function") {
+          vote = options.vote(startState, endState, diffPercentage);
+        } else {
+          vote = options.vote;
+        }
+      } else {
+        vote = diffPercentage > 0.5 ? "downvote" : "upvote";
+      }
+      const idString = typeof tx_id === "function" ? tx_id(endState) : tx_id;
+      feedbackHandler({
+        tx_id: idString,
+        vote,
+        explanation: `State change with diff percentage: ${(diffPercentage * 100).toFixed(1)}%`,
+        correction: diffString,
         source: "IMPLICIT",
-        extra_metadata: t?.metadata,
-        trigger_name: v
+        extra_metadata: options?.metadata,
+        trigger_name: triggerName
       });
     },
-    [t, e, d, o]
-  ), g = W(
-    (C) => {
-      const P = C || p;
-      if (w.current && E.current && E.current !== P) {
-        clearTimeout(w.current);
-        const v = m.current;
-        h(
-          v,
-          n,
-          E.current
-        ), w.current = null;
+    [options, tx_id, diffType, feedbackHandler]
+  );
+  const notifyChange = useCallback(
+    (trigger_name) => {
+      const newTriggerName = trigger_name || defaultTriggerName;
+      if (timeoutRef.current && currentTriggerNameRef.current && currentTriggerNameRef.current !== newTriggerName) {
+        clearTimeout(timeoutRef.current);
+        const startState = changeStartStateRef.current;
+        const currentStateBeforeChange = currentState;
+        sendFeedback(
+          startState,
+          currentStateBeforeChange,
+          currentTriggerNameRef.current
+        );
+        timeoutRef.current = null;
       }
-      E.current = P;
+      currentTriggerNameRef.current = newTriggerName;
     },
-    [n, p, h]
+    [currentState, defaultTriggerName, sendFeedback]
   );
-  return De(() => {
-    if (A.current) {
-      A.current = !1, y.current = n, m.current = n;
+  useEffect(() => {
+    if (isFirstRenderRef.current) {
+      isFirstRenderRef.current = false;
+      prevStateRef.current = currentState;
+      changeStartStateRef.current = currentState;
       return;
     }
-    const C = y.current;
-    return (f ? f(C, n) : JSON.stringify(C) === JSON.stringify(n)) || (w.current || (m.current = C), w.current && clearTimeout(w.current), y.current = n, w.current = setTimeout(() => {
-      const v = m.current, k = n;
-      h(
-        v,
-        k,
-        E.current || p
-      ), m.current = k, w.current = null;
-    }, u)), () => {
-      w.current && clearTimeout(w.current);
+    const prevState = prevStateRef.current;
+    const isEqual = compareWith ? compareWith(prevState, currentState) : JSON.stringify(prevState) === JSON.stringify(currentState);
+    if (!isEqual) {
+      if (!timeoutRef.current) {
+        changeStartStateRef.current = prevState;
+      }
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      prevStateRef.current = currentState;
+      timeoutRef.current = setTimeout(() => {
+        const startState = changeStartStateRef.current;
+        const finalState = currentState;
+        sendFeedback(
+          startState,
+          finalState,
+          currentTriggerNameRef.current || defaultTriggerName
+        );
+        changeStartStateRef.current = finalState;
+        timeoutRef.current = null;
+      }, debounceMs);
+    }
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
     };
   }, [
-    n,
-    e,
-    t,
-    o,
-    d,
-    u,
-    f,
-    p,
-    h
-  ]), {
-    notifyChange: g
+    currentState,
+    tx_id,
+    options,
+    feedbackHandler,
+    diffType,
+    debounceMs,
+    compareWith,
+    defaultTriggerName,
+    sendFeedback
+  ]);
+  return {
+    notifyChange
   };
 }
-function vt(n, e, t) {
-  const [r, o] = X(n), { notifyChange: u } = ct(r, e, t), d = W(
-    (f, p) => {
-      u(p), o((y) => typeof f == "function" ? f(y) : f);
+function useFeedbackState(initialState, tx_id, options) {
+  const [state, setStateInternal] = useState(initialState);
+  const { notifyChange } = useStateChangeTracking(state, tx_id, options);
+  const setState = useCallback(
+    (value, trigger_name) => {
+      notifyChange(trigger_name);
+      setStateInternal((prevState) => {
+        const newState = typeof value === "function" ? value(prevState) : value;
+        return newState;
+      });
     },
-    [u]
+    [notifyChange]
   );
-  return [r, d];
+  return [state, setState];
 }
-let ft = () => {
+let _loadOtelApi = () => {
   try {
     return require("@opentelemetry/api");
   } catch {
@@ -1525,21 +2129,23 @@ let ft = () => {
     );
   }
 };
-function bt() {
-  const { trace: n, context: e } = ft();
+function getOtelTraceId() {
+  const { trace, context } = _loadOtelApi();
   try {
-    const t = n.getSpanContext(e.active());
-    if (t?.traceId)
-      return t.traceId;
-    const r = n.getSpan(e.active());
-    if (r) {
-      const o = r.spanContext();
-      if (o.traceId)
-        return o.traceId;
+    const spanContext = trace.getSpanContext(context.active());
+    if (spanContext?.traceId) {
+      return spanContext.traceId;
+    }
+    const activeSpan = trace.getSpan(context.active());
+    if (activeSpan) {
+      const spanCtx = activeSpan.spanContext();
+      if (spanCtx.traceId) {
+        return spanCtx.traceId;
+      }
     }
-  } catch (t) {
+  } catch (error) {
     throw new Error(
-      `Failed to extract OpenTelemetry trace ID: ${t instanceof Error ? t.message : "Unknown error"}`
+      `Failed to extract OpenTelemetry trace ID: ${error instanceof Error ? error.message : "Unknown error"}`
     );
   }
   throw new Error(
@@ -1547,11 +2153,12 @@ function bt() {
   );
 }
 export {
-  se as KeletContext,
-  ht as KeletProvider,
-  mt as VoteFeedback,
-  bt as getOtelTraceId,
-  ke as useDefaultFeedbackHandler,
-  vt as useFeedbackState,
-  pt as useKelet
+  KeletContext,
+  KeletProvider,
+  VoteFeedback,
+  getOtelTraceId,
+  useDefaultFeedbackHandler,
+  useFeedbackState,
+  useKelet
 };
+//# sourceMappingURL=feedback-ui.es.js.map