@datagouv/components-next 0.0.8 → 0.0.9

package/dist/vue3-json-viewer-DIQzFF6K.js

@@ -0,0 +1,1089 @@
+import { d as T, D as ce, b as _, f as N, y as Y, g as P, E as S, h as pe, A as fe, t as O, q as de, r as k, G as z, c as A, w as J, e as I, H, I as g, n as ve } from "./main-CLUk9Jj7.js";
+const ye = /^([hH][tT]{2}[pP]:\/\/|[hH][tT]{2}[pP][sS]:\/\/)(([A-Za-z0-9-~]+)\.)+([A-Za-z0-9-~\/])+$/, G = 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), d = k(null);
+    I(() => {
+      p.value && d.value && p.value.offsetHeight > d.value.offsetHeight && (c.value = !0);
+    });
+    const i = () => {
+      y.value = !y.value;
+    };
+    return () => {
+      const n = e.jsonValue, t = ye.test(n);
+      let o;
+      !y.value && c.value ? o = g("span", {
+        class: { "jv-ellipsis": !0 },
+        onClick: i
+      }, "...") : 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: i
+      })), a.push(g("span", { class: { "jv-holder-node": !0 }, ref: d })), a.push(o), g("span", {}, a);
+    };
+  }
+}), me = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-undefined"])
+}, he = /* @__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 = A(() => y.jsonValue === null ? "null" : "undefined");
+    return (p, d) => (N(), _("span", me, O(c.value), 1));
+  }
+}), ge = /* @__PURE__ */ T({
+  __name: "json-number",
+  props: {
+    /** The number value to display. */
+    jsonValue: {
+      type: Number,
+      required: !0
+    }
+  },
+  setup(e) {
+    const y = e, c = A(() => Number.isInteger(y.jsonValue));
+    return (p, d) => (N(), _("span", {
+      class: S(["jv-item", "jv-number", c.value ? "jv-number-integer" : "jv-number-float"])
+    }, O(e.jsonValue.toString()), 3));
+  }
+}), be = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-boolean"])
+}, je = /* @__PURE__ */ T({
+  __name: "json-boolean",
+  props: {
+    /** The boolean value to display. */
+    jsonValue: {
+      type: Boolean,
+      required: !0
+    }
+  },
+  setup(e) {
+    return (y, c) => (N(), _("span", be, O(e.jsonValue.toString()), 1));
+  }
+}), xe = 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 d = (o) => {
+      setTimeout(() => {
+        c.value = o;
+      }, 0);
+    };
+    J(() => e.jsonValue, (o) => {
+      d(o);
+    }, { immediate: !0, deep: !0 });
+    const i = A(() => {
+      if (!e.sort)
+        return c.value;
+      const o = Object.keys(c.value).sort(), a = {};
+      return o.forEach((f) => {
+        a[f] = c.value[f];
+      }), 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 i.value)
+          if (i.value.hasOwnProperty(a)) {
+            const f = i.value[a];
+            o.push(g(F, {
+              key: a,
+              // style: { display: !props.expand ? 'none' : undefined }, // Redundant
+              sort: e.sort,
+              keyName: a,
+              depth: e.depth + 1,
+              value: f,
+              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(i.value).join(", ")})`
+      }, "...")), o.push(g("span", { class: ["jv-item", "jv-object"] }, "}")), g("span", { ref: (a) => {
+        p = a;
+      } }, o);
+    };
+  }
+}), Ee = 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 d = (n, t = 0) => {
+      t === 0 && (c.value = []), setTimeout(() => {
+        n && n.length > t && (c.value.push(n[t]), d(n, t + 1));
+      }, 0);
+    };
+    J(() => e.jsonValue, (n) => {
+      d(n);
+    }, { immediate: !0, deep: !0 });
+    const i = () => {
+      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: i
+      })), n.push(g("span", {
+        class: ["jv-item", "jv-array"]
+      }, "[")), e.expand && c.value.forEach((t, o) => {
+        n.push(g(F, {
+          // 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: i,
+        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);
+    };
+  }
+}), we = ["title"], ke = /* @__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, we));
+  }
+}), Se = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-string"])
+}, Te = /* @__PURE__ */ T({
+  __name: "json-date",
+  props: {
+    /** The Date object to display. */
+    jsonValue: {
+      type: Date,
+      required: !0
+    }
+  },
+  setup(e) {
+    const y = e, c = H("timeformat", (d) => d.toLocaleString()), p = A(() => c(y.jsonValue));
+    return (d, i) => (N(), _("span", Se, ' "' + O(p.value) + '" ', 1));
+  }
+}), Ce = {
+  class: /* @__PURE__ */ S(["jv-item", "jv-regexp"])
+}, _e = /* @__PURE__ */ T({
+  __name: "json-regexp",
+  props: {
+    /** The RegExp object to display. */
+    jsonValue: {
+      type: RegExp,
+      required: !0
+    }
+  },
+  setup(e) {
+    return (y, c) => (N(), _("span", Ce, O(e.jsonValue.toString()), 1));
+  }
+}), F = 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 = H("expandDepth", 1 / 0), c = H("keyClick", () => {
+    }), p = k(!0);
+    let d = null;
+    I(() => {
+      p.value = e.previewMode || e.depth < y;
+    });
+    const i = () => {
+      if (p.value = !p.value, d)
+        try {
+          d.dispatchEvent(new Event("resized"));
+        } catch {
+          const n = document.createEvent("Event");
+          n.initEvent("resized", !0, !1), d.dispatchEvent(n);
+        }
+    };
+    return () => {
+      const n = [];
+      let t;
+      e.value === null || e.value === void 0 ? t = he : Array.isArray(e.value) ? t = Ee : e.value instanceof Date ? t = Te : e.value instanceof RegExp ? t = _e : typeof e.value == "object" ? t = xe : typeof e.value == "number" ? t = ge : typeof e.value == "string" ? t = G : typeof e.value == "boolean" ? t = je : typeof e.value == "function" ? t = ke : t = G;
+      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: i
+        })
+      ), 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) => {
+            d = a;
+          }
+        },
+        n
+      );
+    };
+  }
+});
+function Ne(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var $ = { exports: {} };
+/*!
+ * clipboard.js v2.0.11
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+var Ae = $.exports, X;
+function Oe() {
+  return X || (X = 1, function(e, y) {
+    (function(c, p) {
+      e.exports = p();
+    })(Ae, function() {
+      return (
+        /******/
+        function() {
+          var c = {
+            /***/
+            686: (
+              /***/
+              function(i, n, t) {
+                t.d(n, {
+                  default: function() {
+                    return (
+                      /* binding */
+                      ie
+                    );
+                  }
+                });
+                var o = t(279), a = /* @__PURE__ */ t.n(o), f = t(370), j = /* @__PURE__ */ t.n(f), 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 s = window.pageYOffset || document.documentElement.scrollTop;
+                  return l.style.top = "".concat(s, "px"), l.setAttribute("readonly", ""), l.value = u, l;
+                }
+                var K = function(u, r) {
+                  var l = C(u);
+                  r.container.appendChild(l);
+                  var s = w()(l);
+                  return v("copy"), l.remove(), s;
+                }, Q = 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 = Q;
+                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 W = function() {
+                  var u = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, r = u.action, l = r === void 0 ? "copy" : r, s = 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: s
+                    });
+                  if (m)
+                    return l === "cut" ? h(m) : R(m, {
+                      container: s
+                    });
+                }, ee = W;
+                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 te(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 s = r[l];
+                    s.enumerable = s.enumerable || !1, s.configurable = !0, "value" in s && (s.writable = !0), Object.defineProperty(u, s.key, s);
+                  }
+                }
+                function ne(u, r, l) {
+                  return r && U(u.prototype, r), l && U(u, l), u;
+                }
+                function oe(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, s) {
+                    return l.__proto__ = s, l;
+                  }, D(u, r);
+                }
+                function re(u) {
+                  var r = se();
+                  return function() {
+                    var l = B(u), s;
+                    if (r) {
+                      var m = B(this).constructor;
+                      s = Reflect.construct(l, arguments, m);
+                    } else
+                      s = l.apply(this, arguments);
+                    return ae(this, s);
+                  };
+                }
+                function ae(u, r) {
+                  return r && (M(r) === "object" || typeof r == "function") ? r : ue(u);
+                }
+                function ue(u) {
+                  if (u === void 0)
+                    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+                  return u;
+                }
+                function se() {
+                  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 q(u, r) {
+                  var l = "data-clipboard-".concat(u);
+                  if (r.hasAttribute(l))
+                    return r.getAttribute(l);
+                }
+                var le = /* @__PURE__ */ function(u) {
+                  oe(l, u);
+                  var r = re(l);
+                  function l(s, m) {
+                    var E;
+                    return te(this, l), E = r.call(this), E.resolveOptions(m), E.listenClick(s), E;
+                  }
+                  return ne(l, [{
+                    key: "resolveOptions",
+                    value: function() {
+                      var s = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+                      this.action = typeof s.action == "function" ? s.action : this.defaultAction, this.target = typeof s.target == "function" ? s.target : this.defaultTarget, this.text = typeof s.text == "function" ? s.text : this.defaultText, this.container = M(s.container) === "object" ? s.container : document.body;
+                    }
+                    /**
+                     * Adds a click event listener to the passed trigger.
+                     * @param {String|HTMLElement|HTMLCollection|NodeList} trigger
+                     */
+                  }, {
+                    key: "listenClick",
+                    value: function(s) {
+                      var m = this;
+                      this.listener = j()(s, "click", function(E) {
+                        return m.onClick(E);
+                      });
+                    }
+                    /**
+                     * Defines a new `ClipboardAction` on each click event.
+                     * @param {Event} e
+                     */
+                  }, {
+                    key: "onClick",
+                    value: function(s) {
+                      var m = s.delegateTarget || s.currentTarget, E = this.action(m) || "copy", L = ee({
+                        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(s) {
+                      return q("action", s);
+                    }
+                    /**
+                     * Default `target` lookup function.
+                     * @param {Element} trigger
+                     */
+                  }, {
+                    key: "defaultTarget",
+                    value: function(s) {
+                      var m = q("target", s);
+                      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(s) {
+                      return q("text", s);
+                    }
+                    /**
+                     * Destroy lifecycle.
+                     */
+                  }, {
+                    key: "destroy",
+                    value: function() {
+                      this.listener.destroy();
+                    }
+                  }], [{
+                    key: "copy",
+                    value: function(s) {
+                      var m = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+                        container: document.body
+                      };
+                      return R(s, m);
+                    }
+                    /**
+                     * Allow fire programmatically a cut action
+                     * @param {String|HTMLElement} target
+                     * @returns Text cutted.
+                     */
+                  }, {
+                    key: "cut",
+                    value: function(s) {
+                      return h(s);
+                    }
+                    /**
+                     * Returns the support of the given action, or all actions if no action is
+                     * given.
+                     * @param {String} [action]
+                     */
+                  }, {
+                    key: "isSupported",
+                    value: function() {
+                      var s = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : ["copy", "cut"], m = typeof s == "string" ? [s] : s, E = !!document.queryCommandSupported;
+                      return m.forEach(function(L) {
+                        E = E && !!document.queryCommandSupported(L);
+                      }), E;
+                    }
+                  }]), l;
+                }(a()), ie = le;
+              }
+            ),
+            /***/
+            828: (
+              /***/
+              function(i) {
+                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, f) {
+                  for (; a && a.nodeType !== n; ) {
+                    if (typeof a.matches == "function" && a.matches(f))
+                      return a;
+                    a = a.parentNode;
+                  }
+                }
+                i.exports = o;
+              }
+            ),
+            /***/
+            438: (
+              /***/
+              function(i, 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 f(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);
+                  };
+                }
+                i.exports = f;
+              }
+            ),
+            /***/
+            879: (
+              /***/
+              function(i, 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(i, n, t) {
+                var o = t(879), a = t(438);
+                function f(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);
+                }
+                i.exports = f;
+              }
+            ),
+            /***/
+            817: (
+              /***/
+              function(i) {
+                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 f = window.getSelection(), j = document.createRange();
+                    j.selectNodeContents(t), f.removeAllRanges(), f.addRange(j), o = f.toString();
+                  }
+                  return o;
+                }
+                i.exports = n;
+              }
+            ),
+            /***/
+            279: (
+              /***/
+              function(i) {
+                function n() {
+                }
+                n.prototype = {
+                  on: function(t, o, a) {
+                    var f = this.e || (this.e = {});
+                    return (f[t] || (f[t] = [])).push({
+                      fn: o,
+                      ctx: a
+                    }), this;
+                  },
+                  once: function(t, o, a) {
+                    var f = this;
+                    function j() {
+                      f.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(), f = 0, j = a.length;
+                    for (f; f < j; f++)
+                      a[f].fn.apply(a[f].ctx, o);
+                    return this;
+                  },
+                  off: function(t, o) {
+                    var a = this.e || (this.e = {}), f = a[t], j = [];
+                    if (f && o)
+                      for (var b = 0, w = f.length; b < w; b++)
+                        f[b].fn !== o && f[b].fn._ !== o && j.push(f[b]);
+                    return j.length ? a[t] = j : delete a[t], this;
+                  }
+                }, i.exports = n, i.exports.TinyEmitter = n;
+              }
+            )
+            /******/
+          }, p = {};
+          function d(i) {
+            if (p[i])
+              return p[i].exports;
+            var n = p[i] = {
+              /******/
+              // no module.id needed
+              /******/
+              // no module.loaded needed
+              /******/
+              exports: {}
+              /******/
+            };
+            return c[i](n, n.exports, d), n.exports;
+          }
+          return function() {
+            d.n = function(i) {
+              var n = i && i.__esModule ? (
+                /******/
+                function() {
+                  return i.default;
+                }
+              ) : (
+                /******/
+                function() {
+                  return i;
+                }
+              );
+              return d.d(n, { a: n }), n;
+            };
+          }(), function() {
+            d.d = function(i, n) {
+              for (var t in n)
+                d.o(n, t) && !d.o(i, t) && Object.defineProperty(i, t, { enumerable: !0, get: n[t] });
+            };
+          }(), function() {
+            d.o = function(i, n) {
+              return Object.prototype.hasOwnProperty.call(i, n);
+            };
+          }(), d(686);
+        }().default
+      );
+    });
+  }($)), $.exports;
+}
+var Me = Oe();
+const Ve = /* @__PURE__ */ Ne(Me), Be = function(e, y) {
+  let c = Date.now(), p;
+  return (...d) => {
+    Date.now() - c < y && p && clearTimeout(p), p = setTimeout(() => {
+      e(...d);
+    }, y), c = Date.now();
+  };
+}, Le = T({
+  name: "JsonViewer",
+  components: {
+    JsonBox: F
+  },
+  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), d = k(e.expanded), i = k(null), n = k(null);
+    z("expandDepth", e.expandDepth), z("timeformat", e.timeformat), z("keyClick", (v) => {
+      y("onKeyClick", v);
+    });
+    const t = A(() => "jv-container jv-" + e.theme + (e.boxed ? " boxed" : "")), o = A(() => {
+      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 = A(() => {
+      if (!e.parse || typeof e.value != "string")
+        return e.value;
+      try {
+        return JSON.parse(e.value);
+      } catch {
+        return e.value;
+      }
+    }), f = () => {
+      j();
+    }, j = Be(() => {
+      ve(() => {
+        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 = () => {
+      d.value = !d.value;
+    };
+    return J(() => e.value, () => {
+      f();
+    }), I(() => {
+      e.boxed && n.value && (f(), n.value.$el.addEventListener("resized", f, !0)), e.copyable && i.value && new Ve(i.value, {
+        text: () => JSON.stringify(a.value, null, 2)
+        // Use parseValue for copying
+      }).on("success", b);
+    }), {
+      clip: i,
+      jsonBox: n,
+      copied: c,
+      expandableCode: p,
+      expandCode: d,
+      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
+    };
+  }
+}), Re = (e, y) => {
+  const c = e.__vccOpts || e;
+  for (const [p, d] of y)
+    c[p] = d;
+  return c;
+};
+function De(e, y, c, p, d, i) {
+  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"}`)
+    }, [
+      P("span", {
+        ref: "clip",
+        class: S(["jv-button", { copied: e.copied }])
+      }, [
+        pe(e.$slots, "copy", { copied: e.copied }, () => [
+          fe(O(e.copied ? e.copyText.copiedText : e.copyText.copyText), 1)
+        ])
+      ], 2)
+    ], 2)) : Y("", !0),
+    P("div", {
+      class: S(["jv-code", { open: e.expandCode, boxed: e.boxed }])
+    }, [
+      de(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))
+    }, [
+      P("span", {
+        class: S(["jv-toggle", { open: !!e.expandCode }])
+      }, null, 2)
+    ])) : Y("", !0)
+  ], 2);
+}
+const Z = /* @__PURE__ */ Re(Le, [["render", De]]), qe = (e) => {
+  e.component(Z.name, Z);
+}, ze = {
+  install: qe
+};
+export {
+  Z as JsonViewer,
+  ze as default
+};