@vobs/table 1.1.0 → 1.2.1

package/dist/data-table.js

@@ -0,0 +1,1669 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = owner?.handleError(error) ?? false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function readDebugValue(read) {
+  try {
+    return read();
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(readDebugValue, "readDebugValue");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function registerHmrInstance(moduleId, instance) {
+  const instances = getModule(moduleId).instances;
+  instances.add(instance);
+  return () => instances.delete(instance);
+}
+__name(registerHmrInstance, "registerHmrInstance");
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+function getModule(moduleId) {
+  let module = hmrGlobal.modules.get(moduleId);
+  if (!module) {
+    module = { components: /* @__PURE__ */ new Map(), state: /* @__PURE__ */ new Map(), instances: /* @__PURE__ */ new Set() };
+    hmrGlobal.modules.set(moduleId, module);
+  }
+  return module;
+}
+__name(getModule, "getModule");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+function associateHmrInstance(node, instance) {
+  hmrInstances.set(node, instance);
+}
+__name(associateHmrInstance, "associateHmrInstance");
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+var eventBindings = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createText(content) {
+  return getRenderer().createText(content);
+}
+__name(createText, "createText");
+function createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function setProperty(node, key, value) {
+  getRenderer().setProperty(node, key, value);
+}
+__name(setProperty, "setProperty");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+function addEventListener(node, event, handler) {
+  const renderer = getRenderer();
+  const owner = getCurrentOwner();
+  let bindings = eventBindings.get(node);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Map();
+    eventBindings.set(node, bindings);
+  }
+  const previous = bindings.get(event);
+  if (previous && previous.original === handler && previous.owner === owner) return;
+  if (previous) renderer.removeEventListener(node, event, previous.handler);
+  const listener = owner ? (reason) => {
+    try {
+      owner.run(() => handler(reason));
+    } catch (error) {
+      const handled = owner.handleError(error);
+      invokeRuntimeDebug("error", {
+        error,
+        owner,
+        phase: "event",
+        handled,
+        recovery: handled ? "handled" : "propagated"
+      });
+      if (!handled) throw error;
+    }
+  } : handler;
+  const binding = { handler: listener, owner, original: handler };
+  bindings.set(event, binding);
+  renderer.addEventListener(node, event, listener);
+  owner?.onDispose(() => {
+    if (bindings?.get(event) !== binding) return;
+    bindings.delete(event);
+    renderer.removeEventListener(node, event, listener);
+  });
+}
+__name(addEventListener, "addEventListener");
+function createComponent(component, props, source) {
+  const owner = createOwner();
+  const componentName = component.displayName || component.name || "anonymous";
+  setOwnerDebugName(owner, source ? `${componentName} (${source.file}:${source.line}:${source.column})` : componentName);
+  owner.onError((reason) => {
+    attachSourceLocation(reason, source);
+    attachComponentContext(reason, componentName, owner.id);
+    throw reason;
+  });
+  let node;
+  try {
+    node = owner.run(() => component(props));
+  } catch (error) {
+    owner.dispose();
+    attachSourceLocation(error, source);
+    attachComponentContext(error, componentName, owner.id);
+    throw error;
+  }
+  associateNodeOwner(node, owner);
+  const hmrKey = component.hmrKey;
+  if (hmrKey) {
+    const instance = {
+      node,
+      parent: null,
+      refresh() {
+        const previous = instance.node;
+        const next = owner.run(() => component(props));
+        if (instance.parent && !isVobsFragment(previous) && !isVobsFragment(next)) {
+          getRenderer().insertBefore(instance.parent, next, previous);
+          getRenderer().removeChild(instance.parent, previous);
+        }
+        nodeOwners.delete(previous);
+        nodeOwners.set(next, owner);
+        associateHmrInstance(next, instance);
+        instance.node = next;
+      }
+    };
+    associateHmrInstance(node, instance);
+    const separator = hmrKey.lastIndexOf(":");
+    const moduleId = separator < 0 ? hmrKey : hmrKey.slice(0, separator);
+    const cleanup = registerHmrInstance(moduleId, instance);
+    owner.onDispose(cleanup);
+  }
+  return node;
+}
+__name(createComponent, "createComponent");
+function attachSourceLocation(reason, source) {
+  if (!source || (!reason || typeof reason !== "object" && typeof reason !== "function")) return;
+  const error = reason;
+  if (error.vobsSource) return;
+  try {
+    Object.defineProperty(error, "vobsSource", {
+      configurable: true,
+      enumerable: false,
+      value: source,
+      writable: false
+    });
+  } catch {
+  }
+}
+__name(attachSourceLocation, "attachSourceLocation");
+function attachComponentContext(reason, component, ownerId) {
+  if (!reason || typeof reason !== "object" && typeof reason !== "function") return;
+  const error = reason;
+  try {
+    if (!error.vobsComponent) Object.defineProperty(error, "vobsComponent", { configurable: true, enumerable: false, value: component, writable: false });
+    if (!error.vobsOwnerId) Object.defineProperty(error, "vobsOwnerId", { configurable: true, enumerable: false, value: ownerId, writable: false });
+  } catch {
+  }
+}
+__name(attachComponentContext, "attachComponentContext");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const owner = getCurrentOwner();
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// packages/table/src/utils.ts
+function readProp(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp, "readProp");
+function hasProp(props, name) {
+  return name in props;
+}
+__name(hasProp, "hasProp");
+function bindClassList(root, props, classes) {
+  effect(() => {
+    const userClasses = [readString(props, "class"), readString(props, "className")];
+    setAttribute(root, "class", [...classes(), ...userClasses].filter(Boolean).join(" "));
+  });
+}
+__name(bindClassList, "bindClassList");
+function bindCommonAttributes(root, props, skip) {
+  const ignored = /* @__PURE__ */ new Set([...skip, "class", "className", "style", "children"]);
+  effect(() => {
+    for (const name of Object.keys(props)) {
+      if (ignored.has(name) || name.startsWith("on")) continue;
+      if (name !== "id" && name !== "title" && name !== "role" && name !== "tabIndex" && !name.startsWith("aria-") && !name.startsWith("data-")) continue;
+      const value = Reflect.get(props, name);
+      if (value === void 0 || value === null || value === false) removeAttribute(root, normalizeAttributeName(name));
+      else setAttribute(root, normalizeAttributeName(name), String(value));
+    }
+  });
+}
+__name(bindCommonAttributes, "bindCommonAttributes");
+function bindStyle(root, props, internal = () => "") {
+  effect(() => {
+    const value = [internal(), readString(props, "style")].filter(Boolean).join("; ");
+    if (value) setAttribute(root, "style", value);
+    else removeAttribute(root, "style");
+  });
+}
+__name(bindStyle, "bindStyle");
+function resolveSlot(value) {
+  const resolved = typeof value === "function" ? value() : value;
+  if (resolved === void 0 || resolved === null) return null;
+  if (typeof resolved === "string" || typeof resolved === "number") return createText(String(resolved));
+  if (Array.isArray(resolved)) {
+    return createFragment((parent, anchor) => {
+      for (const child of resolved) {
+        const node = resolveSlot(child);
+        if (node) insertBefore(parent, node, anchor);
+      }
+    });
+  }
+  return resolved;
+}
+__name(resolveSlot, "resolveSlot");
+function setOptionalAttribute(node, name, value) {
+  if (value === void 0 || value === null || value === false || value === "") removeAttribute(node, name);
+  else setAttribute(node, name, String(value));
+}
+__name(setOptionalAttribute, "setOptionalAttribute");
+function normalizePixels(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? `${value}px` : value;
+}
+__name(normalizePixels, "normalizePixels");
+function createDefaultColumnSettings(columns, visibleColumnIds) {
+  const columnOrder = columns.map((column) => column.id);
+  const requested = new Set(visibleColumnIds ?? columns.filter((column) => column.visible !== false).map((column) => column.id));
+  const visible = columnOrder.filter((id) => requested.has(id) && columns.some((column) => column.id === id && column.visible !== false));
+  if (visible.length === 0) {
+    const fallback = columns.find((column) => column.visible !== false);
+    if (fallback) visible.push(fallback.id);
+  }
+  return { visibleColumnIds: visible, columnOrder, columnWidths: {} };
+}
+__name(createDefaultColumnSettings, "createDefaultColumnSettings");
+function normalizeColumnSettings(columns, settings, visibleColumnIds) {
+  const fallback = createDefaultColumnSettings(columns, visibleColumnIds);
+  const knownIds = new Set(fallback.columnOrder);
+  const configuredOrder = Array.isArray(settings?.columnOrder) ? settings.columnOrder : void 0;
+  const order = uniqueKnownIds(configuredOrder, knownIds);
+  for (const id of fallback.columnOrder) {
+    if (!order.includes(id)) order.push(id);
+  }
+  const configuredVisible = Array.isArray(settings?.visibleColumnIds) ? settings.visibleColumnIds : void 0;
+  const requestedVisible = new Set(configuredVisible ?? fallback.visibleColumnIds);
+  const visible = order.filter((id) => requestedVisible.has(id) && columns.some((column) => column.id === id && column.visible !== false));
+  if (visible.length === 0) {
+    const fallbackVisible = order.find((id) => columns.some((column) => column.id === id && column.visible !== false));
+    if (fallbackVisible) visible.push(fallbackVisible);
+  }
+  const columnWidths = {};
+  const configuredWidths = settings?.columnWidths && typeof settings.columnWidths === "object" && !Array.isArray(settings.columnWidths) ? settings.columnWidths : {};
+  for (const [id, width] of Object.entries(configuredWidths)) {
+    if (knownIds.has(id) && isColumnWidthValue(width)) columnWidths[id] = width;
+  }
+  return { visibleColumnIds: visible, columnOrder: order, columnWidths };
+}
+__name(normalizeColumnSettings, "normalizeColumnSettings");
+function orderColumns(columns, columnOrder) {
+  if (!columnOrder || columnOrder.length === 0) return columns;
+  const byId = new Map(columns.map((column) => [column.id, column]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of columnOrder) {
+    const column = byId.get(id);
+    if (column && !seen.has(id)) {
+      ordered.push(column);
+      seen.add(id);
+    }
+  }
+  for (const column of columns) {
+    if (!seen.has(column.id)) ordered.push(column);
+  }
+  return ordered;
+}
+__name(orderColumns, "orderColumns");
+function isColumnWidthValue(value) {
+  return typeof value === "number" ? Number.isFinite(value) && value > 0 : typeof value === "string" && value.trim().length > 0 && !/[;{}]/u.test(value);
+}
+__name(isColumnWidthValue, "isColumnWidthValue");
+function uniqueKnownIds(values, knownIds) {
+  const result = [];
+  for (const id of values ?? []) {
+    if (knownIds.has(id) && !result.includes(id)) result.push(id);
+  }
+  return result;
+}
+__name(uniqueKnownIds, "uniqueKnownIds");
+function readString(props, name) {
+  const value = Reflect.get(props, name);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString, "readString");
+function normalizeAttributeName(name) {
+  return name === "tabIndex" ? "tabindex" : name;
+}
+__name(normalizeAttributeName, "normalizeAttributeName");
+function removeAttribute(node, name) {
+  node.removeAttribute(name);
+}
+__name(removeAttribute, "removeAttribute");
+
+// packages/ui/src/utils.ts
+function readProp2(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp2, "readProp");
+function hasProp2(props, name) {
+  return name in props;
+}
+__name(hasProp2, "hasProp");
+function mountSlot(parent, props, propName) {
+  insertDynamic(parent, null, () => resolveSlot2(Reflect.get(props, propName)));
+}
+__name(mountSlot, "mountSlot");
+function resolveSlot2(value) {
+  const resolved = typeof value === "function" ? value() : value;
+  if (resolved === void 0 || resolved === null || resolved === false) return null;
+  if (typeof resolved === "string" || typeof resolved === "number") return createText(String(resolved));
+  if (Array.isArray(resolved)) {
+    const children = resolved;
+    return createFragment((parent, anchor) => {
+      for (const child of children) {
+        const node = resolveSlot2(child);
+        if (node) insertBefore(parent, node, anchor);
+      }
+    });
+  }
+  return resolved;
+}
+__name(resolveSlot2, "resolveSlot");
+
+// packages/icon-core/src/index.ts
+function createSvgIconNode(source, props = {}, options = {}) {
+  const root = createElement("span");
+  effect(() => {
+    updateSvgIconNode(root, typeof source === "function" ? source() : source, props, options);
+  });
+  return root;
+}
+__name(createSvgIconNode, "createSvgIconNode");
+function updateSvgIconNode(root, definition, props, options) {
+  const size = readProp3(props, "size", void 0);
+  const width = readProp3(props, "width", size);
+  const height = readProp3(props, "height", size);
+  const normalizedWidth = normalizeSvgLength(width);
+  const normalizedHeight = normalizeSvgLength(height);
+  const userClass = [
+    readProp3(props, "class", void 0),
+    readProp3(props, "className", void 0)
+  ].filter(hasText).join(" ");
+  const className = [options.class, options.className, userClass].filter(hasText).join(" ");
+  setAttribute(root, "class", className);
+  const internalStyle = size === void 0 ? "" : `width: ${normalizeCssLength(size)}; height: ${normalizeCssLength(size)}`;
+  const userStyle = readProp3(props, "style", void 0);
+  const style = [internalStyle, userStyle].filter(hasText).join("; ");
+  setOptionalAttribute2(root, "style", style || void 0);
+  const managedAttributes = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(props)) {
+    if (name === "class" || name === "className" || name === "style" || name === "children") continue;
+    if (!name.startsWith("aria-") && !name.startsWith("data-") && !["id", "title", "role", "tabIndex"].includes(name)) continue;
+    const value = Reflect.get(props, name);
+    if (value === void 0 || value === null || value === false) continue;
+    managedAttributes.set(name === "tabIndex" ? "tabindex" : name, String(value));
+  }
+  for (const [name, value] of managedAttributes) setAttribute(root, name, value);
+  clearStaleAttributes(root, managedAttributes);
+  const title = readProp3(props, "title", void 0);
+  const ariaLabel = Reflect.get(props, "aria-label");
+  const decorative = readProp3(props, "decorative", title === void 0 && ariaLabel === void 0);
+  setOptionalAttribute2(root, "aria-hidden", decorative ? "true" : void 0);
+  setOptionalAttribute2(root, "aria-label", ariaLabel === void 0 ? title : void 0);
+  setOptionalAttribute2(root, "data-icon-name", options.dataIconName ?? definition?.name);
+  setOptionalAttribute2(root, "color", readProp3(props, "color", void 0));
+  if (!definition) {
+    setProperty(root, "innerHTML", "");
+    return;
+  }
+  const svgAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    viewBox: definition.viewBox ?? "0 0 24 24",
+    ...options.defaultSvgAttributes,
+    ...definition.attributes,
+    ...normalizedWidth === void 0 ? {} : { width: normalizedWidth },
+    ...normalizedHeight === void 0 ? {} : { height: normalizedHeight },
+    ...readProp3(props, "color", void 0) === void 0 ? {} : { color: readProp3(props, "color", void 0) },
+    ...readProp3(props, "stroke", void 0) === void 0 ? {} : { stroke: readProp3(props, "stroke", void 0) },
+    ...readProp3(props, "fill", void 0) === void 0 ? {} : { fill: readProp3(props, "fill", void 0) },
+    ...readProp3(props, "strokeWidth", void 0) === void 0 ? {} : { "stroke-width": readProp3(props, "strokeWidth", void 0) }
+  };
+  const markup = Object.entries(svgAttributes).filter(([, value]) => value !== void 0).map(([name, value]) => `${name}="${escapeXml(String(value))}"`).join(" ");
+  const titleMarkup = title === void 0 ? "" : `<title>${escapeXml(title)}</title>`;
+  setProperty(root, "innerHTML", `<svg ${markup} aria-hidden="true">${titleMarkup}${definition.body}</svg>`);
+}
+__name(updateSvgIconNode, "updateSvgIconNode");
+function readProp3(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp3, "readProp");
+function hasText(value) {
+  return value !== void 0 && value.trim() !== "";
+}
+__name(hasText, "hasText");
+function normalizeSvgLength(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? String(value) : value;
+}
+__name(normalizeSvgLength, "normalizeSvgLength");
+function normalizeCssLength(value) {
+  return typeof value === "number" || /^\d+(?:\.\d+)?$/u.test(value) ? `${value}px` : value;
+}
+__name(normalizeCssLength, "normalizeCssLength");
+function setOptionalAttribute2(node, name, value) {
+  if (value === void 0 || value === null || value === false || value === "") {
+    node.removeAttribute(name);
+    return;
+  }
+  setAttribute(node, name, String(value));
+}
+__name(setOptionalAttribute2, "setOptionalAttribute");
+function clearStaleAttributes(node, next) {
+  const previous = node.__vobsIconAttributes ?? /* @__PURE__ */ new Set();
+  for (const name of previous) {
+    if (!next.has(name)) node.removeAttribute(name);
+  }
+  node.__vobsIconAttributes = new Set(next.keys());
+}
+__name(clearStaleAttributes, "clearStaleAttributes");
+function escapeXml(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;").replace(/"/gu, "&quot;");
+}
+__name(escapeXml, "escapeXml");
+
+// packages/ui/src/icon.ts
+function Icon(props = {}) {
+  const root = createSvgIconNode(() => {
+    const definition = resolveIcon(
+      readProp2(props, "icon", void 0) ?? readProp2(props, "name", void 0)
+    );
+    if (!definition) {
+      if (hasProp2(props, "children")) return void 0;
+      throw new Error("Vobs UI: Icon requires a registered `name` or an `icon` definition");
+    }
+    return iconDefinitionToSvg(definition);
+  }, props, {
+    class: "vui-icon icon",
+    defaultSvgAttributes: {
+      fill: "none",
+      stroke: "currentColor",
+      "stroke-width": 2,
+      "stroke-linecap": "butt",
+      "stroke-linejoin": "miter"
+    }
+  });
+  if (hasProp2(props, "children")) mountSlot(root, props, "children");
+  return root;
+}
+__name(Icon, "Icon");
+function iconDefinitionToSvg(definition) {
+  return {
+    name: definition.name,
+    body: definition.path,
+    viewBox: definition.viewBox
+  };
+}
+__name(iconDefinitionToSvg, "iconDefinitionToSvg");
+var VUI_ICON_PATHS = {
+  search: '<circle cx="11" cy="11" r="7"/><path d="m20 20-3.5-3.5"/>',
+  check: '<polyline points="4 12 10 18 20 6"/>',
+  x: '<line x1="6" y1="6" x2="18" y2="18"/><line x1="18" y1="6" x2="6" y2="18"/>',
+  plus: '<line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/>',
+  minus: '<line x1="5" y1="12" x2="19" y2="12"/>',
+  "chevron-right": '<polyline points="9 6 15 12 9 18"/>',
+  "chevron-down": '<polyline points="6 9 12 15 18 9"/>',
+  "chevron-up": '<polyline points="6 15 12 9 18 15"/>',
+  "chevron-left": '<polyline points="15 6 9 12 15 18"/>',
+  "arrow-left": '<line x1="20" y1="12" x2="4" y2="12"/><polyline points="10 6 4 12 10 18"/>',
+  "arrow-right": '<line x1="4" y1="12" x2="20" y2="12"/><polyline points="14 6 20 12 14 18"/>',
+  "arrow-up": '<line x1="12" y1="20" x2="12" y2="4"/><polyline points="6 10 12 4 18 10"/>',
+  "arrow-down": '<line x1="12" y1="4" x2="12" y2="20"/><polyline points="6 14 12 20 18 14"/>',
+  atom: '<circle cx="12" cy="12" r="2"/><ellipse cx="12" cy="12" rx="10" ry="4"/><ellipse cx="12" cy="12" rx="10" ry="4" transform="rotate(60 12 12)"/><ellipse cx="12" cy="12" rx="10" ry="4" transform="rotate(120 12 12)"/>',
+  globe: '<circle cx="12" cy="12" r="9"/><path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18"/>',
+  "arrow-expand": '<polyline points="14 4 20 4 20 10"/><line x1="14" y1="10" x2="20" y2="4"/><polyline points="10 20 4 20 4 14"/><line x1="10" y1="14" x2="4" y2="20"/>',
+  "arrow-minimize": '<polyline points="20 4 14 10 20 10"/><line x1="14" y1="10" x2="14" y2="4"/><polyline points="4 20 10 14 4 14"/><line x1="10" y1="14" x2="10" y2="20"/>',
+  "check-circle": '<circle cx="12" cy="12" r="9"/><polyline points="8 12 11 15 16 9"/>',
+  "alert-circle": '<circle cx="12" cy="12" r="9"/><line x1="12" y1="8" x2="12" y2="13"/><line x1="12" y1="16" x2="12" y2="16.01"/>',
+  "alert-triangle": '<path d="M12 3 22 20 2 20 Z"/><line x1="12" y1="10" x2="12" y2="15"/><line x1="12" y1="18" x2="12" y2="18.01"/>',
+  info: '<circle cx="12" cy="12" r="9"/><line x1="12" y1="11" x2="12" y2="16"/><line x1="12" y1="8" x2="12" y2="8.01"/>',
+  home: '<polygon points="3 11 12 3 21 11 21 21 14 21 14 14 10 14 10 21 3 21 3 11"/>',
+  user: '<path d="M4 21v-1a6 6 0 0 1 6-6h4a6 6 0 0 1 6 6v1"/><circle cx="12" cy="8" r="4"/>',
+  settings: '<circle cx="12" cy="12" r="3"/><path d="M19.4 15a1.7 1.7 0 0 0 .3 1.8l.1.1a2 2 0 1 1-2.8 2.8l-.1-.1a1.7 1.7 0 0 0-1.8-.3 1.7 1.7 0 0 0-1 1.5V21a2 2 0 1 1-4 0v-.1a1.7 1.7 0 0 0-1-1.5 1.7 1.7 0 0 0-1.8.3l-.1.1a2 2 0 1 1-2.8-2.8l.1-.1a1.7 1.7 0 0 0 .3-1.8 1.7 1.7 0 0 0-1.5-1H3a2 2 0 1 1 0-4h.1a1.7 1.7 0 0 0 1.5-1 1.7 1.7 0 0 0-.3-1.8l-.1-.1a2 2 0 1 1 2.8-2.8l.1.1a1.7 1.7 0 0 0 1.8.3H9a1.7 1.7 0 0 0 1-1.5V3a2 2 0 1 1 4 0v.1a1.7 1.7 0 0 0 1 1.5 1.7 1.7 0 0 0 1.8-.3l.1-.1a2 2 0 1 1 2.8 2.8l-.1.1a1.7 1.7 0 0 0-.3 1.8V9a1.7 1.7 0 0 0 1.5 1H21a2 2 0 1 1 0 4h-.1a1.7 1.7 0 0 0-1.5 1z"/>',
+  menu: '<line x1="4" y1="6" x2="20" y2="6"/><line x1="4" y1="12" x2="20" y2="12"/><line x1="4" y1="18" x2="20" y2="18"/>',
+  "more-h": '<circle cx="5" cy="12" r="1.5" fill="currentColor"/><circle cx="12" cy="12" r="1.5" fill="currentColor"/><circle cx="19" cy="12" r="1.5" fill="currentColor"/>',
+  calendar: '<rect x="3" y="5" width="18" height="16"/><line x1="3" y1="10" x2="21" y2="10"/><line x1="8" y1="3" x2="8" y2="7"/><line x1="16" y1="3" x2="16" y2="7"/>',
+  filter: '<polygon points="3 4 21 4 14 12 14 20 10 18 10 12 3 4"/>',
+  sort: '<path d="M8 20V4"/><polyline points="4 8 8 4 12 8"/><path d="M16 4v16"/><polyline points="12 16 16 20 20 16"/>',
+  edit: '<path d="M4 20h4l10-10-4-4L4 16v4z"/><path d="M14 6l4 4"/>',
+  trash: '<polyline points="4 6 20 6"/><path d="M6 6v14h12V6"/><path d="M9 6V4h6v2"/><line x1="10" y1="10" x2="10" y2="17"/><line x1="14" y1="10" x2="14" y2="17"/>',
+  download: '<path d="M12 3v12"/><polyline points="7 10 12 15 17 10"/><line x1="3" y1="21" x2="21" y2="21"/>',
+  upload: '<path d="M12 21V6"/><polyline points="7 11 12 6 17 11"/><line x1="3" y1="21" x2="21" y2="21"/>',
+  pause: '<line x1="9" y1="5" x2="9" y2="19"/><line x1="15" y1="5" x2="15" y2="19"/>',
+  play: '<polygon points="8 5 19 12 8 19 8 5"/>',
+  refresh: '<polyline points="21 4 21 10 15 10"/><polyline points="3 20 3 14 9 14"/><path d="M20.5 9A9 9 0 0 0 5 5.5L3 7M3.5 15A9 9 0 0 0 19 18.5L21 17"/>',
+  bell: '<path d="M6 8a6 6 0 0 1 12 0c0 7 3 8 3 8H3s3-1 3-8z"/><path d="M10 21a2 2 0 0 0 4 0"/>',
+  folder: '<path d="M3 6h6l2 3h10v10H3z"/>',
+  code: '<polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/>',
+  sparkles: '<path d="M12 3l1.8 4.2L18 9l-4.2 1.8L12 15l-1.8-4.2L6 9l4.2-1.8L12 3z"/><path d="M19 14l1 2.2 2.2 1-2.2 1L19 20.4l-1-2.2-2.2-1 2.2-1L19 14z"/>',
+  zap: '<polygon points="13 2 4 14 12 14 11 22 20 10 12 10 13 2"/>',
+  sun: '<circle cx="12" cy="12" r="4"/><line x1="12" y1="2" x2="12" y2="5"/><line x1="12" y1="19" x2="12" y2="22"/><line x1="2" y1="12" x2="5" y2="12"/><line x1="19" y1="12" x2="22" y2="12"/><line x1="4.6" y1="4.6" x2="6.7" y2="6.7"/><line x1="17.3" y1="17.3" x2="19.4" y2="19.4"/><line x1="4.6" y1="19.4" x2="6.7" y2="17.3"/><line x1="17.3" y1="6.7" x2="19.4" y2="4.6"/>',
+  moon: '<path d="M21 12.8A9 9 0 1 1 11.2 3a7 7 0 0 0 9.8 9.8z"/>',
+  terminal: '<polyline points="4 7 9 12 4 17"/><line x1="12" y1="17" x2="20" y2="17"/>'
+};
+var iconRegistry = new Map(
+  Object.entries(VUI_ICON_PATHS).map(([name, path]) => [name, { name, path }])
+);
+function resolveIcon(icon) {
+  return typeof icon === "string" ? iconRegistry.get(icon) : icon;
+}
+__name(resolveIcon, "resolveIcon");
+
+// packages/table/src/icons.ts
+function defaultIcons() {
+  return {
+    ascending: /* @__PURE__ */ __name(() => createComponent(Icon, { name: "chevron-up" }), "ascending"),
+    descending: /* @__PURE__ */ __name(() => createComponent(Icon, { name: "chevron-down" }), "descending"),
+    unsorted: /* @__PURE__ */ __name(() => createComponent(Icon, { name: "sort" }), "unsorted"),
+    previous: /* @__PURE__ */ __name(() => createComponent(Icon, { name: "chevron-left" }), "previous"),
+    next: /* @__PURE__ */ __name(() => createComponent(Icon, { name: "chevron-right" }), "next")
+  };
+}
+__name(defaultIcons, "defaultIcons");
+
+// packages/table/src/data-table.ts
+var internalQueries = /* @__PURE__ */ new WeakMap();
+var DEFAULT_PAGE_SIZE = 25;
+var DEFAULT_PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
+var DEFAULT_ROW_HEIGHT = 40;
+var DEFAULT_VIRTUAL_HEIGHT = 400;
+var textCollator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+function KitDataTable(props = {}) {
+  const root = createElement("section");
+  const toolbar = createElement("div");
+  const viewport = createElement("div");
+  const table = createElement("table");
+  const head = createElement("thead");
+  const body = createElement("tbody");
+  const footer = createElement("footer");
+  const scrollTop = state(0);
+  internalQueries.set(props, state({
+    page: 1,
+    pageSize: DEFAULT_PAGE_SIZE,
+    sort: null,
+    filters: {}
+  }));
+  bindClassList(root, props, () => [
+    "vobs-data-table",
+    readProp(props, "stickyHeader", true) ? "vobs-data-table--sticky-header" : void 0
+  ]);
+  bindCommonAttributes(root, props, [
+    "columns",
+    "rows",
+    "resource",
+    "rowKey",
+    "page",
+    "pageSize",
+    "total",
+    "sort",
+    "filters",
+    "columnSettings",
+    "sortingMode",
+    "visibleColumnIds",
+    "virtual",
+    "stickyHeader",
+    "virtualHeight",
+    "rowHeight",
+    "overscan",
+    "loading",
+    "empty",
+    "error",
+    "toolbar",
+    "footer",
+    "pagination",
+    "paginationMode",
+    "icons",
+    "previousLabel",
+    "nextLabel",
+    "jumpToLabel",
+    "jumpToPlaceholder",
+    "jumpToSubmitLabel",
+    "pageSizeOptions",
+    "pageSizeLabel",
+    "pageLabel",
+    "onQueryChange",
+    "onRowClick",
+    "onVisibleColumnIdsChange"
+  ]);
+  bindStyle(root, props);
+  setAttribute(toolbar, "class", "vobs-data-table__toolbar");
+  setAttribute(viewport, "class", "vobs-data-table__viewport");
+  setAttribute(viewport, "data-vobs-scrollable", "true");
+  setAttribute(table, "class", "vobs-data-table__table");
+  setAttribute(footer, "class", "vobs-data-table__footer");
+  if (hasProp(props, "toolbar")) insertDynamic(toolbar, null, () => resolveSlot(readProp(props, "toolbar", void 0)));
+  effect(() => {
+    setProperty(toolbar, "hidden", !hasProp(props, "toolbar"));
+  });
+  effect(() => {
+    const virtual = readProp(props, "virtual", false);
+    setProperty(viewport, "tabIndex", virtual ? 0 : -1);
+    setAttribute(viewport, "style", virtual ? `max-height: ${normalizeHeight(readProp(props, "virtualHeight", DEFAULT_VIRTUAL_HEIGHT))}; overflow: auto` : "");
+  });
+  addEventListener(viewport, "scroll", () => {
+    scrollTop.value = viewport.scrollTop;
+  });
+  insertDynamic(head, null, () => createHeader(props));
+  insertDynamic(body, null, () => createBody(props, scrollTop.value));
+  insertBefore(table, head, null);
+  insertBefore(table, body, null);
+  insertBefore(viewport, table, null);
+  insertDynamic(footer, null, () => createFooter(props));
+  effect(() => {
+    setProperty(footer, "hidden", !shouldShowFooter(props));
+  });
+  insertBefore(root, toolbar, null);
+  insertBefore(root, viewport, null);
+  insertBefore(root, footer, null);
+  return root;
+}
+__name(KitDataTable, "KitDataTable");
+function createHeader(props) {
+  const columns = visibleColumns(props);
+  return createFragment((parent, anchor) => {
+    const row = createElement("tr");
+    for (const column of columns) {
+      const cell = createElement("th");
+      setAttribute(cell, "scope", "col");
+      setAttribute(cell, "data-column-id", column.id);
+      applyColumnStyle(cell, column, readProp(props, "columnSettings", void 0));
+      if (column.sortable) insertBefore(cell, createSortButton(props, column, cell), null);
+      else insertBefore(cell, createText(column.label), null);
+      insertBefore(row, cell, null);
+    }
+    insertBefore(parent, row, anchor);
+  });
+}
+__name(createHeader, "createHeader");
+function createSortButton(props, column, cell) {
+  const button = createElement("button");
+  const label = createElement("span");
+  const icon = createElement("span");
+  setAttribute(button, "type", "button");
+  setAttribute(button, "class", "vobs-data-table__sort");
+  setAttribute(button, "aria-label", `Sort by ${column.label}`);
+  setAttribute(label, "class", "vobs-data-table__sort-label");
+  setAttribute(icon, "class", "vobs-data-table__sort-icon");
+  insertBefore(label, createText(column.label), null);
+  insertDynamic(icon, null, () => resolveSlot(sortIcon(props, currentSort(props), column.id)));
+  effect(() => {
+    const sort = currentSort(props);
+    const direction = sort?.columnId === column.id ? sort.direction : void 0;
+    setOptionalAttribute(cell, "aria-sort", direction ? direction === "asc" ? "ascending" : "descending" : void 0);
+    setOptionalAttribute(cell, "data-sort-direction", direction);
+  });
+  addEventListener(button, "click", () => {
+    const current = currentSort(props);
+    const next = current?.columnId === column.id ? current.direction === "asc" ? createSort(column, "desc") : null : createSort(column, "asc");
+    emitQuery(props, { ...currentQuery(props), sort: next, page: 1 });
+  });
+  insertBefore(button, label, null);
+  insertBefore(button, icon, null);
+  return button;
+}
+__name(createSortButton, "createSortButton");
+function createBody(props, scrollTop) {
+  const resource = readProp(props, "resource", void 0);
+  if (resource?.error.value) return createStateRow(props, "error", resource.error.value);
+  if (resource?.loading.value && resource.data.value === null) return createStateRow(props, "loading");
+  const page = resolvePage(props);
+  if (page.rows.length === 0) return createStateRow(props, "empty");
+  const columns = visibleColumns(props);
+  const window = resolveWindow(props, page.rows.length, scrollTop);
+  const fragment = createFragment((parent, anchor) => {
+    if (window.before > 0) insertBefore(parent, createSpacerRow(columns.length, window.before), anchor);
+    for (let index = window.start; index < window.end; index++) {
+      insertBefore(parent, createRow(props, page.rows[index], index, columns), anchor);
+    }
+    if (window.after > 0) insertBefore(parent, createSpacerRow(columns.length, window.after), anchor);
+  });
+  return fragment;
+}
+__name(createBody, "createBody");
+function createStateRow(props, kind, error) {
+  const row = createElement("tr");
+  const cell = createElement("td");
+  setAttribute(cell, "class", `vobs-data-table__state vobs-data-table__state--${kind}`);
+  setAttribute(cell, "colspan", String(Math.max(1, visibleColumns(props).length)));
+  let content;
+  if (kind === "error") {
+    const fallback = readProp(props, "error", void 0);
+    const resource = readProp(props, "resource", void 0);
+    content = fallback ? resolveSlot(fallback(error, () => resource?.refetch() ?? Promise.resolve())) : createText(error?.message ?? "Unable to load data");
+  } else {
+    content = resolveSlot(readProp(props, kind, void 0)) ?? createText(kind === "loading" ? "Loading..." : "No data");
+  }
+  if (content) insertBefore(cell, content, null);
+  insertBefore(row, cell, null);
+  return row;
+}
+__name(createStateRow, "createStateRow");
+function createRow(props, row, index, columns) {
+  const tableRow = createElement("tr");
+  const rowKey = readProp(props, "rowKey", void 0);
+  if (rowKey) setOptionalAttribute(tableRow, "data-row-key", rowKey(row, index));
+  const onRowClick = readProp(props, "onRowClick", void 0);
+  if (onRowClick) {
+    setProperty(tableRow, "tabIndex", 0);
+    setAttribute(tableRow, "data-clickable", "true");
+    addEventListener(tableRow, "click", () => onRowClick(row, index));
+  }
+  for (const column of columns) {
+    const cell = createElement("td");
+    setAttribute(cell, "data-column-id", column.id);
+    applyColumnStyle(cell, column, readProp(props, "columnSettings", void 0));
+    insertDynamic(cell, null, () => resolveSlot(column.render ? column.render(row, index) : column.key === void 0 ? void 0 : readRowValue(row, column.key)));
+    insertBefore(tableRow, cell, null);
+  }
+  return tableRow;
+}
+__name(createRow, "createRow");
+function createSpacerRow(columnCount, height) {
+  const row = createElement("tr");
+  const cell = createElement("td");
+  setAttribute(cell, "class", "vobs-data-table__spacer");
+  setAttribute(cell, "colspan", String(Math.max(1, columnCount)));
+  setAttribute(cell, "style", `height: ${height}px`);
+  insertBefore(row, cell, null);
+  return row;
+}
+__name(createSpacerRow, "createSpacerRow");
+function createFooter(props) {
+  const custom = readProp(props, "footer", void 0);
+  if (custom !== void 0) return resolveSlot(custom) ?? createText("");
+  const pagination = resolvePaginationState(props);
+  const root = createElement("div");
+  const summary = createElement("span");
+  setAttribute(root, "class", "vobs-data-table__footer-content");
+  setAttribute(summary, "class", "vobs-data-table__summary");
+  insertBefore(summary, createText(pageLabel(
+    props,
+    pagination.page,
+    pagination.pageCount,
+    pagination.total,
+    pagination.visibleCount,
+    pagination.pageSize
+  )), null);
+  const actions = hasProp(props, "pagination") ? createCustomPagination(props, pagination) : createPagination(props, pagination);
+  insertBefore(root, summary, null);
+  if (actions) insertBefore(root, actions, null);
+  return root;
+}
+__name(createFooter, "createFooter");
+function createCustomPagination(props, pagination) {
+  const custom = readProp(props, "pagination", void 0);
+  if (custom === void 0) return null;
+  const value = typeof custom === "function" ? custom({
+    page: pagination.page,
+    pageCount: pagination.pageCount,
+    pageSize: pagination.pageSize,
+    pageSizeOptions: pageSizeOptions(props, pagination.pageSize),
+    total: pagination.total,
+    visibleCount: pagination.visibleCount,
+    goToPage: /* @__PURE__ */ __name((page) => goToPage(props, page, pagination.pageCount), "goToPage"),
+    setPageSize: /* @__PURE__ */ __name((pageSize) => setPageSize(props, pageSize), "setPageSize")
+  }) : custom;
+  return resolveSlot(value);
+}
+__name(createCustomPagination, "createCustomPagination");
+function createPagination(props, pagination) {
+  const root = createElement("div");
+  const mode = readProp(props, "paginationMode", "simple");
+  setAttribute(root, "class", "vobs-data-table__pagination");
+  setAttribute(root, "data-mode", mode);
+  insertBefore(root, createPageButton(props, "previous", pagination), null);
+  if (mode !== "simple") {
+    const pages = createElement("div");
+    setAttribute(pages, "class", "vobs-data-table__pagination-pages");
+    for (const item of buildPaginationItems(pagination.page, pagination.pageCount)) {
+      insertBefore(pages, typeof item === "number" ? createPageNumberButton(props, item, pagination.page) : createPageEllipsis(item), null);
+    }
+    insertBefore(root, pages, null);
+  }
+  insertBefore(root, createPageButton(props, "next", pagination), null);
+  if (mode === "all") insertBefore(root, createJumpControl(props, pagination), null);
+  insertBefore(root, createPageSizeControl(props, pagination), null);
+  return root;
+}
+__name(createPagination, "createPagination");
+function createPageButton(props, direction, pagination) {
+  const button = createElement("button");
+  const label = direction === "previous" ? readProp(props, "previousLabel", "Previous") : readProp(props, "nextLabel", "Next");
+  const disabled = direction === "previous" ? pagination.page <= 1 : pagination.page >= pagination.pageCount;
+  setAttribute(button, "type", "button");
+  setAttribute(button, "class", "vobs-data-table__page-button");
+  setAttribute(button, "aria-label", label);
+  setProperty(button, "disabled", disabled);
+  const icons = resolveIcons(props);
+  const icon = direction === "previous" ? icons.previous : icons.next;
+  const node = icon === void 0 ? void 0 : resolveSlot(icon);
+  if (node) insertBefore(button, node, null);
+  addEventListener(button, "click", () => {
+    if (disabled) return;
+    const query = currentQuery(props);
+    goToPage(props, direction === "previous" ? query.page - 1 : query.page + 1, pagination.pageCount);
+  });
+  return button;
+}
+__name(createPageButton, "createPageButton");
+function createPageNumberButton(props, page, currentPage) {
+  const button = createElement("button");
+  const active = page === currentPage;
+  setAttribute(button, "type", "button");
+  setAttribute(button, "class", `vobs-data-table__page-button${active ? " is-active" : ""}`);
+  setAttribute(button, "aria-label", `Page ${page}`);
+  if (active) setAttribute(button, "aria-current", "page");
+  insertBefore(button, createText(String(page)), null);
+  addEventListener(button, "click", () => goToPage(props, page, resolvePaginationState(props).pageCount));
+  return button;
+}
+__name(createPageNumberButton, "createPageNumberButton");
+function createPageEllipsis(side) {
+  const ellipsis = createElement("span");
+  setAttribute(ellipsis, "class", "vobs-data-table__page-ellipsis");
+  setAttribute(ellipsis, "aria-hidden", "true");
+  setAttribute(ellipsis, "data-side", side);
+  insertBefore(ellipsis, createText("..."), null);
+  return ellipsis;
+}
+__name(createPageEllipsis, "createPageEllipsis");
+function createJumpControl(props, pagination) {
+  const root = createElement("form");
+  const label = createElement("label");
+  const input = createElement("input");
+  const submit = createElement("button");
+  const jumpLabel = readProp(props, "jumpToLabel", "Go to");
+  setAttribute(root, "class", "vobs-data-table__pagination-jump");
+  setAttribute(label, "class", "vobs-data-table__jump-label");
+  setAttribute(input, "class", "vobs-data-table__jump-input");
+  setAttribute(input, "type", "text");
+  setAttribute(input, "inputmode", "numeric");
+  setAttribute(input, "pattern", "[0-9]*");
+  setAttribute(input, "autocomplete", "off");
+  setAttribute(input, "aria-label", jumpLabel);
+  setAttribute(input, "placeholder", readProp(props, "jumpToPlaceholder", "Page"));
+  setProperty(input, "value", String(pagination.page));
+  setAttribute(submit, "type", "submit");
+  setAttribute(submit, "class", "vobs-data-table__page-button vobs-data-table__jump-submit");
+  setAttribute(submit, "aria-label", readProp(props, "jumpToSubmitLabel", "Go"));
+  insertBefore(label, createText(jumpLabel), null);
+  insertBefore(label, input, null);
+  insertBefore(submit, createText(readProp(props, "jumpToSubmitLabel", "Go")), null);
+  addEventListener(input, "input", () => {
+    const value = input.value.replace(/[^0-9]/gu, "");
+    if (value !== input.value) setProperty(input, "value", value);
+  });
+  addEventListener(root, "submit", (event) => {
+    event.preventDefault();
+    if (!/^\d+$/u.test(input.value)) return;
+    const requested = Number(input.value);
+    if (!Number.isSafeInteger(requested)) return;
+    goToPage(props, requested, pagination.pageCount);
+  });
+  insertBefore(root, label, null);
+  insertBefore(root, submit, null);
+  return root;
+}
+__name(createJumpControl, "createJumpControl");
+function createPageSizeControl(props, pagination) {
+  const root = createElement("label");
+  const select = createElement("select");
+  const label = readProp(props, "pageSizeLabel", "Rows per page");
+  setAttribute(root, "class", "vobs-data-table__page-size");
+  setAttribute(select, "class", "vobs-data-table__page-size-select");
+  setAttribute(select, "aria-label", label);
+  insertBefore(root, createText(label), null);
+  for (const optionValue of pageSizeOptions(props, pagination.pageSize)) {
+    const option = createElement("option");
+    setAttribute(option, "value", String(optionValue));
+    setProperty(option, "textContent", String(optionValue));
+    insertBefore(select, option, null);
+  }
+  setProperty(select, "value", String(pagination.pageSize));
+  addEventListener(select, "change", () => {
+    setPageSize(props, Number(select.value));
+  });
+  insertBefore(root, select, null);
+  return root;
+}
+__name(createPageSizeControl, "createPageSizeControl");
+function resolvePage(props) {
+  const resource = readProp(props, "resource", void 0);
+  const supplied = resource?.data.value ?? readProp(props, "rows", []);
+  const source = normalizeRows(supplied);
+  const query = currentQuery(props);
+  const rows = applyFiltersAndSort(source.rows, visibleColumns(props), query, readProp(props, "sortingMode", "client"));
+  const remoteTotal = source.total ?? readProp(props, "total", void 0);
+  const total = remoteTotal ?? rows.length;
+  const isRemotePage = source.total !== void 0 || readProp(props, "total", void 0) !== void 0;
+  if (isRemotePage) return { rows, total };
+  const start = (query.page - 1) * query.pageSize;
+  return { rows: rows.slice(start, start + query.pageSize), total };
+}
+__name(resolvePage, "resolvePage");
+function normalizeRows(value) {
+  if (isRowArray(value)) return { rows: value };
+  return { rows: value.rows ?? [], total: value.total };
+}
+__name(normalizeRows, "normalizeRows");
+function isRowArray(value) {
+  return Array.isArray(value);
+}
+__name(isRowArray, "isRowArray");
+function applyFiltersAndSort(rows, columns, query, sortingMode) {
+  let result = rows;
+  for (const column2 of columns) {
+    const value = query.filters[column2.id];
+    if (value === void 0 || value === null || value === "") continue;
+    result = result.filter((row) => column2.filter ? column2.filter(row, value) : String(column2.key === void 0 ? "" : readRowValue(row, column2.key)).toLocaleLowerCase().includes(String(value).toLocaleLowerCase()));
+  }
+  if (!query.sort || sortingMode === "server") return result;
+  const column = columns.find((candidate) => candidate.id === query.sort.columnId);
+  if (!column) return result;
+  const direction = query.sort.direction;
+  return result.map((row, index) => ({ row, index })).sort((left, right) => {
+    const compared = compareRows(left.row, right.row, column, direction);
+    return compared === 0 ? left.index - right.index : compared;
+  }).map((entry) => entry.row);
+}
+__name(applyFiltersAndSort, "applyFiltersAndSort");
+function compareRows(left, right, column, direction) {
+  const multiplier = direction === "asc" ? 1 : -1;
+  if (column.compare) return multiplier * column.compare(left, right);
+  const leftValue = column.sortValue ? column.sortValue(left) : column.key === void 0 ? void 0 : readRowValue(left, column.key);
+  const rightValue = column.sortValue ? column.sortValue(right) : column.key === void 0 ? void 0 : readRowValue(right, column.key);
+  const leftMissing = isMissingSortValue(leftValue, column.sortType);
+  const rightMissing = isMissingSortValue(rightValue, column.sortType);
+  if (leftMissing || rightMissing) {
+    if (leftMissing && rightMissing) return 0;
+    return leftMissing ? 1 : -1;
+  }
+  return multiplier * compareSortValues(leftValue, rightValue, column.sortType);
+}
+__name(compareRows, "compareRows");
+function compareSortValues(left, right, sortType) {
+  if (sortType === "number") return compareNumbers(left, right);
+  if (sortType === "date") return compareDates(left, right);
+  if (sortType === "boolean") return Number(Boolean(left)) - Number(Boolean(right));
+  if (sortType === "text") return compareText(left, right);
+  if (typeof left === "number" && typeof right === "number") return compareNumbers(left, right);
+  if (left instanceof Date && right instanceof Date) return compareNumbers(left.getTime(), right.getTime());
+  if (typeof left === "boolean" && typeof right === "boolean") return Number(left) - Number(right);
+  return compareText(left, right);
+}
+__name(compareSortValues, "compareSortValues");
+function compareNumbers(left, right) {
+  return Number(left) - Number(right);
+}
+__name(compareNumbers, "compareNumbers");
+function compareDates(left, right) {
+  const leftTime = left instanceof Date ? left.getTime() : Date.parse(String(left));
+  const rightTime = right instanceof Date ? right.getTime() : Date.parse(String(right));
+  return leftTime - rightTime;
+}
+__name(compareDates, "compareDates");
+function compareText(left, right) {
+  return textCollator.compare(String(left), String(right));
+}
+__name(compareText, "compareText");
+function createSort(column, direction) {
+  return column.sortKey ? { columnId: column.id, direction, sortKey: column.sortKey } : { columnId: column.id, direction };
+}
+__name(createSort, "createSort");
+function isMissingSortValue(value, sortType) {
+  if (value === void 0 || value === null || value === "") return true;
+  if (sortType === "number") return !Number.isFinite(Number(value));
+  if (sortType === "date") {
+    const timestamp = value instanceof Date ? value.getTime() : Date.parse(String(value));
+    return !Number.isFinite(timestamp);
+  }
+  return false;
+}
+__name(isMissingSortValue, "isMissingSortValue");
+function resolveWindow(props, count, scrollTop) {
+  if (!readProp(props, "virtual", false)) return { start: 0, end: count, before: 0, after: 0 };
+  const rowHeight = normalizePositive(readProp(props, "rowHeight", DEFAULT_ROW_HEIGHT), DEFAULT_ROW_HEIGHT);
+  const viewportHeight = normalizePositive(readProp(props, "virtualHeight", DEFAULT_VIRTUAL_HEIGHT), DEFAULT_VIRTUAL_HEIGHT);
+  const overscan = Math.max(0, Math.floor(readProp(props, "overscan", 5)));
+  const start = Math.max(0, Math.floor(scrollTop / rowHeight) - overscan);
+  const end = Math.min(count, Math.ceil((scrollTop + viewportHeight) / rowHeight) + overscan);
+  return { start, end, before: start * rowHeight, after: (count - end) * rowHeight };
+}
+__name(resolveWindow, "resolveWindow");
+function unwrapQueryValue(value) {
+  return typeof value === "number" ? value : value.value;
+}
+__name(unwrapQueryValue, "unwrapQueryValue");
+function currentQuery(props) {
+  const internal = internalQueries.get(props)?.value;
+  const page = unwrapQueryValue(readProp(props, "page", internal?.page ?? 1));
+  const pageSize = unwrapQueryValue(readProp(props, "pageSize", internal?.pageSize ?? DEFAULT_PAGE_SIZE));
+  return {
+    page: Math.max(1, Math.floor(page)),
+    pageSize: normalizePositive(pageSize, DEFAULT_PAGE_SIZE),
+    sort: readProp(props, "sort", internal?.sort ?? null),
+    filters: readProp(props, "filters", internal?.filters ?? {})
+  };
+}
+__name(currentQuery, "currentQuery");
+function readSignalProp(props, name) {
+  const value = Reflect.get(props, name);
+  return value && typeof value === "object" && "value" in value ? value : void 0;
+}
+__name(readSignalProp, "readSignalProp");
+function emitQuery(props, query) {
+  const internal = internalQueries.get(props);
+  if (internal) internal.value = query;
+  const pageSignal = readSignalProp(props, "page");
+  if (pageSignal) pageSignal.value = query.page;
+  const pageSizeSignal = readSignalProp(props, "pageSize");
+  if (pageSizeSignal) pageSizeSignal.value = query.pageSize;
+  readProp(props, "onQueryChange", void 0)?.(query);
+}
+__name(emitQuery, "emitQuery");
+function currentSort(props) {
+  return currentQuery(props).sort;
+}
+__name(currentSort, "currentSort");
+function visibleColumns(props) {
+  const columns = readProp(props, "columns", []);
+  const rawSettings = readProp(props, "columnSettings", void 0);
+  const settings = rawSettings ? normalizeColumnSettings(columns, rawSettings) : void 0;
+  const ids = settings?.visibleColumnIds ?? readProp(props, "visibleColumnIds", void 0);
+  const visible = ids ? new Set(ids) : void 0;
+  return orderColumns(columns, settings?.columnOrder).filter((column) => column.visible !== false && (!visible || visible.has(column.id)));
+}
+__name(visibleColumns, "visibleColumns");
+function resolveIcons(props) {
+  return { ...defaultIcons(), ...readProp(props, "icons", void 0) ?? {} };
+}
+__name(resolveIcons, "resolveIcons");
+function sortIcon(props, sort, columnId) {
+  const icons = resolveIcons(props);
+  if (sort?.columnId !== columnId) return icons.unsorted;
+  return sort.direction === "asc" ? icons.ascending : icons.descending;
+}
+__name(sortIcon, "sortIcon");
+function pageLabel(props, page, pageCount, total, visibleCount, pageSize) {
+  return readProp(props, "pageLabel", void 0)?.(page, pageCount, total, visibleCount, pageSize) ?? `${visibleCount}/${pageSize} - ${page}/${pageCount}`;
+}
+__name(pageLabel, "pageLabel");
+function shouldShowFooter(props) {
+  return hasProp(props, "footer") || hasProp(props, "pagination") || hasProp(props, "paginationMode") || hasProp(props, "pageSizeOptions") || resolvePage(props).total > currentQuery(props).pageSize;
+}
+__name(shouldShowFooter, "shouldShowFooter");
+function resolvePaginationState(props) {
+  const page = resolvePage(props);
+  const query = currentQuery(props);
+  return {
+    page: query.page,
+    pageCount: Math.max(1, Math.ceil(page.total / query.pageSize)),
+    pageSize: query.pageSize,
+    total: page.total,
+    visibleCount: page.rows.length
+  };
+}
+__name(resolvePaginationState, "resolvePaginationState");
+function goToPage(props, page, pageCount) {
+  const query = currentQuery(props);
+  const nextPage = clampPage(page, pageCount);
+  if (nextPage === query.page) return;
+  emitQuery(props, { ...query, page: nextPage });
+}
+__name(goToPage, "goToPage");
+function setPageSize(props, pageSize) {
+  const query = currentQuery(props);
+  const nextPageSize = normalizePositive(pageSize, query.pageSize);
+  if (nextPageSize === query.pageSize) return;
+  emitQuery(props, { ...query, page: 1, pageSize: nextPageSize });
+}
+__name(setPageSize, "setPageSize");
+function pageSizeOptions(props, currentPageSize) {
+  const configured = readProp(props, "pageSizeOptions", void 0) ?? DEFAULT_PAGE_SIZE_OPTIONS;
+  const values = configured.map((value) => normalizePositive(value, 0)).filter((value) => value > 0);
+  if (!values.includes(currentPageSize)) values.push(currentPageSize);
+  return [...new Set(values)].sort((left, right) => left - right);
+}
+__name(pageSizeOptions, "pageSizeOptions");
+function buildPaginationItems(page, pageCount) {
+  const siblingCount = 1;
+  const totalVisible = siblingCount * 2 + 5;
+  if (pageCount <= totalVisible) {
+    return Array.from({ length: pageCount }, (_, index) => index + 1);
+  }
+  const left = Math.max(page - siblingCount, 2);
+  const right = Math.min(page + siblingCount, pageCount - 1);
+  const items = [1];
+  if (left > 2) items.push("ellipsis-left");
+  for (let value = left; value <= right; value++) items.push(value);
+  if (right < pageCount - 1) items.push("ellipsis-right");
+  items.push(pageCount);
+  return items;
+}
+__name(buildPaginationItems, "buildPaginationItems");
+function clampPage(page, pageCount) {
+  if (pageCount <= 0) return 1;
+  return Math.min(pageCount, Math.max(1, Math.floor(Number.isFinite(page) ? page : 1)));
+}
+__name(clampPage, "clampPage");
+function applyColumnStyle(cell, column, settings) {
+  const width = settings?.columnWidths[column.id] ?? column.width;
+  const styles = [
+    normalizePixels(width) ? `width: ${normalizePixels(width)}` : "",
+    normalizePixels(column.minWidth) ? `min-width: ${normalizePixels(column.minWidth)}` : ""
+  ].filter(Boolean).join("; ");
+  if (styles) setAttribute(cell, "style", styles);
+  setOptionalAttribute(cell, "data-align", column.align);
+}
+__name(applyColumnStyle, "applyColumnStyle");
+function normalizeHeight(value) {
+  return `${normalizePositive(value, DEFAULT_VIRTUAL_HEIGHT)}px`;
+}
+__name(normalizeHeight, "normalizeHeight");
+function normalizePositive(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+__name(normalizePositive, "normalizePositive");
+function readRowValue(row, key) {
+  return row === null || row === void 0 ? void 0 : Reflect.get(row, key);
+}
+__name(readRowValue, "readRowValue");
+
+export { KitDataTable };
+//# sourceMappingURL=data-table.js.map
+//# sourceMappingURL=data-table.js.map