fec-dev-designer 1.0.0 → 1.0.1

package/es/node_modules/vue3-json-viewer/dist/vue3-json-viewer.js

@@ -0,0 +1,1086 @@
+import { defineComponent as T, ref as k, onMounted as J, h as g, watch as F, computed as O, inject as $, provide as q, openBlock as _, createElementBlock as N, toDisplayString as A, normalizeClass as S, nextTick as se, resolveComponent as ce, createElementVNode as z, renderSlot as pe, createTextVNode as de, createCommentVNode as Y, createVNode as fe } from "vue";
+const ve = /^([hH][tT]{2}[pP]:\/\/|[hH][tT]{2}[pP][sS]:\/\/)(([A-Za-z0-9-~]+)\.)+([A-Za-z0-9-~\/])+$/, X = T({
+  name: "JsonString",
+  props: {
+    /** The string value to display. */
+    jsonValue: {
+      type: String,
+      required: !0
+    }
+  },
+  /**
+   * Setup function for the JsonString component.
+   * @param props - The component's props.
+   */
+  setup(e) {
+    const y = k(!0), c = k(!1), p = k(null), f = k(null);
+    J(() => {
+      p.value && f.value && p.value.offsetHeight > f.value.offsetHeight && (c.value = !0);
+    });
+    const s = () => {
+      y.value = !y.value;
+    };
+    return () => {
+      const n = e.jsonValue, t = ve.test(n);
+      let o;
+      !y.value && c.value ? o = g("span", {
+        class: { "jv-ellipsis": !0 },
+        onClick: s
+      }, "...") : t ? o = g("span", { class: { "jv-item": !0, "jv-string": !0 }, ref: p }, [
+        g("span", null, '"'),
+        // Opening quote
+        g("a", { href: n, target: "_blank", class: "jv-link" }, n),
+        g("span", null, '"')
+        // Closing quote
+      ]) : o = g("span", {
+        class: { "jv-item": !0, "jv-string": !0 },
+        ref: p
+        // Assign ref for height calculation
+      }, `"${n}"`);
+      const a = [];
+      return c.value && a.push(g("span", {
+        class: {
+          "jv-toggle": !0,
+          // CSS class for the toggle button
+          open: y.value
+          // Class to indicate open/closed state
+        },
+        onClick: s
+      })), a.push(g("span", { class: { "jv-holder-node": !0 }, ref: f })), a.push(o), g("span", {}, a);
+    };
+  }
+}), ye = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-undefined"])
+}, me = /* @__PURE__ */ T({
+  __name: "json-undefined",
+  props: {
+    /**
+     * The value to display. Expected to be `null` or `undefined`.
+     * The `type` is set to `null` and `PropType` is used to allow `undefined` as well,
+     * with a default of `undefined`.
+     */
+    jsonValue: {
+      type: null,
+      default: void 0
+    }
+  },
+  setup(e) {
+    const y = e, c = O(() => y.jsonValue === null ? "null" : "undefined");
+    return (p, f) => (_(), N("span", ye, A(c.value), 1));
+  }
+}), he = /* @__PURE__ */ T({
+  __name: "json-number",
+  props: {
+    /** The number value to display. */
+    jsonValue: {
+      type: Number,
+      required: !0
+    }
+  },
+  setup(e) {
+    const y = e, c = O(() => Number.isInteger(y.jsonValue));
+    return (p, f) => (_(), N("span", {
+      class: S(["jv-item", "jv-number", c.value ? "jv-number-integer" : "jv-number-float"])
+    }, A(e.jsonValue.toString()), 3));
+  }
+}), ge = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-boolean"])
+}, be = /* @__PURE__ */ T({
+  __name: "json-boolean",
+  props: {
+    /** The boolean value to display. */
+    jsonValue: {
+      type: Boolean,
+      required: !0
+    }
+  },
+  setup(e) {
+    return (y, c) => (_(), N("span", ge, A(e.jsonValue.toString()), 1));
+  }
+}), je = T({
+  name: "JsonObject",
+  props: {
+    /** The object value to render. */
+    jsonValue: {
+      type: Object,
+      required: !0
+    },
+    /** The key name of this object if it's a property of another object. */
+    keyName: {
+      type: String,
+      default: ""
+    },
+    /** Current nesting depth of this object. */
+    depth: {
+      type: Number,
+      default: 0
+    },
+    /** Whether this object should be rendered in an expanded state. */
+    expand: Boolean,
+    /** Whether to sort the keys of this object alphabetically. */
+    sort: Boolean,
+    /** Whether preview mode is enabled. */
+    previewMode: Boolean
+  },
+  emits: ["update:expand"],
+  /**
+   * Setup function for the JsonObject component.
+   * @param props - The component's props.
+   * @param context - The setup context, including `emit`.
+   */
+  setup(e, { emit: y }) {
+    const c = k({});
+    let p = null;
+    const f = (o) => {
+      setTimeout(() => {
+        c.value = o;
+      }, 0);
+    };
+    F(() => e.jsonValue, (o) => {
+      f(o);
+    }, { immediate: !0, deep: !0 });
+    const s = O(() => {
+      if (!e.sort)
+        return c.value;
+      const o = Object.keys(c.value).sort(), a = {};
+      return o.forEach((d) => {
+        a[d] = c.value[d];
+      }), a;
+    }), n = () => {
+      if (p)
+        try {
+          p.dispatchEvent(new Event("resized"));
+        } catch {
+          const o = document.createEvent("Event");
+          o.initEvent("resized", !0, !1), p.dispatchEvent(o);
+        }
+    }, t = () => {
+      y("update:expand", !e.expand), n();
+    };
+    return () => {
+      const o = [];
+      if (o.push(g("span", { class: ["jv-item", "jv-object"] }, "{")), e.expand) {
+        for (const a in s.value)
+          if (s.value.hasOwnProperty(a)) {
+            const d = s.value[a];
+            o.push(g(I, {
+              key: a,
+              // style: { display: !props.expand ? 'none' : undefined }, // Redundant
+              sort: e.sort,
+              keyName: a,
+              depth: e.depth + 1,
+              value: d,
+              previewMode: e.previewMode
+            }));
+          }
+      }
+      return !e.expand && Object.keys(c.value).length > 0 && o.push(g("span", {
+        // style: { display: props.expand ? 'none' : undefined }, // Redundant
+        class: "jv-ellipsis",
+        onClick: t,
+        title: `click to reveal object content (keys: ${Object.keys(s.value).join(", ")})`
+      }, "...")), o.push(g("span", { class: ["jv-item", "jv-object"] }, "}")), g("span", { ref: (a) => {
+        p = a;
+      } }, o);
+    };
+  }
+}), xe = T({
+  name: "JsonArray",
+  props: {
+    /** The array value to render. */
+    jsonValue: {
+      type: Array,
+      required: !0
+    },
+    /** The key name of this array if it's a property of an object. */
+    keyName: {
+      type: String,
+      default: ""
+    },
+    /** Current nesting depth of this array. */
+    depth: {
+      type: Number,
+      default: 0
+    },
+    /** Whether to sort array items (Note: arrays are typically not sorted by key). */
+    sort: Boolean,
+    // This prop might be less relevant for arrays vs objects
+    /** Whether this array should be rendered in an expanded state. */
+    expand: Boolean,
+    /** Whether preview mode is enabled (potentially showing a condensed view). */
+    previewMode: Boolean
+  },
+  emits: ["update:expand"],
+  /**
+   * Setup function for the JsonArray component.
+   * @param props - The component's props.
+   * @param context - The setup context, including `emit`.
+   */
+  setup(e, { emit: y }) {
+    const c = k([]);
+    let p = null;
+    const f = (n, t = 0) => {
+      t === 0 && (c.value = []), setTimeout(() => {
+        n && n.length > t && (c.value.push(n[t]), f(n, t + 1));
+      }, 0);
+    };
+    F(() => e.jsonValue, (n) => {
+      f(n);
+    }, { immediate: !0, deep: !0 });
+    const s = () => {
+      if (y("update:expand", !e.expand), p)
+        try {
+          p.dispatchEvent(new Event("resized"));
+        } catch {
+          const n = document.createEvent("Event");
+          n.initEvent("resized", !0, !1), p.dispatchEvent(n);
+        }
+    };
+    return () => {
+      const n = [];
+      return !e.previewMode && !e.keyName && n.push(g("span", {
+        class: {
+          "jv-toggle": !0,
+          open: !!e.expand
+        },
+        onClick: s
+      })), n.push(g("span", {
+        class: ["jv-item", "jv-array"]
+      }, "[")), e.expand && c.value.forEach((t, o) => {
+        n.push(g(I, {
+          // Cast JsonBox to Component
+          key: o,
+          // style: { display: props.expand ? undefined : 'none' }, // This style is redundant if items are not rendered
+          sort: e.sort,
+          depth: e.depth + 1,
+          value: t,
+          previewMode: e.previewMode
+        }));
+      }), !e.expand && c.value.length > 0 && n.push(g("span", {
+        class: "jv-ellipsis",
+        onClick: s,
+        title: `click to reveal ${c.value.length} hidden items`
+      }, "...")), n.push(g("span", {
+        class: ["jv-item", "jv-array"]
+      }, "]")), g("span", { ref: (t) => {
+        p = t;
+      } }, n);
+    };
+  }
+}), Ee = ["title"], we = /* @__PURE__ */ T({
+  __name: "json-function",
+  props: {
+    /** The Function object to represent. */
+    jsonValue: {
+      type: Function,
+      required: !0
+    }
+  },
+  setup(e) {
+    return (y, c) => (_(), N("span", {
+      class: S(["jv-item", "jv-function"]),
+      title: e.jsonValue.toString()
+    }, " <function> ", 8, Ee));
+  }
+}), ke = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-string"])
+}, Se = /* @__PURE__ */ T({
+  __name: "json-date",
+  props: {
+    /** The Date object to display. */
+    jsonValue: {
+      type: Date,
+      required: !0
+    }
+  },
+  setup(e) {
+    const y = e, c = $("timeformat", (f) => f.toLocaleString()), p = O(() => c(y.jsonValue));
+    return (f, s) => (_(), N("span", ke, ' "' + A(p.value) + '" ', 1));
+  }
+}), Te = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-regexp"])
+}, Ce = /* @__PURE__ */ T({
+  __name: "json-regexp",
+  props: {
+    /** The RegExp object to display. */
+    jsonValue: {
+      type: RegExp,
+      required: !0
+    }
+  },
+  setup(e) {
+    return (y, c) => (_(), N("span", Te, A(e.jsonValue.toString()), 1));
+  }
+}), I = T({
+  name: "JsonBox",
+  props: {
+    /** The JSON value to render. Can be any valid JSON type. */
+    value: {
+      type: [Object, Array, String, Number, Boolean, Function, Date],
+      default: null
+    },
+    /** The key name for this value, if it's part of an object. */
+    keyName: {
+      type: String,
+      default: ""
+    },
+    /** Whether to sort object keys alphabetically. Passed down from JsonViewer. */
+    sort: Boolean,
+    /** Current nesting depth of this component. */
+    depth: {
+      type: Number,
+      default: 0
+    },
+    /** Whether preview mode is enabled. Passed down from JsonViewer. */
+    previewMode: Boolean
+  },
+  /**
+   * Setup function for the JsonBox component.
+   * @param props - The component's props.
+   */
+  setup(e) {
+    const y = $("expandDepth", 1 / 0), c = $("keyClick", () => {
+    }), p = k(!0);
+    let f = null;
+    J(() => {
+      p.value = e.previewMode || e.depth < y;
+    });
+    const s = () => {
+      if (p.value = !p.value, f)
+        try {
+          f.dispatchEvent(new Event("resized"));
+        } catch {
+          const n = document.createEvent("Event");
+          n.initEvent("resized", !0, !1), f.dispatchEvent(n);
+        }
+    };
+    return () => {
+      const n = [];
+      let t;
+      e.value === null || e.value === void 0 ? t = me : Array.isArray(e.value) ? t = xe : e.value instanceof Date ? t = Se : e.value instanceof RegExp ? t = Ce : typeof e.value == "object" ? t = je : typeof e.value == "number" ? t = he : typeof e.value == "string" ? t = X : typeof e.value == "boolean" ? t = be : typeof e.value == "function" ? t = we : t = X;
+      const o = e.value && (Array.isArray(e.value) || typeof e.value == "object" && !(e.value instanceof Date) && // Exclude Date
+      !(e.value instanceof RegExp));
+      return !e.previewMode && o && !(e.value instanceof RegExp) && n.push(
+        g("span", {
+          class: {
+            "jv-toggle": !0,
+            open: !!p.value
+            // Double negation to ensure boolean
+          },
+          onClick: s
+        })
+      ), e.keyName && n.push(
+        g("span", {
+          class: "jv-key",
+          // 'jv-key' is a string, not an object
+          onClick: () => {
+            c && c(e.keyName);
+          }
+        }, `${e.keyName}:`)
+        // Text content as children
+      ), n.push(
+        g(t, {
+          class: "jv-push",
+          // 'jv-push' is a string
+          jsonValue: e.value,
+          keyName: e.keyName,
+          // Pass keyName for context if needed by child
+          sort: e.sort,
+          // Pass sort for objects/arrays
+          depth: e.depth,
+          // Pass current depth
+          expand: p.value,
+          // Pass current expand state
+          previewMode: e.previewMode,
+          // Listen for 'update:expand' events from child components (e.g., JsonArray, JsonObject)
+          // This allows children to request a change in their own expansion state.
+          "onUpdate:expand": (a) => {
+            p.value = a;
+          }
+        })
+      ), g(
+        "div",
+        {
+          class: {
+            "jv-node": !0,
+            "jv-key-node": !!e.keyName && !o,
+            // Apply if keyName exists and not a complex type
+            toggle: !e.previewMode && o
+            // Apply if not preview and is complex for styling indent
+          },
+          ref: (a) => {
+            f = a;
+          }
+        },
+        n
+      );
+    };
+  }
+});
+function _e(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var H = { exports: {} };
+/*!
+ * clipboard.js v2.0.11
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+var Ne = H.exports, Z;
+function Oe() {
+  return Z || (Z = 1, function(e, y) {
+    (function(c, p) {
+      e.exports = p();
+    })(Ne, function() {
+      return (
+        /******/
+        function() {
+          var c = {
+            /***/
+            686: (
+              /***/
+              function(s, n, t) {
+                t.d(n, {
+                  default: function() {
+                    return (
+                      /* binding */
+                      le
+                    );
+                  }
+                });
+                var o = t(279), a = /* @__PURE__ */ t.n(o), d = t(370), j = /* @__PURE__ */ t.n(d), b = t(817), w = /* @__PURE__ */ t.n(b);
+                function v(u) {
+                  try {
+                    return document.execCommand(u);
+                  } catch {
+                    return !1;
+                  }
+                }
+                var x = function(u) {
+                  var r = w()(u);
+                  return v("cut"), r;
+                }, h = x;
+                function C(u) {
+                  var r = document.documentElement.getAttribute("dir") === "rtl", l = document.createElement("textarea");
+                  l.style.fontSize = "12pt", l.style.border = "0", l.style.padding = "0", l.style.margin = "0", l.style.position = "absolute", l.style[r ? "right" : "left"] = "-9999px";
+                  var i = window.pageYOffset || document.documentElement.scrollTop;
+                  return l.style.top = "".concat(i, "px"), l.setAttribute("readonly", ""), l.value = u, l;
+                }
+                var K = function(u, r) {
+                  var l = C(u);
+                  r.container.appendChild(l);
+                  var i = w()(l);
+                  return v("copy"), l.remove(), i;
+                }, G = function(u) {
+                  var r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                    container: document.body
+                  }, l = "";
+                  return typeof u == "string" ? l = K(u, r) : u instanceof HTMLInputElement && !["text", "search", "url", "tel", "password"].includes(u == null ? void 0 : u.type) ? l = K(u.value, r) : (l = w()(u), v("copy")), l;
+                }, R = G;
+                function V(u) {
+                  "@babel/helpers - typeof";
+                  return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? V = function(r) {
+                    return typeof r;
+                  } : V = function(r) {
+                    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+                  }, V(u);
+                }
+                var Q = function() {
+                  var u = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, r = u.action, l = r === void 0 ? "copy" : r, i = u.container, m = u.target, E = u.text;
+                  if (l !== "copy" && l !== "cut")
+                    throw new Error('Invalid "action" value, use either "copy" or "cut"');
+                  if (m !== void 0)
+                    if (m && V(m) === "object" && m.nodeType === 1) {
+                      if (l === "copy" && m.hasAttribute("disabled"))
+                        throw new Error('Invalid "target" attribute. Please use "readonly" instead of "disabled" attribute');
+                      if (l === "cut" && (m.hasAttribute("readonly") || m.hasAttribute("disabled")))
+                        throw new Error(`Invalid "target" attribute. You can't cut text from elements with "readonly" or "disabled" attributes`);
+                    } else
+                      throw new Error('Invalid "target" value, use a valid Element');
+                  if (E)
+                    return R(E, {
+                      container: i
+                    });
+                  if (m)
+                    return l === "cut" ? h(m) : R(m, {
+                      container: i
+                    });
+                }, W = Q;
+                function M(u) {
+                  "@babel/helpers - typeof";
+                  return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? M = function(r) {
+                    return typeof r;
+                  } : M = function(r) {
+                    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+                  }, M(u);
+                }
+                function ee(u, r) {
+                  if (!(u instanceof r))
+                    throw new TypeError("Cannot call a class as a function");
+                }
+                function U(u, r) {
+                  for (var l = 0; l < r.length; l++) {
+                    var i = r[l];
+                    i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(u, i.key, i);
+                  }
+                }
+                function te(u, r, l) {
+                  return r && U(u.prototype, r), l && U(u, l), u;
+                }
+                function ne(u, r) {
+                  if (typeof r != "function" && r !== null)
+                    throw new TypeError("Super expression must either be null or a function");
+                  u.prototype = Object.create(r && r.prototype, { constructor: { value: u, writable: !0, configurable: !0 } }), r && D(u, r);
+                }
+                function D(u, r) {
+                  return D = Object.setPrototypeOf || function(l, i) {
+                    return l.__proto__ = i, l;
+                  }, D(u, r);
+                }
+                function oe(u) {
+                  var r = ue();
+                  return function() {
+                    var l = B(u), i;
+                    if (r) {
+                      var m = B(this).constructor;
+                      i = Reflect.construct(l, arguments, m);
+                    } else
+                      i = l.apply(this, arguments);
+                    return re(this, i);
+                  };
+                }
+                function re(u, r) {
+                  return r && (M(r) === "object" || typeof r == "function") ? r : ae(u);
+                }
+                function ae(u) {
+                  if (u === void 0)
+                    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                  return u;
+                }
+                function ue() {
+                  if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham)
+                    return !1;
+                  if (typeof Proxy == "function")
+                    return !0;
+                  try {
+                    return Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+                    })), !0;
+                  } catch {
+                    return !1;
+                  }
+                }
+                function B(u) {
+                  return B = Object.setPrototypeOf ? Object.getPrototypeOf : function(r) {
+                    return r.__proto__ || Object.getPrototypeOf(r);
+                  }, B(u);
+                }
+                function P(u, r) {
+                  var l = "data-clipboard-".concat(u);
+                  if (r.hasAttribute(l))
+                    return r.getAttribute(l);
+                }
+                var ie = /* @__PURE__ */ function(u) {
+                  ne(l, u);
+                  var r = oe(l);
+                  function l(i, m) {
+                    var E;
+                    return ee(this, l), E = r.call(this), E.resolveOptions(m), E.listenClick(i), E;
+                  }
+                  return te(l, [{
+                    key: "resolveOptions",
+                    value: function() {
+                      var i = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                      this.action = typeof i.action == "function" ? i.action : this.defaultAction, this.target = typeof i.target == "function" ? i.target : this.defaultTarget, this.text = typeof i.text == "function" ? i.text : this.defaultText, this.container = M(i.container) === "object" ? i.container : document.body;
+                    }
+                    /**
+                     * Adds a click event listener to the passed trigger.
+                     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+                     */
+                  }, {
+                    key: "listenClick",
+                    value: function(i) {
+                      var m = this;
+                      this.listener = j()(i, "click", function(E) {
+                        return m.onClick(E);
+                      });
+                    }
+                    /**
+                     * Defines a new `ClipboardAction` on each click event.
+                     * @param {Event} e
+                     */
+                  }, {
+                    key: "onClick",
+                    value: function(i) {
+                      var m = i.delegateTarget || i.currentTarget, E = this.action(m) || "copy", L = W({
+                        action: E,
+                        container: this.container,
+                        target: this.target(m),
+                        text: this.text(m)
+                      });
+                      this.emit(L ? "success" : "error", {
+                        action: E,
+                        text: L,
+                        trigger: m,
+                        clearSelection: function() {
+                          m && m.focus(), window.getSelection().removeAllRanges();
+                        }
+                      });
+                    }
+                    /**
+                     * Default `action` lookup function.
+                     * @param {Element} trigger
+                     */
+                  }, {
+                    key: "defaultAction",
+                    value: function(i) {
+                      return P("action", i);
+                    }
+                    /**
+                     * Default `target` lookup function.
+                     * @param {Element} trigger
+                     */
+                  }, {
+                    key: "defaultTarget",
+                    value: function(i) {
+                      var m = P("target", i);
+                      if (m)
+                        return document.querySelector(m);
+                    }
+                    /**
+                     * Allow fire programmatically a copy action
+                     * @param {String|HTMLElement} target
+                     * @param {Object} options
+                     * @returns Text copied.
+                     */
+                  }, {
+                    key: "defaultText",
+                    /**
+                     * Default `text` lookup function.
+                     * @param {Element} trigger
+                     */
+                    value: function(i) {
+                      return P("text", i);
+                    }
+                    /**
+                     * Destroy lifecycle.
+                     */
+                  }, {
+                    key: "destroy",
+                    value: function() {
+                      this.listener.destroy();
+                    }
+                  }], [{
+                    key: "copy",
+                    value: function(i) {
+                      var m = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                        container: document.body
+                      };
+                      return R(i, m);
+                    }
+                    /**
+                     * Allow fire programmatically a cut action
+                     * @param {String|HTMLElement} target
+                     * @returns Text cutted.
+                     */
+                  }, {
+                    key: "cut",
+                    value: function(i) {
+                      return h(i);
+                    }
+                    /**
+                     * Returns the support of the given action, or all actions if no action is
+                     * given.
+                     * @param {String} [action]
+                     */
+                  }, {
+                    key: "isSupported",
+                    value: function() {
+                      var i = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ["copy", "cut"], m = typeof i == "string" ? [i] : i, E = !!document.queryCommandSupported;
+                      return m.forEach(function(L) {
+                        E = E && !!document.queryCommandSupported(L);
+                      }), E;
+                    }
+                  }]), l;
+                }(a()), le = ie;
+              }
+            ),
+            /***/
+            828: (
+              /***/
+              function(s) {
+                var n = 9;
+                if (typeof Element < "u" && !Element.prototype.matches) {
+                  var t = Element.prototype;
+                  t.matches = t.matchesSelector || t.mozMatchesSelector || t.msMatchesSelector || t.oMatchesSelector || t.webkitMatchesSelector;
+                }
+                function o(a, d) {
+                  for (; a && a.nodeType !== n; ) {
+                    if (typeof a.matches == "function" && a.matches(d))
+                      return a;
+                    a = a.parentNode;
+                  }
+                }
+                s.exports = o;
+              }
+            ),
+            /***/
+            438: (
+              /***/
+              function(s, n, t) {
+                var o = t(828);
+                function a(b, w, v, x, h) {
+                  var C = j.apply(this, arguments);
+                  return b.addEventListener(v, C, h), {
+                    destroy: function() {
+                      b.removeEventListener(v, C, h);
+                    }
+                  };
+                }
+                function d(b, w, v, x, h) {
+                  return typeof b.addEventListener == "function" ? a.apply(null, arguments) : typeof v == "function" ? a.bind(null, document).apply(null, arguments) : (typeof b == "string" && (b = document.querySelectorAll(b)), Array.prototype.map.call(b, function(C) {
+                    return a(C, w, v, x, h);
+                  }));
+                }
+                function j(b, w, v, x) {
+                  return function(h) {
+                    h.delegateTarget = o(h.target, w), h.delegateTarget && x.call(b, h);
+                  };
+                }
+                s.exports = d;
+              }
+            ),
+            /***/
+            879: (
+              /***/
+              function(s, n) {
+                n.node = function(t) {
+                  return t !== void 0 && t instanceof HTMLElement && t.nodeType === 1;
+                }, n.nodeList = function(t) {
+                  var o = Object.prototype.toString.call(t);
+                  return t !== void 0 && (o === "[object NodeList]" || o === "[object HTMLCollection]") && "length" in t && (t.length === 0 || n.node(t[0]));
+                }, n.string = function(t) {
+                  return typeof t == "string" || t instanceof String;
+                }, n.fn = function(t) {
+                  var o = Object.prototype.toString.call(t);
+                  return o === "[object Function]";
+                };
+              }
+            ),
+            /***/
+            370: (
+              /***/
+              function(s, n, t) {
+                var o = t(879), a = t(438);
+                function d(v, x, h) {
+                  if (!v && !x && !h)
+                    throw new Error("Missing required arguments");
+                  if (!o.string(x))
+                    throw new TypeError("Second argument must be a String");
+                  if (!o.fn(h))
+                    throw new TypeError("Third argument must be a Function");
+                  if (o.node(v))
+                    return j(v, x, h);
+                  if (o.nodeList(v))
+                    return b(v, x, h);
+                  if (o.string(v))
+                    return w(v, x, h);
+                  throw new TypeError("First argument must be a String, HTMLElement, HTMLCollection, or NodeList");
+                }
+                function j(v, x, h) {
+                  return v.addEventListener(x, h), {
+                    destroy: function() {
+                      v.removeEventListener(x, h);
+                    }
+                  };
+                }
+                function b(v, x, h) {
+                  return Array.prototype.forEach.call(v, function(C) {
+                    C.addEventListener(x, h);
+                  }), {
+                    destroy: function() {
+                      Array.prototype.forEach.call(v, function(C) {
+                        C.removeEventListener(x, h);
+                      });
+                    }
+                  };
+                }
+                function w(v, x, h) {
+                  return a(document.body, v, x, h);
+                }
+                s.exports = d;
+              }
+            ),
+            /***/
+            817: (
+              /***/
+              function(s) {
+                function n(t) {
+                  var o;
+                  if (t.nodeName === "SELECT")
+                    t.focus(), o = t.value;
+                  else if (t.nodeName === "INPUT" || t.nodeName === "TEXTAREA") {
+                    var a = t.hasAttribute("readonly");
+                    a || t.setAttribute("readonly", ""), t.select(), t.setSelectionRange(0, t.value.length), a || t.removeAttribute("readonly"), o = t.value;
+                  } else {
+                    t.hasAttribute("contenteditable") && t.focus();
+                    var d = window.getSelection(), j = document.createRange();
+                    j.selectNodeContents(t), d.removeAllRanges(), d.addRange(j), o = d.toString();
+                  }
+                  return o;
+                }
+                s.exports = n;
+              }
+            ),
+            /***/
+            279: (
+              /***/
+              function(s) {
+                function n() {
+                }
+                n.prototype = {
+                  on: function(t, o, a) {
+                    var d = this.e || (this.e = {});
+                    return (d[t] || (d[t] = [])).push({
+                      fn: o,
+                      ctx: a
+                    }), this;
+                  },
+                  once: function(t, o, a) {
+                    var d = this;
+                    function j() {
+                      d.off(t, j), o.apply(a, arguments);
+                    }
+                    return j._ = o, this.on(t, j, a);
+                  },
+                  emit: function(t) {
+                    var o = [].slice.call(arguments, 1), a = ((this.e || (this.e = {}))[t] || []).slice(), d = 0, j = a.length;
+                    for (d; d < j; d++)
+                      a[d].fn.apply(a[d].ctx, o);
+                    return this;
+                  },
+                  off: function(t, o) {
+                    var a = this.e || (this.e = {}), d = a[t], j = [];
+                    if (d && o)
+                      for (var b = 0, w = d.length; b < w; b++)
+                        d[b].fn !== o && d[b].fn._ !== o && j.push(d[b]);
+                    return j.length ? a[t] = j : delete a[t], this;
+                  }
+                }, s.exports = n, s.exports.TinyEmitter = n;
+              }
+            )
+            /******/
+          }, p = {};
+          function f(s) {
+            if (p[s])
+              return p[s].exports;
+            var n = p[s] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            return c[s](n, n.exports, f), n.exports;
+          }
+          return function() {
+            f.n = function(s) {
+              var n = s && s.__esModule ? (
+                /******/
+                function() {
+                  return s.default;
+                }
+              ) : (
+                /******/
+                function() {
+                  return s;
+                }
+              );
+              return f.d(n, { a: n }), n;
+            };
+          }(), function() {
+            f.d = function(s, n) {
+              for (var t in n)
+                f.o(n, t) && !f.o(s, t) && Object.defineProperty(s, t, { enumerable: !0, get: n[t] });
+            };
+          }(), function() {
+            f.o = function(s, n) {
+              return Object.prototype.hasOwnProperty.call(s, n);
+            };
+          }(), f(686);
+        }().default
+      );
+    });
+  }(H)), H.exports;
+}
+var Ae = Oe();
+const Me = /* @__PURE__ */ _e(Ae), Ve = function(e, y) {
+  let c = Date.now(), p;
+  return (...f) => {
+    Date.now() - c < y && p && clearTimeout(p), p = setTimeout(() => {
+      e(...f);
+    }, y), c = Date.now();
+  };
+}, Be = T({
+  name: "JsonViewer",
+  components: {
+    JsonBox: I
+  },
+  props: {
+    value: {
+      type: [Object, Array, String, Number, Boolean, Function],
+      required: !0
+    },
+    expanded: {
+      type: Boolean,
+      default: !1
+    },
+    expandDepth: {
+      type: Number,
+      default: 1
+    },
+    copyable: {
+      type: [Boolean, Object],
+      default: !1
+    },
+    sort: {
+      type: Boolean,
+      default: !1
+    },
+    boxed: {
+      type: Boolean,
+      default: !1
+    },
+    theme: {
+      type: String,
+      default: "light"
+    },
+    timeformat: {
+      type: Function,
+      default: (e) => e.toLocaleString()
+    },
+    previewMode: {
+      type: Boolean,
+      default: !1
+    },
+    parse: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: ["onKeyClick", "copied"],
+  /**
+   * Setup function for the JsonViewer component.
+   * @param props - The component's props.
+   * @param context - The setup context, including `emit`.
+   */
+  setup(e, { emit: y }) {
+    const c = k(!1), p = k(!1), f = k(e.expanded), s = k(null), n = k(null);
+    q("expandDepth", e.expandDepth), q("timeformat", e.timeformat), q("keyClick", (v) => {
+      y("onKeyClick", v);
+    });
+    const t = O(() => "jv-container jv-" + e.theme + (e.boxed ? " boxed" : "")), o = O(() => {
+      if (typeof e.copyable == "boolean" && !e.copyable)
+        return { copyText: "copy", copiedText: "copied!", timeout: 2e3, align: "right" };
+      const v = e.copyable;
+      return {
+        copyText: v.copyText || "copy",
+        copiedText: v.copiedText || "copied!",
+        timeout: v.timeout || 2e3,
+        align: v.align || "right"
+      };
+    }), a = O(() => {
+      if (!e.parse || typeof e.value != "string")
+        return e.value;
+      try {
+        return JSON.parse(e.value);
+      } catch {
+        return e.value;
+      }
+    }), d = () => {
+      j();
+    }, j = Ve(() => {
+      se(() => {
+        n.value && (n.value.$el.clientHeight >= 250 ? p.value = !0 : p.value = !1);
+      });
+    }, 200), b = (v) => {
+      c.value || (c.value = !0, setTimeout(() => {
+        c.value = !1;
+      }, o.value.timeout), y("copied", v));
+    }, w = () => {
+      f.value = !f.value;
+    };
+    return F(() => e.value, () => {
+      d();
+    }), J(() => {
+      e.boxed && n.value && (d(), n.value.$el.addEventListener("resized", d, !0)), e.copyable && s.value && new Me(s.value, {
+        text: () => JSON.stringify(a.value, null, 2)
+        // Use parseValue for copying
+      }).on("success", b);
+    }), {
+      clip: s,
+      jsonBox: n,
+      copied: c,
+      expandableCode: p,
+      expandCode: f,
+      jvClass: t,
+      copyText: o,
+      parseValue: a,
+      toggleExpandCode: w
+      // Methods are already bound or don't need explicit exposure if not used in template
+      // onResized, // only called internally
+      // debResized, // only called internally
+      // onCopied, // only called internally
+    };
+  }
+}), Le = (e, y) => {
+  const c = e.__vccOpts || e;
+  for (const [p, f] of y)
+    c[p] = f;
+  return c;
+};
+function Re(e, y, c, p, f, s) {
+  const n = ce("json-box");
+  return _(), N("div", {
+    class: S(e.jvClass)
+  }, [
+    e.copyable ? (_(), N("div", {
+      key: 0,
+      class: S(`jv-tooltip ${e.copyText.align || "right"}`)
+    }, [
+      z("span", {
+        ref: "clip",
+        class: S(["jv-button", { copied: e.copied }])
+      }, [
+        pe(e.$slots, "copy", { copied: e.copied }, () => [
+          de(A(e.copied ? e.copyText.copiedText : e.copyText.copyText), 1)
+        ])
+      ], 2)
+    ], 2)) : Y("", !0),
+    z("div", {
+      class: S(["jv-code", { open: e.expandCode, boxed: e.boxed }])
+    }, [
+      fe(n, {
+        ref: "jsonBox",
+        value: e.parseValue,
+        sort: e.sort,
+        "preview-mode": e.previewMode
+      }, null, 8, ["value", "sort", "preview-mode"])
+    ], 2),
+    e.expandableCode && e.boxed ? (_(), N("div", {
+      key: 1,
+      class: "jv-more",
+      onClick: y[0] || (y[0] = (...t) => e.toggleExpandCode && e.toggleExpandCode(...t))
+    }, [
+      z("span", {
+        class: S(["jv-toggle", { open: !!e.expandCode }])
+      }, null, 2)
+    ])) : Y("", !0)
+  ], 2);
+}
+const Pe = /* @__PURE__ */ Le(Be, [["render", Re]]);
+export {
+  Pe as JsonViewer
+};