@dynamix-layout/core 1.0.1 → 1.1.0

package/dist/core.es.js

@@ -1,12 +1,12 @@
-class N {
+class b {
   buffer;
   head = 0;
   tail = 0;
   count = 0;
   capacity;
   constructor(t = 16, e = []) {
-    this.capacity = Math.max(t, e.length), this.buffer = new Array(this.capacity), e.forEach((i) => {
-      this.enqueue(i);
+    this.capacity = Math.max(t, e.length), this.buffer = new Array(this.capacity), e.forEach((n) => {
+      this.enqueue(n);
     });
   }
   enqueue(t) {
@@ -23,8 +23,8 @@ class N {
     if (t === this.count)
       return this.enqueue(e), !0;
     this.count === this.capacity && this.resize();
-    const i = t, n = this.count - t;
-    return i <= n ? this.shiftLeft(t, e) : this.shiftRight(t, e), this.count++, !0;
+    const n = t, i = this.count - t;
+    return n <= i ? this.shiftLeft(t, e) : this.shiftRight(t, e), this.count++, !0;
   }
   insertArray(t, e) {
     if (t < 0 || t > this.count)
@@ -32,38 +32,38 @@ class N {
     if (e.length === 0)
       return !0;
     if (t === 0) {
-      for (let d = e.length - 1; d >= 0; d--)
-        this.enqueueFront(e[d]);
+      for (let r = e.length - 1; r >= 0; r--)
+        this.enqueueFront(e[r]);
       return !0;
     }
     if (t === this.count)
-      return e.forEach((d) => this.enqueue(d)), !0;
+      return e.forEach((r) => this.enqueue(r)), !0;
     for (; this.count + e.length > this.capacity; )
       this.resize();
-    const i = t, n = this.count - t, s = e.length;
-    return i <= n ? this.shiftLeftArray(t, e) : this.shiftRightArray(t, e), this.count += s, !0;
+    const n = t, i = this.count - t, s = e.length;
+    return n <= i ? this.shiftLeftArray(t, e) : this.shiftRightArray(t, e), this.count += s, !0;
   }
   insertQueue(t, e) {
     if (t < 0 || t > this.count)
       return !1;
     if (e.isEmpty())
       return !0;
-    const i = e.size();
+    const n = e.size();
     if (t === 0) {
-      const o = e.toArray();
-      for (let h = o.length - 1; h >= 0; h--)
-        this.enqueueFront(o[h]);
+      const c = e.toArray();
+      for (let d = c.length - 1; d >= 0; d--)
+        this.enqueueFront(c[d]);
       return !0;
     }
     if (t === this.count) {
-      for (const o of e)
-        this.enqueue(o);
+      for (const c of e)
+        this.enqueue(c);
       return !0;
     }
-    for (; this.count + i > this.capacity; )
+    for (; this.count + n > this.capacity; )
       this.resize();
-    const n = e.toArray(), s = t, d = this.count - t;
-    return s <= d ? this.shiftLeftArray(t, n) : this.shiftRightArray(t, n), this.count += i, !0;
+    const i = e.toArray(), s = t, r = this.count - t;
+    return s <= r ? this.shiftLeftArray(t, i) : this.shiftRightArray(t, i), this.count += n, !0;
   }
   push(t) {
     this.enqueue(t);
@@ -86,8 +86,8 @@ class N {
   }
   indexOf(t) {
     for (let e = 0; e < this.count; e++) {
-      const i = (this.head + e) % this.capacity;
-      if (this.buffer[i] === t)
+      const n = (this.head + e) % this.capacity;
+      if (this.buffer[n] === t)
         return e;
     }
     return -1;
@@ -103,8 +103,8 @@ class N {
       return this.dequeue();
     if (t === this.count - 1)
       return this.dequeueBack();
-    const e = (this.head + t) % this.capacity, i = this.buffer[e], n = t, s = this.count - t - 1;
-    return n <= s ? this.shiftRightForRemoval(t) : this.shiftLeftForRemoval(t), this.count--, i;
+    const e = (this.head + t) % this.capacity, n = this.buffer[e], i = t, s = this.count - t - 1;
+    return i <= s ? this.shiftRightForRemoval(t) : this.shiftLeftForRemoval(t), this.count--, n;
   }
   shift() {
     return this.dequeue();
@@ -145,8 +145,8 @@ class N {
   set(t, e) {
     if (t < 0 || t >= this.count)
       return !1;
-    const i = (this.head + t) % this.capacity;
-    return this.buffer[i] = e, !0;
+    const n = (this.head + t) % this.capacity;
+    return this.buffer[n] = e, !0;
   }
   peek() {
     return this.count > 0 ? this.buffer[this.head] : void 0;
@@ -180,8 +180,8 @@ class N {
   toArray() {
     const t = [];
     for (let e = 0; e < this.count; e++) {
-      const i = (this.head + e) % this.capacity;
-      t.push(this.buffer[i]);
+      const n = (this.head + e) % this.capacity;
+      t.push(this.buffer[n]);
     }
     return t;
   }
@@ -224,137 +224,150 @@ class N {
   }
   resize() {
     const t = this.capacity * 2, e = new Array(t);
-    for (let i = 0; i < this.count; i++) {
-      const n = (this.head + i) % this.capacity;
-      e[i] = this.buffer[n];
+    for (let n = 0; n < this.count; n++) {
+      const i = (this.head + n) % this.capacity;
+      e[n] = this.buffer[i];
     }
     this.buffer = e, this.capacity = t, this.head = 0, this.tail = this.count;
   }
   shiftLeft(t, e) {
     this.head = (this.head - 1 + this.capacity) % this.capacity;
-    for (let n = 0; n < t; n++) {
-      const s = (this.head + 1 + n) % this.capacity, d = (this.head + n) % this.capacity;
-      this.buffer[d] = this.buffer[s];
+    for (let i = 0; i < t; i++) {
+      const s = (this.head + 1 + i) % this.capacity, r = (this.head + i) % this.capacity;
+      this.buffer[r] = this.buffer[s];
     }
-    const i = (this.head + t) % this.capacity;
-    this.buffer[i] = e;
+    const n = (this.head + t) % this.capacity;
+    this.buffer[n] = e;
   }
   shiftRight(t, e) {
-    for (let n = this.count - 1; n >= t; n--) {
-      const s = (this.head + n) % this.capacity, d = (this.head + n + 1) % this.capacity;
-      this.buffer[d] = this.buffer[s];
+    for (let i = this.count - 1; i >= t; i--) {
+      const s = (this.head + i) % this.capacity, r = (this.head + i + 1) % this.capacity;
+      this.buffer[r] = this.buffer[s];
     }
-    const i = (this.head + t) % this.capacity;
-    this.buffer[i] = e, this.tail = (this.tail + 1) % this.capacity;
+    const n = (this.head + t) % this.capacity;
+    this.buffer[n] = e, this.tail = (this.tail + 1) % this.capacity;
   }
   shiftRightForRemoval(t) {
     for (let e = t; e > 0; e--) {
-      const i = (this.head + e - 1) % this.capacity, n = (this.head + e) % this.capacity;
-      this.buffer[n] = this.buffer[i];
+      const n = (this.head + e - 1) % this.capacity, i = (this.head + e) % this.capacity;
+      this.buffer[i] = this.buffer[n];
     }
     this.head = (this.head + 1) % this.capacity;
   }
   shiftLeftForRemoval(t) {
     for (let e = t; e < this.count - 1; e++) {
-      const i = (this.head + e + 1) % this.capacity, n = (this.head + e) % this.capacity;
-      this.buffer[n] = this.buffer[i];
+      const n = (this.head + e + 1) % this.capacity, i = (this.head + e) % this.capacity;
+      this.buffer[i] = this.buffer[n];
     }
     this.tail = (this.tail - 1 + this.capacity) % this.capacity;
   }
   shiftLeftArray(t, e) {
-    const i = e.length;
-    this.head = (this.head - i + this.capacity) % this.capacity;
-    for (let n = 0; n < t; n++) {
-      const s = (this.head + i + n) % this.capacity, d = (this.head + n) % this.capacity;
-      this.buffer[d] = this.buffer[s];
+    const n = e.length;
+    this.head = (this.head - n + this.capacity) % this.capacity;
+    for (let i = 0; i < t; i++) {
+      const s = (this.head + n + i) % this.capacity, r = (this.head + i) % this.capacity;
+      this.buffer[r] = this.buffer[s];
     }
-    for (let n = 0; n < i; n++) {
-      const s = (this.head + t + n) % this.capacity;
-      this.buffer[s] = e[n];
+    for (let i = 0; i < n; i++) {
+      const s = (this.head + t + i) % this.capacity;
+      this.buffer[s] = e[i];
     }
   }
   shiftRightArray(t, e) {
-    const i = e.length;
-    for (let n = this.count - 1; n >= t; n--) {
-      const s = (this.head + n) % this.capacity, d = (this.head + n + i) % this.capacity;
-      this.buffer[d] = this.buffer[s];
+    const n = e.length;
+    for (let i = this.count - 1; i >= t; i--) {
+      const s = (this.head + i) % this.capacity, r = (this.head + i + n) % this.capacity;
+      this.buffer[r] = this.buffer[s];
     }
-    for (let n = 0; n < i; n++) {
-      const s = (this.head + t + n) % this.capacity;
-      this.buffer[s] = e[n];
+    for (let i = 0; i < n; i++) {
+      const s = (this.head + t + i) % this.capacity;
+      this.buffer[s] = e[i];
     }
-    this.tail = (this.tail + i) % this.capacity;
+    this.tail = (this.tail + n) % this.capacity;
   }
 }
-function g(I, t = (e, i) => e === i) {
-  let e = I;
-  const i = /* @__PURE__ */ new Set();
-  let n = [];
-  const s = () => e, d = (l, f = !1) => {
-    if (f) {
-      e = l;
+function x(o, t = (e, n) => e === n) {
+  let e = o;
+  const n = /* @__PURE__ */ new Set();
+  let i = [];
+  const s = () => e, r = (f, m = !1) => {
+    if (m) {
+      e = f;
       return;
     }
-    t(e, l) || (e = l, i.forEach((m) => m(e)), n.forEach((m) => m(e)), n = []);
-  }, o = () => {
-    i.forEach((l) => l(e)), n.forEach((l) => l(e)), n = [];
-  }, h = (l) => (i.add(l), () => i.delete(l)), r = () => new Promise((l) => {
-    n.push(l);
+    t(e, f) || (e = f, n.forEach((p) => p(e)), i.forEach((p) => p(e)), i = []);
+  }, c = () => {
+    n.forEach((f) => f(e)), i.forEach((f) => f(e)), i = [];
+  }, d = (f) => (n.add(f), () => n.delete(f)), l = () => new Promise((f) => {
+    i.push(f);
   });
   return {
     get: s,
-    set: d,
-    onChange: h,
-    nextChange: r,
-    triggerChange: o,
-    onChangePromise: (l) => {
-      let f = !0;
+    set: r,
+    onChange: d,
+    nextChange: l,
+    triggerChange: c,
+    onChangePromise: (f) => {
+      let m = !0;
       return (async () => {
-        for (; f; ) {
-          const p = await r();
-          if (!f) break;
-          l(p);
+        for (; m; ) {
+          const I = await l();
+          if (!m) break;
+          f(I);
         }
       })(), () => {
-        f = !1;
+        m = !1;
       };
     }
   };
 }
-function E(I, t) {
-  if (I.size !== t.size) return !1;
-  for (const [e, i] of I.entries()) {
-    const n = t.get(e);
-    if (!n || !O(i, n))
+function E(o, t) {
+  if (o.size !== t.size) return !1;
+  for (const [e, n] of o.entries()) {
+    const i = t.get(e);
+    if (!i || !A(n, i))
       return !1;
   }
   return !0;
 }
-function O(I, t) {
-  if (I.typNode !== t.typNode || I.nodName !== t.nodName || I.uidNode !== t.uidNode || I.nodPart !== t.nodPart) return !1;
-  const e = I.nodDims, i = t.nodDims;
-  return e.x === i.x && e.y === i.y && e.w === i.w && e.h === i.h;
+function A(o, t) {
+  if (o.typNode !== t.typNode || o.nodName !== t.nodName || o.uidNode !== t.uidNode || o.nodPart !== t.nodPart) return !1;
+  const e = o.nodDims, n = t.nodDims;
+  return e.x === n.x && e.y === n.y && e.w === n.w && e.h === n.h;
 }
+const v = () => crypto.randomUUID(), T = {
+  set: (o, t) => setTimeout(o, t),
+  clear: (o) => clearTimeout(o)
+}, u = {
+  createId: v,
+  timer: T,
+  root: void 0,
+  tree: null,
+  minW: 40,
+  minH: 40,
+  bond: 10,
+  inst: null
+};
 class a {
   static cache = {
     dimMins: /* @__PURE__ */ new Map(),
     mapDirs: /* @__PURE__ */ new Map(),
     tabCnts: /* @__PURE__ */ new Map(),
     mapElem: /* @__PURE__ */ new Map(),
-    tabOpts: g(
+    tabOpts: x(
       /* @__PURE__ */ new Map(),
       E
     ),
-    nodOpts: g(
+    nodOpts: x(
       /* @__PURE__ */ new Map(),
       E
     ),
-    bndOpts: g(
+    bndOpts: x(
       /* @__PURE__ */ new Map(),
       E
     )
   };
-  kids = new N();
+  kids = new b();
   dims = { w: 0, h: 0, x: 0, y: 0 };
   unId;
   next = null;
@@ -371,76 +384,73 @@ class a {
       name: "",
       part: 100,
       dims: { w: 0, h: 0, x: 0, y: 0 },
-      unId: crypto.randomUUID(),
+      unId: u.createId(),
       open: ""
     };
     this.type = t.type ?? e.type, this.host = t.host ?? e.host, this.name = t.name ?? e.name, this.part = t.part ?? e.part, this.dims = t.dims ?? e.dims, this.open = t.open ?? e.open, this.unId = t.unId || e.unId;
   }
   addBond(t, e = null) {
     if (!e) return;
-    const i = new x(t, this, e);
-    a.cache.mapElem.set(i.unId, i);
+    const n = new O(t, this, e);
+    a.cache.mapElem.set(n.unId, n);
   }
   getReqDimension() {
-    const t = a.cache.dimMins.get(this.unId), e = a.cache.tabCnts.get(this.unId), i = Math.max(
+    const t = a.cache.dimMins.get(this.unId), e = a.cache.tabCnts.get(this.unId), n = Math.max(
       t.minWidth,
-      e.horizontal * c._minW + Math.max(0, e.horizontal - 1) * c._bond
-    ), n = Math.max(
+      e.horizontal * u.minW + Math.max(0, e.horizontal - 1) * u.bond
+    ), i = Math.max(
       t.minHeight,
-      e.vertical * c._minH + Math.max(0, e.vertical - 1) * c._bond
+      e.vertical * u.minH + Math.max(0, e.vertical - 1) * u.bond
     );
     return {
-      width: i,
-      height: n
+      width: n,
+      height: i
     };
   }
   calcDimensions() {
     const t = a.cache.mapDirs.get(this.unId);
     if (!this.kids) return;
     let e = 0;
-    const i = a.cache.dimMins.get(this.unId) || {
+    const n = a.cache.dimMins.get(this.unId) || {
       minWidth: 0,
       minHeight: 0
     };
-    let n = 0;
-    for (const o of this.kids)
-      e += o.part;
+    let i = 0;
+    for (const h of this.kids)
+      e += h.part;
     if (e === 0) return;
     let s;
-    t ? s = this.dims.w - i.minWidth : s = this.dims.h - i.minHeight;
-    let d = s;
-    for (const o of this.kids) {
-      const h = a.cache.dimMins.get(o.unId) || {
+    t ? s = this.dims.w - n.minWidth : s = this.dims.h - n.minHeight;
+    const r = s < 0, c = this.kids.peekBack();
+    let d = 0, l = 0;
+    for (const h of this.kids) {
+      const f = a.cache.dimMins.get(h.unId) || {
         minWidth: 0,
         minHeight: 0
       };
-      if (this.dims.w < i.minWidth)
-        t ? (o.dims.w = h.minWidth, o.dims.h = this.dims.h, o.dims.x = this.dims.x + n, o.dims.y = this.dims.y, n += o.dims.w + c._bond) : (o.dims.h = h.minHeight, o.dims.w = this.dims.w, o.dims.y = this.dims.y + n, o.dims.x = this.dims.x, n += o.dims.h + c._bond);
-      else {
-        const r = o.part / e, u = Math.floor(s * r);
-        if (o === this.kids.peekBack()) {
-          t ? (o.dims.w = h.minWidth + d, o.dims.h = this.dims.h, o.dims.x = this.dims.x + n, o.dims.y = this.dims.y, n += o.dims.w + c._bond) : (o.dims.h = h.minHeight + d, o.dims.w = this.dims.w, o.dims.y = this.dims.y + n, o.dims.x = this.dims.x, n += o.dims.h + c._bond);
-          break;
-        }
-        t ? (o.dims.w = h.minWidth + u, o.dims.h = this.dims.h, o.dims.x = this.dims.x + n, o.dims.y = this.dims.y, n += o.dims.w + c._bond) : (o.dims.h = h.minHeight + u, o.dims.w = this.dims.w, o.dims.y = this.dims.y + n, o.dims.x = this.dims.x, n += o.dims.h + c._bond), d -= u;
+      let m = 0;
+      if (!r) {
+        d += h.part;
+        const p = h === c ? s : Math.round(s * d / e);
+        m = p - l, l = p;
       }
-      o.next && (t ? o.next.dims = {
-        w: c._bond,
-        h: o.dims.h,
-        x: o.dims.x + o.dims.w,
-        y: o.dims.y
-      } : o.next.dims = {
-        w: o.dims.w,
-        h: c._bond,
-        x: o.dims.x,
-        y: o.dims.y + o.dims.h
+      t ? (h.dims.w = f.minWidth + m, h.dims.h = this.dims.h, h.dims.x = this.dims.x + i, h.dims.y = this.dims.y, i += h.dims.w + u.bond) : (h.dims.h = f.minHeight + m, h.dims.w = this.dims.w, h.dims.y = this.dims.y + i, h.dims.x = this.dims.x, i += h.dims.h + u.bond), h.next && (t ? h.next.dims = {
+        w: u.bond,
+        h: h.dims.h,
+        x: h.dims.x + h.dims.w,
+        y: h.dims.y
+      } : h.next.dims = {
+        w: h.dims.w,
+        h: u.bond,
+        x: h.dims.x,
+        y: h.dims.y + h.dims.h
       });
     }
   }
   toJSON() {
     const t = [];
-    for (const i of this.kids)
-      t.push(i.toJSON());
+    for (const n of this.kids)
+      t.push(n.toJSON());
     const e = {
       typNode: this.type,
       nodPart: this.part,
@@ -450,13 +460,493 @@ class a {
     return this.open && (e.nodOpen = this.open), t.length > 0 && (e.nodKids = t), e;
   }
 }
-class c {
-  static _root;
-  static _tree;
-  static _minW = 40;
-  static _minH = 40;
-  static _bond = 10;
-  static _inst = null;
+class O {
+  dims = { w: 0, h: 0, x: 0, y: 0 };
+  unId = u.createId();
+  next = null;
+  prev = null;
+  host = null;
+  constructor(t = null, e = null, n = null) {
+    this.host = t, this.next = e, this.prev = n, this.next && (this.next.prev = this), this.prev && (this.prev.next = this);
+  }
+  toJSON() {
+    return {
+      nodName: this.host?.name || "",
+      typNode: "bond",
+      uidNode: this.unId,
+      nodPart: 0,
+      nodOpen: "",
+      nodKids: []
+    };
+  }
+}
+function* S(o) {
+  const t = new b();
+  for (t.enqueue(o); !t.isEmpty(); ) {
+    const e = t.dequeue();
+    if (e && (yield e, e.nodKids && e.nodKids.length > 0))
+      for (const n of e.nodKids)
+        t.enqueue(n);
+  }
+}
+function* R(o) {
+  const t = new b();
+  for (t.enqueue(o); !t.isEmpty(); ) {
+    const e = t.dequeue();
+    if (e && (a.cache.mapElem.set(e.unId, e), yield e, e.kids.size() > 0))
+      for (const n of e.kids)
+        t.enqueue(n);
+  }
+}
+function* H(o, t) {
+  for (const e of t.kids)
+    yield* o.NodeLayoutRecursiveIterator(e);
+  yield t;
+}
+function q(o, t) {
+  const e = a.cache.mapDirs.get(t.unId);
+  if (e === void 0) {
+    console.warn(
+      `Cannot update child directions for node ${t.unId}; its own direction is not set.`
+    );
+    return;
+  }
+  for (const n of t.kids)
+    a.cache.mapDirs.set(n.unId, !e), n.kids.size() > 0 && (n.host = t, o.updateChildDirections(n), n.next && a.cache.mapDirs.set(n.next.unId, !e));
+}
+function B(o, t = u.tree) {
+  if (!t) return;
+  const e = o.JSONLayoutIterator(t), n = o.NodeLayoutIterator(u.root);
+  for (a.cache.mapDirs.set(u.root.unId, !0); ; ) {
+    const i = e.next(), s = n.next();
+    if (i.done || s.done)
+      break;
+    const r = i.value, c = s.value;
+    !r || !c || o.createNodeTreeFromJSONTree(r, c);
+  }
+  o.calcTabsetCountAndMinDim();
+}
+function M(o, t, e) {
+  const n = a.cache.mapDirs.get(e.unId);
+  for (const i of t.nodKids || []) {
+    const s = o.createNodeFromJSON(i), r = e.kids.peekBack();
+    s.host = e, s.addBond(s.host, r), e.kids.enqueue(s), a.cache.mapDirs.set(s.unId, !n);
+  }
+  e.type === "tabset" && a.cache.mapElem.set(e.unId, e), e.type === "tab" && a.cache.mapElem.set(e.unId, e);
+}
+function C(o, t, e = u.root) {
+  const n = new b();
+  for (n.enqueue(e), a.cache.mapDirs.set(u.root.unId, !0); !t.isEmpty(); ) {
+    const i = n.dequeue();
+    if (!i)
+      break;
+    const s = a.cache.mapDirs.get(i.unId);
+    if (t.size() == 2) {
+      const h = t.dequeue(), f = t.dequeue(), m = new a({ type: "tabset", host: i }), p = new a({ type: "tabset", host: i }), I = new a({
+        type: "tab",
+        host: m,
+        name: h,
+        unId: o.tabsIds.get(h ?? "") ?? u.createId()
+      }), y = new a({
+        type: "tab",
+        host: p,
+        name: f,
+        unId: o.tabsIds.get(f ?? "") ?? u.createId()
+      });
+      m.open = I.name, p.open = y.name, m.kids.enqueue(I), p.kids.enqueue(y), i.kids.enqueue(m), i.kids.enqueue(p), p.addBond(i, m), a.cache.mapDirs.set(m.unId, !s), a.cache.mapDirs.set(p.unId, !s), a.cache.mapElem.set(m.unId, m), a.cache.mapElem.set(p.unId, p), a.cache.mapDirs.set(I.unId, s), a.cache.mapDirs.set(y.unId, s), a.cache.mapElem.set(I.unId, I), a.cache.mapElem.set(y.unId, y);
+      break;
+    }
+    const r = t.dequeue(), c = new a({ type: "tabset", host: i }), d = new a({ type: "row", host: i }), l = new a({
+      type: "tab",
+      host: c,
+      name: r,
+      unId: o.tabsIds.get(r ?? "") ?? u.createId()
+    });
+    c.open = l.name, c.kids.enqueue(l), i.kids.enqueue(c), i.kids.enqueue(d), d.addBond(i, c), a.cache.mapDirs.set(c.unId, !s), a.cache.mapDirs.set(d.unId, !s), a.cache.mapElem.set(c.unId, c), a.cache.mapDirs.set(l.unId, s), a.cache.mapElem.set(l.unId, l), n.enqueue(d);
+  }
+  o.calcTabsetCountAndMinDim();
+}
+function F(o, t) {
+  const e = new a({
+    type: t.typNode,
+    name: t.nodName,
+    unId: t.uidNode,
+    part: t.nodPart,
+    dims: { w: 0, h: 0, x: 0, y: 0 },
+    open: typeof t.nodOpen == "string" ? t.nodOpen : ""
+  });
+  return t.typNode === "tab" && (e.unId = o.tabsIds.get(t.nodName) || t.uidNode), e;
+}
+function W(o, t = u.root, e = !0) {
+  t === u.root && e && (a.cache.tabCnts.clear(), a.cache.dimMins.clear(), a.cache.mapElem.clear(), a.cache.nodOpts.get().clear(), a.cache.bndOpts.get().clear());
+  for (const n of o.NodeLayoutRecursiveIterator(t)) {
+    const i = a.cache.tabCnts, s = a.cache.dimMins;
+    a.cache.mapElem.set(n.unId, n);
+    const r = i.set(n.unId, {
+      horizontal: 0,
+      vertical: 0
+    }).get(n.unId), c = s.set(n.unId, {
+      minWidth: 0,
+      minHeight: 0
+    }).get(n.unId), d = a.cache.mapDirs.get(n.unId);
+    if (n.type === "tab" && (a.cache.mapElem.set(n.unId, n), s.set(n.unId, {
+      minWidth: 0,
+      minHeight: 0
+    })), n.next && a.cache.mapElem.set(n.next.unId, n.next), n.type === "tabset" && (a.cache.mapElem.set(n.unId, n), s.set(n.unId, {
+      minWidth: u.minW,
+      minHeight: u.minH
+    }), d ? i.set(n.unId, {
+      horizontal: 0,
+      vertical: 1
+    }) : i.set(n.unId, {
+      horizontal: 1,
+      vertical: 0
+    })), n.type === "row") {
+      for (const l of n.kids) {
+        const h = i.get(l.unId), f = s.get(l.unId);
+        h && (r.horizontal += h.horizontal, r.vertical += h.vertical, d ? (c.minHeight = Math.max(
+          c.minHeight,
+          f.minHeight
+        ), c.minWidth += f.minWidth) : (c.minHeight += f.minHeight, c.minWidth = Math.max(
+          c.minWidth,
+          f.minWidth
+        )));
+      }
+      d ? c.minWidth += (n.kids.size() - 1) * u.bond : c.minHeight += (n.kids.size() - 1) * u.bond;
+    }
+  }
+  t === u.root && e && o.pruneStaleDirections();
+}
+function L() {
+  for (const o of a.cache.mapDirs.keys())
+    a.cache.mapElem.has(o) || a.cache.mapDirs.delete(o);
+}
+function P() {
+  const o = u.root.getReqDimension();
+  let t = !1, e = u.root.dims.w, n = u.root.dims.h;
+  return u.root.dims.w < o.width && (e = o.width, t = !0), u.root.dims.h < o.height && (n = o.height, t = !0), t && (u.root.dims.w = e, u.root.dims.h = n), {
+    adjustedW: e,
+    adjustedH: n,
+    wasAdjusted: t
+  };
+}
+function z(o, t = u.root, e = !1) {
+  const n = t === u.root, i = (d) => n ? /* @__PURE__ */ new Map() : new Map(d.get()), s = i(a.cache.nodOpts), r = i(a.cache.bndOpts), c = i(a.cache.tabOpts);
+  n && o.calculateRootAdjustment();
+  for (const d of o.NodeLayoutIterator(t)) {
+    d.calcDimensions();
+    const l = a.cache.mapDirs.get(d.unId);
+    if (d.type === "tabset") {
+      const h = {
+        typNode: d.type,
+        nodName: d.name,
+        uidNode: d.unId,
+        nodPart: d.part,
+        nodOpen: d.open,
+        nodeDir: l,
+        nodKids: Array.from(d.kids).map((f) => {
+          const m = {
+            typNode: f.type,
+            nodName: f.name,
+            uidNode: f.unId,
+            nodPart: f.part,
+            nodOpen: d.open === f.name,
+            nodeDir: !l,
+            nodDims: {
+              ...d.dims
+            }
+          };
+          return c.set(f.unId, m), m;
+        }),
+        nodDims: {
+          ...d.dims
+        }
+      };
+      s.set(d.unId, h);
+    }
+    if (d.next && d.type !== "tab") {
+      const h = {
+        typNode: "bond",
+        nodName: d.name,
+        uidNode: d.next.unId,
+        nodeDir: l,
+        nodPart: 0,
+        nodDims: {
+          ...d.next.dims
+        }
+      };
+      r.set(d.next.unId, h);
+    }
+  }
+  a.cache.nodOpts.set(s, e), a.cache.bndOpts.set(r, e), a.cache.tabOpts.set(c, e);
+}
+function K(o, t, e = !1, n = 2) {
+  if (u.root.dims = t, e) {
+    o.calcDimensions(u.root);
+    return;
+  }
+  o.cntdown && (u.timer.clear(o.cntdown), o.cntdown = null), o.cntdown = u.timer.set(() => {
+    o.cntdown = null, o.calcDimensions();
+  }, n);
+}
+function U(o, t, e, n = !1, i = 2) {
+  if (n) {
+    o.updateSliderDimension(t, e);
+    return;
+  }
+  o.cntdown && (u.timer.clear(o.cntdown), o.cntdown = null), o.cntdown = u.timer.set(() => {
+    o.cntdown = null, o.updateSliderDimension(t, e);
+  }, i);
+}
+function $(o, t, e) {
+  const n = a.cache.mapElem.get(t);
+  if (!n || !(n instanceof O)) {
+    console.warn(`Bond with id ${t} not found or is not a Bond instance`);
+    return;
+  }
+  const i = a.cache.mapDirs.get(n.host.unId), s = n.prev, r = n.next, c = n.host;
+  if (!s || !r || !c) {
+    console.warn("Missing prev, next, or host node", s, r, c);
+    return;
+  }
+  const d = a.cache.dimMins.get(s.unId) || {
+    minWidth: 0,
+    minHeight: 0
+  }, l = a.cache.dimMins.get(r.unId) || {
+    minWidth: 0,
+    minHeight: 0
+  }, h = u.bond / 2;
+  if (i) {
+    const f = r.dims.x + r.dims.w, m = s.dims.x + d.minWidth + h, p = f - l.minWidth - h, I = Math.max(m, Math.min(p, e.x));
+    n.dims.x = I - h, s.dims.w = n.dims.x - s.dims.x, r.dims.x = I + h, r.dims.w = f - r.dims.x;
+    const y = Math.max(0, s.dims.w - d.minWidth), g = Math.max(0, r.dims.w - l.minWidth), N = y + g, k = s.part + r.part;
+    N > 0 ? (s.part = y / N * k, r.part = g / N * k) : (s.part = k / 2, r.part = k / 2);
+  } else {
+    const f = r.dims.y + r.dims.h, m = s.dims.y + d.minHeight + h, p = f - l.minHeight - h, I = Math.max(m, Math.min(p, e.y));
+    n.dims.y = I - h, s.dims.h = n.dims.y - s.dims.y, r.dims.y = I + h, r.dims.h = f - r.dims.y;
+    const y = Math.max(0, s.dims.h - d.minHeight), g = Math.max(0, r.dims.h - l.minHeight), N = y + g, k = s.part + r.part;
+    N > 0 ? (s.part = y / N * k, r.part = g / N * k) : (s.part = k / 2, r.part = k / 2);
+  }
+  o.calcDimensions(c);
+}
+function _(o, t, e, n) {
+  const i = a.cache.mapElem.get(t);
+  let s = a.cache.mapElem.get(e);
+  return !i || !(i instanceof a) || !s || !(s instanceof a) ? (console.warn(`Source node ${t} not found or is not a Node instance`), !1) : i?.type == "tab" && i.host === s && s.kids.size() < 2 ? (console.warn("Cannot move to self as it has only one tab"), !1) : i?.type == "tabset" && s?.host === i ? (console.warn("Cannot move tabset to self as it is already a child"), !1) : !i || !s ? (console.warn(`Source or destination node not found: ${t}, ${e}`), !1) : i === s ? (console.warn(
+    "Source and destination nodes are the same, no action taken."
+  ), !1) : !i.host || !s.host && s.type !== "row" ? (console.warn(
+    `Source node or destination node's host is null: ${i.unId}, ${s.unId}`
+  ), !1) : s.type === "row" && s !== u.root ? (console.warn(`Cannot move relative to a nested row: ${s.unId}`), !1) : s.type === "row" && n === "contain" ? (console.warn(
+    `Cannot move to a row with 'contain' layout: ${s.unId}`
+  ), !1) : i.type === "row" || (s.type === "tabset" && n === "contain" && (s = s.kids.peekBack() || s), i === s) ? !1 : o.isOnlyContent(i) ? (console.warn("Cannot move the only tabset or tab in the layout"), !1) : (s.type === "tab" && (n === "contain" || n === "left" || n === "right") ? o.moveNodeAsTab(i, s, n) : s.type === "row" && n !== "contain" ? o.moveRelativeToRoot(i, s, n) : s.type === "tabset" && n !== "contain" && o.moveRelativeToTabset(i, s, n), o.calcTabsetCountAndMinDim(), o.calcDimensions(u.root, !0), !0);
+}
+function Y(o, t) {
+  let e = 0;
+  for (const n of o.NodeLayoutRecursiveIterator(u.root))
+    n.type === "tabset" && e++;
+  return e !== 1 ? !1 : t.type === "tabset" || t.type === "tab" && t.host?.kids.size() === 1;
+}
+function G(o, t, e, n) {
+  if (!e || !e.host) {
+    console.warn(`Destination node ${e.unId} has no host, cannot move.`);
+    return;
+  }
+  o.removeNode(t);
+  const i = e.host, s = i.kids.indexOf(e);
+  if (s === void 0 || s === -1)
+    return;
+  const r = n === "contain" || n === "left", c = r ? s : s + 1, d = i.kids.get(c + 1), l = i.kids.get(c - 1), h = e.next, f = e.prev;
+  if (!r && h ? a.cache.mapElem.delete(h.unId) : r && f && a.cache.mapElem.delete(f.unId), t.type == "tab")
+    r ? (l && t.addBond(i, l), e.addBond(i, t)) : (t.addBond(i, e), d && d.addBond(i, t)), i.kids.insert(c, t), t.host = i, i.open = t.name;
+  else if (t.type == "tabset") {
+    const m = t.kids.peek(), p = t.kids.peekBack();
+    r ? (m && l && m.addBond(i, l), p && e && e.addBond(i, p)) : (m && e && m.addBond(i, e), p && d && d.addBond(i, p)), i.kids.insertQueue(c, t.kids);
+    for (const I of t.kids)
+      I.host = i, I.next && (I.next.host = i);
+    i.open = p ? p.name : "";
+  }
+  o.updateChildDirections(i);
+}
+const J = {
+  root: (o, t) => o === t,
+  tabset: (o, t) => o !== t
+};
+function D(o, t, e, n, i) {
+  if (o.removeNode(t), t.type !== "tab" && t.type !== "tabset") return;
+  const s = a.cache.mapDirs.get(e.unId) === !1, r = n === "left" || n === "right", c = n === "top" || n === "left";
+  let d = t;
+  t.type === "tab" && (d = new a({ type: "tabset", host: e.host }), d.kids.enqueue(t), d.open = t.name, t.host = d), J[i](s, r) ? o.insertNodeWithNewParent(d, e, c) : o.insertNode(e, d, c);
+}
+function Q(o, t, e, n) {
+  D(o, t, e, n, "root");
+}
+function j(o, t, e, n) {
+  D(o, t, e, n, "tabset");
+}
+function X(o, t, e, n) {
+  const i = t.host;
+  if (t == u.root) {
+    const f = u.root.kids.peek(), m = u.root.kids.peekBack();
+    n ? (u.root.kids.enqueueFront(e), f && f.addBond(u.root, e)) : (u.root.kids.enqueue(e), m && e.addBond(u.root, m)), e.host = u.root, o.updateChildDirections(u.root);
+    return;
+  }
+  if (!i) {
+    console.warn(`Destination node ${t.unId} has no host, cannot insert.`);
+    return;
+  }
+  const s = i.kids.indexOf(t);
+  if (s === -1) {
+    console.warn(
+      `Destination node ${t.unId} not found in its host's kids.`
+    );
+    return;
+  }
+  const r = a.cache.mapDirs.get(i.unId);
+  r && a.cache.mapDirs.set(e.unId, !r);
+  const c = i.kids.get(s + 1), d = i.kids.get(s - 1), l = t.next, h = t.prev;
+  e.host = i, n ? (i.kids.insert(s, e), t.addBond(i, e), d && e.addBond(i, d), h && a.cache.mapElem.delete(h.unId)) : (i.kids.insert(s + 1, e), e.addBond(i, t), c && c.addBond(i, e), l && a.cache.mapElem.delete(l.unId)), o.updateChildDirections(i);
+}
+function V(o, t, e, n) {
+  const i = new b(), s = new a({ type: "tabset", host: e.host });
+  if (!e || !t) {
+    console.warn(`Destination node ${e.unId} has no host, cannot insert.`);
+    return;
+  }
+  if (e === u.root) {
+    const c = new a({ type: "row", host: e });
+    if (e.kids.size() === 0)
+      e.kids.enqueue(t), t.host = e;
+    else if (e.kids.size() == 1 && e.kids.peek()?.type === "tabset") {
+      const d = e.kids.dequeue();
+      if (!d) {
+        console.warn(
+          `No kid found in destination node ${e.unId}, cannot insert.`
+        );
+        return;
+      }
+      n ? (c.kids.enqueue(t), c.kids.enqueue(d), e.kids.enqueue(c), d.addBond(c, t)) : (c.kids.enqueue(d), c.kids.enqueue(t), t.addBond(c, d), e.kids.enqueue(c)), t.host = c, d.host = c;
+    } else if (e.kids.size() == 1 && e.kids.peek()?.type === "row") {
+      const d = e.kids.peek(), l = d?.kids.peek(), h = d?.kids.peekBack();
+      n && d ? (d.kids.enqueueFront(t), l && l.addBond(d, t)) : d && (d.kids.enqueue(t), h && t.addBond(d, h)), t.host = d;
+    } else if (e.kids.size() > 1) {
+      const d = new a({ type: "row", host: e }), l = new a({ type: "row", host: d });
+      for (const h of e.kids)
+        l.kids.enqueue(h), h.host = l, h.next && (h.next.host = l);
+      t.host = d, e.kids.clear(), n ? (d.kids.enqueueFront(t), d.kids.enqueue(l), l.addBond(d, t)) : (d.kids.enqueue(l), d.kids.enqueue(t), t.addBond(d, l)), e.kids.enqueue(d);
+    }
+    o.updateChildDirections(e);
+    return;
+  }
+  t.host = e, s.host = e, s.kids = e.kids, s.open = e.open;
+  const r = a.cache.mapDirs.get(e.unId);
+  for (const c of s.kids)
+    c.host = s, c.next && (c.next.host = s), a.cache.mapDirs.set(c.unId, r);
+  for (const c of t.kids)
+    c.host = t, c.next && (c.next.host = t), a.cache.mapDirs.set(c.unId, r);
+  a.cache.mapDirs.set(s.unId, !r), a.cache.mapDirs.set(t.unId, !r), n ? (i.enqueue(t), i.enqueue(s), e.kids = i, e.type = "row", s.addBond(e, t)) : (i.enqueue(s), i.enqueue(t), e.kids = i, e.type = "row", t.addBond(e, s));
+}
+function Z(o, t) {
+  if (!t.host || !t.host.host) {
+    console.warn(`Source node ${t.unId} has no host, cannot move.`);
+    return;
+  }
+  const e = t.host, n = t.host.host, i = n.kids.indexOf(e), s = n.kids.get(i - 1), r = n.kids.get(i + 1), c = t.kids.peek(), d = t.kids.peekBack();
+  o.removeKid(e);
+  let l = i;
+  if (t.type == "row" && e) {
+    s && c && c.addBond(n, s), r && d && r.addBond(n, d);
+    for (const h of t.kids)
+      h.host = n, h.next && (h.next.host = n), n.kids.insert(l, h), a.cache.mapDirs.set(
+        h.unId,
+        !a.cache.mapDirs.get(n.unId)
+      ), a.cache.dimMins.delete(h.unId), l++;
+  } else if (t.type == "tabset") {
+    s && t.addBond(n, s), r && r.addBond(n, t), n.kids.insert(l, t), t.host = n, a.cache.mapDirs.set(t.unId, !a.cache.mapDirs.get(n.unId));
+    for (const h of t.kids)
+      a.cache.mapDirs.set(
+        h.unId,
+        a.cache.mapDirs.get(n.unId)
+      ), a.cache.dimMins.delete(h.unId);
+  }
+}
+function tt(o, t = !0) {
+  const e = o.host, n = o.prev, i = o.next;
+  if (o.host = null, o.next = null, o.prev = null, n && (n.next = null), i && (i.prev = null), !t)
+    return o;
+  n && i && n.prev && i.next ? n.prev.addBond(e, i.next) : n && n.prev ? n.prev.next = null : i && i.next && (i.next.prev = null);
+}
+function et(o, t) {
+  if (!t.host) {
+    console.warn("Kid node has no host, cannot remove.");
+    return;
+  }
+  const e = t?.host, n = e?.host;
+  if (o.removeKid(t), t.type === "tabset" && e.kids.size() === 1) {
+    const i = e.kids.peek();
+    i && o.moveAdjacentNodeToGrandParent(i);
+  } else if (t.type === "tab" && e.kids.size() === 0 && n.kids.size() === 2) {
+    o.removeKid(e);
+    const i = n?.kids.peek();
+    i && o.moveAdjacentNodeToGrandParent(i);
+  } else if (t.type === "tab" && e.kids.size() === 0 && n.kids.size() > 2)
+    o.removeKid(e);
+  else if (t.type === "tab" && e.open === t.name && e.kids.size() > 0) {
+    const i = e.kids.peek();
+    i && (e.open = i.name);
+  }
+}
+function nt(o) {
+  if (!o.host) {
+    console.warn("Kid node has no host, cannot remove.");
+    return;
+  }
+  const t = o.host, e = t.kids.indexOf(o), n = t.kids.get(e + 1), i = t.kids.get(e - 1), s = o.next, r = o.prev;
+  if (e === -1) {
+    console.warn("Kid node not found in its host's kids.");
+    return;
+  }
+  s && a.cache.mapElem.delete(s.unId), r && a.cache.mapElem.delete(r.unId), n && i ? n.addBond(t, i) : n ? n.prev = null : i && (i.next = null), t.kids.removeAt(e), a.cache.mapElem.delete(o.unId), a.cache.dimMins.delete(o.unId), a.cache.mapDirs.delete(o.unId), a.cache.tabCnts.delete(o.unId), o.type === "tabset" && a.cache.mapElem.delete(o.unId), o.type === "tab" && a.cache.mapElem.delete(o.unId), o.host = null, o.next = null, o.prev = null;
+}
+function it() {
+  a.cache.dimMins.clear(), a.cache.mapDirs.clear(), a.cache.tabCnts.clear(), a.cache.mapElem.clear(), a.cache.nodOpts.get().clear(), a.cache.bndOpts.get().clear();
+}
+class w {
+  static get _root() {
+    return u.root;
+  }
+  static set _root(t) {
+    u.root = t;
+  }
+  static get _tree() {
+    return u.tree;
+  }
+  static set _tree(t) {
+    u.tree = t;
+  }
+  static get _minW() {
+    return u.minW;
+  }
+  static set _minW(t) {
+    u.minW = t;
+  }
+  static get _minH() {
+    return u.minH;
+  }
+  static set _minH(t) {
+    u.minH = t;
+  }
+  static get _bond() {
+    return u.bond;
+  }
+  static set _bond(t) {
+    u.bond = t;
+  }
+  static get _inst() {
+    return u.inst;
+  }
+  static set _inst(t) {
+    u.inst = t;
+  }
   nodeOps;
   cntdown = null;
   tabsIds = /* @__PURE__ */ new Map();
@@ -471,482 +961,222 @@ class c {
       tabsIds: /* @__PURE__ */ new Map(),
       ...t
     };
-    this.tabsIds = e.tabsIds, e.tree && (c._tree = e.tree), c._root = new a({
+    this.tabsIds = e.tabsIds, u.createId = e.createId ?? v, u.timer = e.timer ?? T, w._tree = e.tree ?? null, w._root = new a({
       unId: e.uqid,
       name: e.uqid,
       type: "row"
-    }), this.nodeOps = g(
+    }), this.nodeOps = x(
       /* @__PURE__ */ new Map(),
       E
-    ), c._minW = e.minW, c._minH = e.minH, c._bond = e.bond;
-    const i = new N(e.tabs.length, e.tabs);
-    c._tree ? this.createNodeLayout() : this.createBinaryNodeTreeFromQueue(i), c._inst = this;
+    ), w._minW = e.minW, w._minH = e.minH, w._bond = e.bond;
+    const n = new b(e.tabs.length, e.tabs);
+    w._tree ? this.createNodeLayout() : this.createBinaryNodeTreeFromQueue(n), w._inst = this;
   }
   *JSONLayoutIterator(t) {
-    const e = new N();
-    for (e.enqueue(t); !e.isEmpty(); ) {
-      const i = e.dequeue();
-      if (i && (yield i, i.nodKids && i.nodKids.length > 0))
-        for (const n of i.nodKids)
-          e.enqueue(n);
-    }
+    yield* S(t);
   }
   *NodeLayoutIterator(t) {
-    const e = new N();
-    for (e.enqueue(t); !e.isEmpty(); ) {
-      const i = e.dequeue();
-      if (i && (a.cache.mapElem.set(i.unId, i), yield i, i.kids.size() > 0))
-        for (const n of i.kids)
-          e.enqueue(n);
-    }
+    yield* R(t);
   }
   *NodeLayoutRecursiveIterator(t) {
-    for (const e of t.kids)
-      yield* this.NodeLayoutRecursiveIterator(e);
-    yield t;
+    yield* H(this, t);
   }
   updateChildDirections(t) {
-    const e = a.cache.mapDirs.get(t.unId);
-    if (e === void 0) {
-      console.warn(
-        `Cannot update child directions for node ${t.unId}; its own direction is not set.`
-      );
-      return;
-    }
-    for (const i of t.kids)
-      a.cache.mapDirs.set(i.unId, !e), i.kids.size() > 0 && (i.host = t, this.updateChildDirections(i), i.next && a.cache.mapDirs.set(i.next.unId, !e));
-  }
-  createNodeLayout(t = c._tree) {
-    const e = this.JSONLayoutIterator(t), i = this.NodeLayoutIterator(c._root);
-    for (a.cache.mapDirs.set(c._root.unId, !0); ; ) {
-      const n = e.next(), s = i.next();
-      if (n.done || s.done)
-        break;
-      const d = n.value, o = s.value;
-      !d || !o || this.createNodeTreeFromJSONTree(d, o);
-    }
-    this.calcTabsetCountAndMinDim();
+    return q(this, t);
+  }
+  createNodeLayout(t = w._tree) {
+    return B(this, t);
   }
   createNodeTreeFromJSONTree(t, e) {
-    const i = a.cache.mapDirs.get(e.unId);
-    for (const n of t.nodKids || []) {
-      const s = this.createNodeFromJSON(n), d = e.kids.peekBack();
-      s.host = e, s.addBond(s.host, d), e.kids.enqueue(s), a.cache.mapDirs.set(s.unId, !i);
-    }
-    e.type === "tabset" && a.cache.mapElem.set(e.unId, e), e.type === "tab" && a.cache.mapElem.set(e.unId, e);
-  }
-  createBinaryNodeTreeFromQueue(t, e = c._root) {
-    const i = new N();
-    for (i.enqueue(e), a.cache.mapDirs.set(c._root.unId, !0); !t.isEmpty(); ) {
-      const n = i.dequeue();
-      if (!n)
-        break;
-      const s = a.cache.mapDirs.get(n.unId);
-      if (t.size() == 2) {
-        const u = t.dequeue(), l = t.dequeue(), f = new a({ type: "tabset", host: n }), m = new a({ type: "tabset", host: n }), p = new a({
-          type: "tab",
-          host: f,
-          name: u,
-          unId: this.tabsIds.get(u ?? "") ?? crypto.randomUUID()
-        }), w = new a({
-          type: "tab",
-          host: m,
-          name: l,
-          unId: this.tabsIds.get(l ?? "") ?? crypto.randomUUID()
-        });
-        f.open = p.name, m.open = w.name, f.kids.enqueue(p), m.kids.enqueue(w), n.kids.enqueue(f), n.kids.enqueue(m), m.addBond(n, f), a.cache.mapDirs.set(f.unId, !s), a.cache.mapDirs.set(m.unId, !s), a.cache.mapElem.set(f.unId, f), a.cache.mapElem.set(m.unId, m), a.cache.mapDirs.set(p.unId, s), a.cache.mapDirs.set(w.unId, s), a.cache.mapElem.set(p.unId, p), a.cache.mapElem.set(w.unId, w);
-        break;
-      }
-      const d = t.dequeue(), o = new a({ type: "tabset", host: n }), h = new a({ type: "row", host: n }), r = new a({
-        type: "tab",
-        host: o,
-        name: d,
-        unId: this.tabsIds.get(d ?? "") ?? crypto.randomUUID()
-      });
-      o.open = r.name, o.kids.enqueue(r), n.kids.enqueue(o), n.kids.enqueue(h), h.addBond(n, o), a.cache.mapDirs.set(o.unId, !s), a.cache.mapDirs.set(h.unId, !s), a.cache.mapElem.set(o.unId, o), a.cache.mapDirs.set(r.unId, s), a.cache.mapElem.set(r.unId, r), i.enqueue(h);
-    }
-    this.calcTabsetCountAndMinDim();
+    return M(this, t, e);
+  }
+  createBinaryNodeTreeFromQueue(t, e = w._root) {
+    return C(this, t, e);
   }
   createNodeFromJSON(t) {
-    const e = new a({
-      type: t.typNode,
-      name: t.nodName,
-      unId: t.uidNode,
-      part: t.nodPart,
-      dims: { w: 0, h: 0, x: 0, y: 0 },
-      open: typeof t.nodOpen == "string" ? t.nodOpen : ""
-    });
-    return t.typNode === "tab" && (e.unId = this.tabsIds.get(t.nodName) || t.uidNode), e;
-  }
-  calcTabsetCountAndMinDim(t = c._root, e = !0) {
-    t === c._root && e && (a.cache.tabCnts.clear(), a.cache.dimMins.clear(), a.cache.mapElem.clear(), a.cache.mapElem.clear(), a.cache.mapElem.clear(), a.cache.mapElem.clear(), a.cache.nodOpts.get().clear(), a.cache.bndOpts.get().clear());
-    for (const i of this.NodeLayoutRecursiveIterator(t)) {
-      const n = a.cache.tabCnts, s = a.cache.dimMins;
-      a.cache.mapElem.set(i.unId, i);
-      const d = n.set(i.unId, {
-        horizontal: 0,
-        vertical: 0
-      }).get(i.unId), o = s.set(i.unId, {
-        minWidth: 0,
-        minHeight: 0
-      }).get(i.unId), h = a.cache.mapDirs.get(i.unId);
-      if (i.type === "tab" && (a.cache.mapElem.set(i.unId, i), s.set(i.unId, {
-        minWidth: 0,
-        minHeight: 0
-      })), i.next && a.cache.mapElem.set(i.next.unId, i.next), i.type === "tabset" && (a.cache.mapElem.set(i.unId, i), s.set(i.unId, {
-        minWidth: c._minW,
-        minHeight: c._minH
-      }), h ? n.set(i.unId, {
-        horizontal: 0,
-        vertical: 1
-      }) : n.set(i.unId, {
-        horizontal: 1,
-        vertical: 0
-      })), i.type === "row") {
-        for (const r of i.kids) {
-          const u = n.get(r.unId), l = s.get(r.unId);
-          u && (d.horizontal += u.horizontal, d.vertical += u.vertical, h ? (o.minHeight = Math.max(
-            o.minHeight,
-            l.minHeight
-          ), o.minWidth += l.minWidth) : (o.minHeight += l.minHeight, o.minWidth = Math.max(
-            o.minWidth,
-            l.minWidth
-          )));
-        }
-        h ? o.minWidth += (i.kids.size() - 1) * c._bond : o.minHeight += (i.kids.size() - 1) * c._bond;
-      }
-    }
+    return F(this, t);
+  }
+  calcTabsetCountAndMinDim(t = w._root, e = !0) {
+    return W(this, t, e);
+  }
+  pruneStaleDirections() {
+    return L();
   }
   calculateRootAdjustment() {
-    const t = c._root.getReqDimension();
-    let e = !1, i = c._root.dims.w, n = c._root.dims.h;
-    return c._root.dims.w < t.width && (i = t.width, e = !0), c._root.dims.h < t.height && (n = t.height, e = !0), e && (c._root.dims.w = i, c._root.dims.h = n), {
-      adjustedW: i,
-      adjustedH: n,
-      wasAdjusted: e
-    };
+    return P();
   }
-  calcDimensions(t = c._root, e = !1) {
-    const i = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
-    t === c._root && this.calculateRootAdjustment();
-    for (const d of this.NodeLayoutIterator(t)) {
-      d.calcDimensions();
-      const o = a.cache.mapDirs.get(d.unId);
-      if (d.type === "tabset") {
-        const h = {
-          typNode: d.type,
-          nodName: d.name,
-          uidNode: d.unId,
-          nodPart: d.part,
-          nodOpen: d.open,
-          nodeDir: o,
-          nodKids: Array.from(d.kids).map((r) => {
-            const u = {
-              typNode: r.type,
-              nodName: r.name,
-              uidNode: r.unId,
-              nodPart: r.part,
-              nodOpen: d.open === r.name,
-              nodeDir: !o,
-              nodDims: {
-                ...d.dims
-              }
-            };
-            return s.set(r.unId, u), u;
-          }),
-          nodDims: {
-            ...d.dims
-          }
-        };
-        i.set(d.unId, h);
-      }
-      if (d.next && d.type !== "tab") {
-        const h = {
-          typNode: "bond",
-          nodName: d.name,
-          uidNode: d.next.unId,
-          nodeDir: o,
-          nodPart: 0,
-          nodDims: {
-            ...d.next.dims
-          }
-        };
-        n.set(d.next.unId, h);
-      }
-    }
-    a.cache.nodOpts.set(i, e), a.cache.bndOpts.set(n, e), a.cache.tabOpts.set(s, e);
+  calcDimensions(t = w._root, e = !1) {
+    return z(this, t, e);
   }
-  updateDimension(t, e = !1, i = 2) {
-    if (c._root.dims = t, e) {
-      this.calcDimensions(c._root);
-      return;
-    }
-    this.cntdown && (clearTimeout(this.cntdown), this.cntdown = null), this.cntdown = setTimeout(() => {
-      this.cntdown = null, this.calcDimensions();
-    }, i);
+  updateDimension(t, e = !1, n = 2) {
+    return K(this, t, e, n);
   }
-  updateSlider(t, e, i = !1, n = 2) {
-    if (i) {
-      this.updateSliderDimension(t, e);
-      return;
-    }
-    this.cntdown && (clearTimeout(this.cntdown), this.cntdown = null), this.cntdown = setTimeout(() => {
-      this.cntdown = null, this.updateSliderDimension(t, e);
-    }, n);
+  updateSlider(t, e, n = !1, i = 2) {
+    return U(this, t, e, n, i);
   }
   updateSliderDimension(t, e) {
-    const i = a.cache.mapElem.get(t);
-    if (!i || !(i instanceof x)) {
-      console.warn(
-        `Bond with id ${t} not found or is not a Bond instance`
-      );
-      return;
-    }
-    const n = a.cache.mapDirs.get(i.host.unId), s = i.prev, d = i.next, o = i.host;
-    if (!s || !d || !o) {
-      console.warn("Missing prev, next, or host node", s, d, o);
-      return;
-    }
-    const h = a.cache.dimMins.get(s.unId) || {
-      minWidth: 0,
-      minHeight: 0
-    }, r = a.cache.dimMins.get(d.unId) || {
-      minWidth: 0,
-      minHeight: 0
-    }, u = c._bond / 2;
-    if (n) {
-      const l = d.dims.x + d.dims.w, f = s.dims.x + h.minWidth + u, m = l - r.minWidth - u, p = Math.max(f, Math.min(m, e.x));
-      i.dims.x = p - u, s.dims.w = i.dims.x - s.dims.x, d.dims.x = p + u, d.dims.w = l - d.dims.x;
-      const w = Math.max(
-        0,
-        s.dims.w - h.minWidth
-      ), k = Math.max(
-        0,
-        d.dims.w - r.minWidth
-      ), b = w + k, y = s.part + d.part;
-      b > 0 ? (s.part = w / b * y, d.part = k / b * y) : (s.part = y / 2, d.part = y / 2);
-    } else {
-      const l = d.dims.y + d.dims.h, f = s.dims.y + h.minHeight + u, m = l - r.minHeight - u, p = Math.max(f, Math.min(m, e.y));
-      i.dims.y = p - u, s.dims.h = i.dims.y - s.dims.y, d.dims.y = p + u, d.dims.h = l - d.dims.y;
-      const w = Math.max(
-        0,
-        s.dims.h - h.minHeight
-      ), k = Math.max(
-        0,
-        d.dims.h - r.minHeight
-      ), b = w + k, y = s.part + d.part;
-      b > 0 ? (s.part = w / b * y, d.part = k / b * y) : (s.part = y / 2, d.part = y / 2);
-    }
-    this.calcDimensions(o);
-  }
-  updateTree(t, e, i) {
-    const n = a.cache.mapElem.get(t);
-    let s = a.cache.mapElem.get(e);
-    return !n || !(n instanceof a) || !s || !(s instanceof a) ? (console.warn(
-      `Source node ${t} not found or is not a Node instance`
-    ), !1) : n?.type == "tab" && n.host === s && s.kids.size() < 2 ? (console.warn("Cannot move to self as it has only one tab"), !1) : n?.type == "tabset" && s?.host === n ? (console.warn("Cannot move tabset to self as it is already a child"), !1) : !n || !s ? (console.warn(`Source or destination node not found: ${t}, ${e}`), !1) : n === s ? (console.warn(
-      "Source and destination nodes are the same, no action taken."
-    ), !1) : !n.host || !s.host && s.type !== "row" ? (console.warn(
-      `Source node or destination node's host is null: ${n.unId}, ${s.unId}`
-    ), !1) : s.type === "row" && i === "contain" ? (console.warn(
-      `Cannot move to a row with 'contain' layout: ${s.unId}`
-    ), !1) : n.type === "row" ? !1 : (s.type === "tabset" && i === "contain" && (s = s.kids.peekBack() || s), s.type === "tab" && (i === "contain" || i === "left" || i === "right") ? this.moveNodeAsTab(n, s, i) : s.type === "row" && i !== "contain" ? this.moveRelativeToRoot(n, s, i) : s.type === "tabset" && i !== "contain" && this.moveRelativeToTabset(n, s, i), this.calcTabsetCountAndMinDim(), this.calcDimensions(c._root, !0), !0);
-  }
-  moveNodeAsTab(t, e, i) {
-    if (!e || !e.host) {
-      console.warn(
-        `Destination node ${e.unId} has no host, cannot move.`
-      );
-      return;
-    }
-    this.removeNode(t);
-    const n = e.host, s = n.kids.indexOf(e);
-    if (s === void 0 || s === -1)
-      return;
-    const d = i === "contain" || i === "left", o = d ? s : s + 1, h = n.kids.get(o + 1), r = n.kids.get(o - 1), u = e.next, l = e.prev;
-    if (!d && u ? (a.cache.mapElem.delete(u.unId), a.cache.nodOpts.get().delete(u.unId)) : d && l && (a.cache.mapElem.delete(l.unId), a.cache.nodOpts.get().delete(l.unId)), t.type == "tab")
-      d ? (r && t.addBond(n, r), e.addBond(n, t)) : (t.addBond(n, e), h && h.addBond(n, t)), n.kids.insert(o, t), t.host = n, n.open = t.name;
-    else if (t.type == "tabset") {
-      const f = t.kids.peek(), m = t.kids.peekBack();
-      d ? (f && r && f.addBond(n, r), m && e && e.addBond(n, m)) : (f && e && f.addBond(n, e), m && h && h.addBond(n, m)), n.kids.insertQueue(o, t.kids);
-      for (const p of t.kids)
-        p.host = n, p.next && (p.next.host = n);
-      n.open = m ? m.name : "";
-    }
-    this.updateChildDirections(n);
-  }
-  moveRelativeToRoot(t, e, i) {
-    this.removeNode(t);
-    const n = a.cache.mapDirs.get(e.unId), s = i === "top" || i === "left";
-    if (t.type === "tab") {
-      const d = new a({ type: "tabset", host: e.host });
-      d.kids.enqueue(t), t.host = d, d.open = t.name, n == !1 ? i === "left" || i === "right" ? this.insertNodeWithNewParent(d, e, s) : this.insertNode(e, d, s) : i === "top" || i === "bottom" ? this.insertNodeWithNewParent(d, e, s) : this.insertNode(e, d, s);
-    } else t.type === "tabset" && (n == !1 ? i === "left" || i === "right" ? this.insertNodeWithNewParent(t, e, s) : this.insertNode(e, t, s) : i === "top" || i === "bottom" ? this.insertNodeWithNewParent(t, e, s) : this.insertNode(e, t, s));
-  }
-  moveRelativeToTabset(t, e, i) {
-    this.removeNode(t);
-    const n = a.cache.mapDirs.get(e.unId), s = i === "top" || i === "left";
-    if (t.type === "tab") {
-      const d = new a({ type: "tabset", host: e.host });
-      d.kids.enqueue(t), t.host = d, d.open = t.name, n == !1 ? i === "top" || i === "bottom" ? this.insertNodeWithNewParent(d, e, s) : this.insertNode(e, d, s) : i === "left" || i === "right" ? this.insertNodeWithNewParent(d, e, s) : this.insertNode(e, d, s);
-    } else t.type === "tabset" && (n == !1 ? i === "top" || i === "bottom" ? this.insertNodeWithNewParent(t, e, s) : this.insertNode(e, t, s) : i === "left" || i === "right" ? this.insertNodeWithNewParent(t, e, s) : this.insertNode(e, t, s));
-  }
-  insertNode(t, e, i) {
-    const n = t.host;
-    if (t == c._root) {
-      const l = c._root.kids.peek(), f = c._root.kids.peekBack();
-      i ? (c._root.kids.enqueueFront(e), l && l.addBond(c._root, e)) : (c._root.kids.enqueue(e), f && e.addBond(c._root, f)), e.host = c._root, this.updateChildDirections(c._root);
-      return;
-    }
-    if (!n) {
-      console.warn(
-        `Destination node ${t.unId} has no host, cannot insert.`
-      );
-      return;
-    }
-    const s = n.kids.indexOf(t);
-    if (s === -1) {
-      console.warn(
-        `Destination node ${t.unId} not found in its host's kids.`
-      );
-      return;
-    }
-    const d = a.cache.mapDirs.get(n.unId);
-    d && a.cache.mapDirs.set(e.unId, !d);
-    const o = n.kids.get(s + 1), h = n.kids.get(s - 1), r = t.next, u = t.prev;
-    e.host = n, i ? (n.kids.insert(s, e), t.addBond(n, e), h && e.addBond(n, h), u && (a.cache.mapElem.delete(u.unId), a.cache.nodOpts.get().delete(u.unId))) : (n.kids.insert(s + 1, e), e.addBond(n, t), o && o.addBond(n, e), r && (a.cache.mapElem.delete(r.unId), a.cache.nodOpts.get().delete(r.unId))), this.updateChildDirections(n);
-  }
-  insertNodeWithNewParent(t, e, i) {
-    const n = new N(), s = new a({ type: "tabset", host: e.host });
-    if (!e || !t) {
-      console.warn(
-        `Destination node ${e.unId} has no host, cannot insert.`
-      );
-      return;
-    }
-    if (e === c._root) {
-      const o = new a({ type: "row", host: e });
-      if (e.kids.size() == 1 && e.kids.peek()?.type === "tabset") {
-        const h = e.kids.dequeue();
-        if (!h) {
-          console.warn(
-            `No kid found in destination node ${e.unId}, cannot insert.`
-          );
-          return;
-        }
-        i ? (o.kids.enqueue(t), o.kids.enqueue(h), e.kids.enqueue(o), h.addBond(o, t)) : (o.kids.enqueue(h), o.kids.enqueue(t), t.addBond(o, h), e.kids.enqueue(o)), t.host = o, h.host = o;
-      } else if (e.kids.size() == 1 && e.kids.peek()?.type === "row") {
-        const h = e.kids.peek(), r = h?.kids.peek(), u = h?.kids.peekBack();
-        i && h ? (h.kids.enqueueFront(t), r && r.addBond(h, t)) : h && (h.kids.enqueue(t), u && t.addBond(h, u)), t.host = h;
-      } else if (e.kids.size() > 1) {
-        const h = new a({ type: "row", host: e }), r = new a({ type: "row", host: h });
-        for (const u of e.kids)
-          r.kids.enqueue(u), u.host = r, u.next && (u.next.host = r);
-        t.host = h, e.kids.clear(), i ? (h.kids.enqueueFront(t), h.kids.enqueue(r), r.addBond(h, t)) : (h.kids.enqueue(r), h.kids.enqueue(t), t.addBond(h, r)), e.kids.enqueue(h);
-      }
-      this.updateChildDirections(e);
-      return;
-    }
-    t.host = e, s.host = e, s.kids = e.kids, s.open = e.open;
-    const d = a.cache.mapDirs.get(e.unId);
-    for (const o of s.kids)
-      o.host = s, o.next && (o.next.host = s), a.cache.mapDirs.set(o.unId, d);
-    for (const o of t.kids)
-      o.host = t, o.next && (o.next.host = t), a.cache.mapDirs.set(o.unId, d);
-    a.cache.mapDirs.set(s.unId, !d), a.cache.mapDirs.set(t.unId, !d), i ? (n.enqueue(t), n.enqueue(s), e.kids = n, e.type = "row", s.addBond(e, t)) : (n.enqueue(s), n.enqueue(t), e.kids = n, e.type = "row", t.addBond(e, s));
+    return $(this, t, e);
+  }
+  updateTree(t, e, n) {
+    return _(this, t, e, n);
+  }
+  isOnlyContent(t) {
+    return Y(this, t);
+  }
+  moveNodeAsTab(t, e, n) {
+    return G(this, t, e, n);
+  }
+  moveRelativeToRoot(t, e, n) {
+    return Q(this, t, e, n);
+  }
+  moveRelativeToTabset(t, e, n) {
+    return j(this, t, e, n);
+  }
+  insertNode(t, e, n) {
+    return X(this, t, e, n);
+  }
+  insertNodeWithNewParent(t, e, n) {
+    return V(this, t, e, n);
   }
   moveAdjacentNodeToGrandParent(t) {
-    if (!t.host || !t.host.host) {
-      console.warn(`Source node ${t.unId} has no host, cannot move.`);
-      return;
-    }
-    const e = t.host, i = t.host.host, n = i.kids.indexOf(e), s = i.kids.get(n - 1), d = i.kids.get(n + 1), o = t.kids.peek(), h = t.kids.peekBack();
-    this.removeKid(e);
-    let r = n;
-    if (t.type == "row" && e) {
-      s && o && o.addBond(i, s), d && h && d.addBond(i, h);
-      for (const u of t.kids)
-        u.host = i, u.next && (u.next.host = i), i.kids.insert(r, u), a.cache.mapDirs.set(
-          u.unId,
-          !a.cache.mapDirs.get(i.unId)
-        ), a.cache.dimMins.delete(u.unId), r++;
-    } else if (t.type == "tabset") {
-      s && t.addBond(i, s), d && d.addBond(i, t), i.kids.insert(r, t), t.host = i, a.cache.mapDirs.set(
-        t.unId,
-        !a.cache.mapDirs.get(i.unId)
-      );
-      for (const u of t.kids)
-        a.cache.mapDirs.set(
-          u.unId,
-          a.cache.mapDirs.get(i.unId)
-        ), a.cache.dimMins.delete(u.unId);
-    }
+    return Z(this, t);
   }
   removeRelation(t, e = !0) {
-    const i = t.host, n = t.prev, s = t.next;
-    if (t.host = null, t.next = null, t.prev = null, n && (n.next = null), s && (s.prev = null), !e)
-      return t;
-    n && s && n.prev && s.next ? n.prev.addBond(i, s.next) : n && n.prev ? n.prev.next = null : s && s.next && (s.next.prev = null);
+    return tt(t, e);
   }
   removeNode(t) {
-    if (!t.host) {
-      console.warn("Kid node has no host, cannot remove.");
-      return;
-    }
-    const e = t?.host, i = e?.host;
-    if (this.removeKid(t), t.type === "tabset" && e.kids.size() === 1) {
-      const n = e.kids.peek();
-      n && this.moveAdjacentNodeToGrandParent(n);
-    } else if (t.type === "tab" && e.kids.size() === 0 && i.kids.size() === 2) {
-      this.removeKid(e);
-      const n = i?.kids.peek();
-      n && this.moveAdjacentNodeToGrandParent(n);
-    } else if (t.type === "tab" && e.kids.size() === 0 && i.kids.size() > 2)
-      this.removeKid(e);
-    else if (t.type === "tab" && e.open === t.name && e.kids.size() > 0) {
-      const n = e.kids.peek();
-      n && (e.open = n.name);
-    }
+    return et(this, t);
   }
   removeKid(t) {
-    if (!t.host) {
-      console.warn("Kid node has no host, cannot remove.");
-      return;
-    }
-    const e = t.host, i = e.kids.indexOf(t), n = e.kids.get(i + 1), s = e.kids.get(i - 1), d = t.next, o = t.prev;
-    if (i === -1) {
-      console.warn("Kid node not found in its host's kids.");
-      return;
-    }
-    d && (a.cache.mapElem.delete(d.unId), a.cache.nodOpts.get().delete(d.unId)), o && (a.cache.mapElem.delete(o.unId), a.cache.nodOpts.get().delete(o.unId)), n && s ? n.addBond(e, s) : n ? n.prev = null : s && (s.next = null), e.kids.removeAt(i), a.cache.mapElem.delete(t.unId), a.cache.dimMins.delete(t.unId), a.cache.mapDirs.delete(t.unId), a.cache.tabCnts.delete(t.unId), t.type === "tabset" && a.cache.mapElem.delete(t.unId), t.type === "tab" && a.cache.mapElem.delete(t.unId), t.host = null, t.next = null, t.prev = null;
+    return nt(t);
   }
   clearAllCache() {
-    a.cache.dimMins.clear(), a.cache.mapDirs.clear(), a.cache.tabCnts.clear(), a.cache.mapElem.clear(), a.cache.nodOpts.get().clear(), a.cache.bndOpts.get().clear();
+    return it();
   }
 }
-class x {
-  dims = { w: 0, h: 0, x: 0, y: 0 };
-  unId = crypto.randomUUID();
-  next = null;
-  prev = null;
-  host = null;
-  constructor(t = null, e = null, i = null) {
-    this.host = t, this.next = e, this.prev = i, this.next && (this.next.prev = this), this.prev && (this.prev.next = this);
+const ot = 6;
+function st(o, t, e) {
+  const { left: n, top: i, width: s, height: r } = o, c = t - n, d = e - i;
+  return c < s / 3 ? { area: "left", left: n, top: i, width: s / 2, height: r } : c > 2 * s / 3 ? {
+    area: "right",
+    left: n + s / 2,
+    top: i,
+    width: s / 2,
+    height: r
+  } : d < r / 3 ? { area: "top", left: n, top: i, width: s, height: r / 2 } : d > 2 * r / 3 ? {
+    area: "bottom",
+    left: n,
+    top: i + r / 2,
+    width: s,
+    height: r / 2
+  } : {
+    area: "contain",
+    left: n + s * 0.1,
+    top: i + r * 0.1,
+    width: s * 0.8,
+    height: r * 0.8
+  };
+}
+function at(o, t) {
+  const { x: e, y: n, w: i, h: s } = o;
+  switch (t) {
+    case "left":
+      return { area: t, left: e, top: n, width: i / 2, height: s };
+    case "right":
+      return {
+        area: t,
+        left: e + i / 2,
+        top: n,
+        width: i / 2,
+        height: s
+      };
+    case "top":
+      return { area: t, left: e, top: n, width: i, height: s / 2 };
+    case "bottom":
+      return {
+        area: t,
+        left: e,
+        top: n + s / 2,
+        width: i,
+        height: s / 2
+      };
   }
-  toJSON() {
+}
+function rt(o, t, e, n) {
+  if (t.length === 0 || n < o.top || n > o.bottom) return null;
+  const i = t[0], s = t[t.length - 1];
+  let r = ot;
+  if (e > s.right)
     return {
-      nodName: this.host?.name || "",
-      typNode: "bond",
-      uidNode: this.unId,
-      nodPart: 0,
-      nodOpen: "",
-      nodKids: []
+      index: t.length - 1,
+      area: "right",
+      left: s.right + 1,
+      top: s.top,
+      width: r - 2,
+      height: s.height
     };
-  }
+  if (e < i.left)
+    return {
+      index: 0,
+      area: "left",
+      left: i.left - r + 1,
+      top: i.top,
+      width: r - 2,
+      height: i.height
+    };
+  let c = 0, d = 1 / 0, l = !1;
+  t.forEach((m, p) => {
+    const I = m.left + m.width / 2, y = Math.abs(e - I);
+    y < d && (d = y, c = p, l = e < I);
+  });
+  const h = l ? c > 0 : c < t.length - 1;
+  t.length > 1 && h && (r = t[1].left - i.right);
+  const f = t[c];
+  return {
+    index: c,
+    area: l ? "left" : "right",
+    left: l ? f.left - r + 1 : f.right + 1,
+    top: f.top,
+    width: r - 2,
+    height: f.height
+  };
+}
+function dt(o, t) {
+  return o.area === t.area && o.left === t.left && o.top === t.top && o.width === t.width && o.height === t.height;
+}
+function ct(o, { x: t, y: e, w: n, h: i }) {
+  o.style.left = `${t}px`, o.style.top = `${e}px`, o.style.width = `${n}px`, o.style.height = `${i}px`;
+}
+function ht(o, t) {
+  return {
+    x: o.x,
+    y: o.y + t,
+    w: o.w,
+    h: Math.max(0, o.h - t)
+  };
+}
+function ut(o) {
+  let t = null, e = null;
+  const n = () => {
+    e = null;
+    const i = t;
+    t = null, i && o(i.value);
+  };
+  return {
+    schedule(i) {
+      t = { value: i }, e === null && (e = requestAnimationFrame(n));
+    },
+    flush() {
+      e !== null && (cancelAnimationFrame(e), n());
+    },
+    cancel() {
+      e !== null && cancelAnimationFrame(e), e = null, t = null;
+    }
+  };
 }
 (() => {
   if (typeof window > "u") return;
-  const I = "color: #03A9F4; font-weight: bold; line-height: 1.2;", t = "color: #E0E0E0; font-size: 12px;", e = "color: #42a5f5; font-size: 12px;", i = "color: #9E9E9E; font-size: 10px;", n = `
+  const o = "color: #03A9F4; font-weight: bold; line-height: 1.2;", t = "color: #E0E0E0; font-size: 12px;", e = "color: #42a5f5; font-size: 12px;", n = "color: #9E9E9E; font-size: 10px;", i = `
 ██████╗ ██╗   ██╗ ███╗   ██╗  █████╗  ███╗   ███╗ ██████╗ ██╗  ██╗
 ██╔══██╗╚██╗ ██╔╝ ████╗  ██║ ██╔══██╗ ████╗ ████║ ╚═██╔═╝ ╚██╗██╔╝
 ██║  ██║ ╚████╔╝  ██╔██╗ ██║ ███████║ ██╔████╔██║   ██║    ╚███╔╝ 
@@ -963,7 +1193,7 @@ class x {
   console.groupCollapsed(
     "%cDYNAMIX LAYOUT (click to expand)",
     "color: #03A9F4; font-weight: bold; font-size: 14px;"
-  ), console.log(`%c${n}`, I), console.log("%c A powerful, dynamic layout system 🚀", t), console.log(
+  ), console.log(`%c${i}`, o), console.log("%c A powerful, dynamic layout system 🚀", t), console.log(
     `%c ⚡ For docs and more info, 
  ⚡ visit: https://github.com/akash-aman/dynamix-layout`,
     e
@@ -988,7 +1218,7 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-`, i), console.groupEnd(), typeof window < "u" && (window.__DYNAMIX_LAYOUT__ = {
+`, n), console.groupEnd(), typeof window < "u" && (window.__DYNAMIX_LAYOUT__ = {
     __LICENSE__: `MIT License
 
 Copyright (c) 2025 Akash Aman <sir.akashaman@gmail.com> (https://akash.cx)
@@ -1011,15 +1241,22 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 `,
-    __LAYOUT__: c
+    __LAYOUT__: w
   });
 })();
 export {
-  x as Bond,
-  c as DynamixLayoutCore,
+  O as Bond,
+  w as DynamixLayoutCore,
   a as Node,
-  N as Queue,
-  O as areNodeOptionsEqual,
+  b as Queue,
+  A as areNodeOptionsEqual,
   E as areNodeOptionsMapEqual,
-  g as createReactiveState
+  ut as createFrameScheduler,
+  x as createReactiveState,
+  rt as getNavbarDropPreview,
+  at as getRootSplitPreview,
+  ht as getTabBodyRect,
+  st as getTabsetDropPreview,
+  dt as isSameDropPreview,
+  ct as setElementRect
 };