@bedrock-layout/solid 0.2.2 → 0.5.0

package/lib/index.m.js

@@ -1,4 +1,1139 @@
-const Stack = () => {
-  return void 0;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a2, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a2, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a2, prop, b[prop]);
+    }
+  return a2;
 };
-export { Stack };
+var __spreadProps = (a2, b) => __defProps(a2, __getOwnPropDescs(b));
+let e = { data: "" }, t = (t2) => typeof window == "object" ? ((t2 ? t2.querySelector("#_goober") : window._goober) || Object.assign((t2 || document.head).appendChild(document.createElement("style")), { innerHTML: " ", id: "_goober" })).firstChild : t2 || e, l = /(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g, a = /\/\*[^]*?\*\/|\s\s+|\n/g, n = (e2, t2) => {
+  let r = "", l2 = "", a2 = "";
+  for (let o2 in e2) {
+    let s2 = e2[o2];
+    o2[0] == "@" ? o2[1] == "i" ? r = o2 + " " + s2 + ";" : l2 += o2[1] == "f" ? n(s2, o2) : o2 + "{" + n(s2, o2[1] == "k" ? "" : t2) + "}" : typeof s2 == "object" ? l2 += n(s2, t2 ? t2.replace(/([^,])+/g, (e3) => o2.replace(/(^:.*)|([^,])+/g, (t3) => /&/.test(t3) ? t3.replace(/&/g, e3) : e3 ? e3 + " " + t3 : t3)) : o2) : s2 != null && (o2 = /^--/.test(o2) ? o2 : o2.replace(/[A-Z]/g, "-$&").toLowerCase(), a2 += n.p ? n.p(o2, s2) : o2 + ":" + s2 + ";");
+  }
+  return r + (t2 && a2 ? t2 + "{" + a2 + "}" : a2) + l2;
+}, o = {}, s = (e2) => {
+  if (typeof e2 == "object") {
+    let t2 = "";
+    for (let r in e2)
+      t2 += r + s(e2[r]);
+    return t2;
+  }
+  return e2;
+}, c = (e2, t2, r, c2, i2) => {
+  let u2 = s(e2), p = o[u2] || (o[u2] = ((e3) => {
+    let t3 = 0, r2 = 11;
+    for (; t3 < e3.length; )
+      r2 = 101 * r2 + e3.charCodeAt(t3++) >>> 0;
+    return "go" + r2;
+  })(u2));
+  if (!o[p]) {
+    let t3 = u2 !== e2 ? e2 : ((e3) => {
+      let t4, r2 = [{}];
+      for (; t4 = l.exec(e3.replace(a, "")); )
+        t4[4] ? r2.shift() : t4[3] ? r2.unshift(r2[0][t4[3]] = r2[0][t4[3]] || {}) : r2[0][t4[1]] = t4[2];
+      return r2[0];
+    })(e2);
+    o[p] = n(i2 ? { ["@keyframes " + p]: t3 } : t3, r ? "" : "." + p);
+  }
+  return ((e3, t3, r2) => {
+    t3.data.indexOf(e3) == -1 && (t3.data = r2 ? e3 + t3.data : t3.data + e3);
+  })(o[p], t2, c2), p;
+}, i = (e2, t2, r) => e2.reduce((e3, l2, a2) => {
+  let o2 = t2[a2];
+  if (o2 && o2.call) {
+    let e4 = o2(r), t3 = e4 && e4.props && e4.props.className || /^go/.test(e4) && e4;
+    o2 = t3 ? "." + t3 : e4 && typeof e4 == "object" ? e4.props ? "" : n(e4, "") : e4 === false ? "" : e4;
+  }
+  return e3 + l2 + (o2 == null ? "" : o2);
+}, "");
+function u(e2) {
+  let r = this || {}, l2 = e2.call ? e2(r.p) : e2;
+  return c(l2.unshift ? l2.raw ? i(l2, [].slice.call(arguments, 1), r.p) : l2.reduce((e3, t2) => Object.assign(e3, t2 && t2.call ? t2(r.p) : t2), {}) : l2, t(r.target), r.g, r.o, r.k);
+}
+u.bind({ g: 1 });
+u.bind({ k: 1 });
+const equalFn = (a2, b) => a2 === b;
+const $PROXY = Symbol("solid-proxy");
+const signalOptions = {
+  equals: equalFn
+};
+let runEffects = runQueue;
+const NOTPENDING = {};
+const STALE = 1;
+const PENDING = 2;
+const UNOWNED = {
+  owned: null,
+  cleanups: null,
+  context: null,
+  owner: null
+};
+var Owner = null;
+let Transition = null;
+let Listener = null;
+let Pending = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+function createComputed(fn, value, options) {
+  const c2 = createComputation(fn, value, true, STALE);
+  updateComputation(c2);
+}
+function createRenderEffect(fn, value, options) {
+  const c2 = createComputation(fn, value, false, STALE);
+  updateComputation(c2);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c2 = createComputation(fn, value, true, 0);
+  c2.pending = NOTPENDING;
+  c2.observers = null;
+  c2.observerSlots = null;
+  c2.comparator = options.equals || void 0;
+  updateComputation(c2);
+  return readSignal.bind(c2);
+}
+function batch(fn) {
+  if (Pending)
+    return fn();
+  let result;
+  const q = Pending = [];
+  try {
+    result = fn();
+  } finally {
+    Pending = null;
+  }
+  runUpdates(() => {
+    for (let i2 = 0; i2 < q.length; i2 += 1) {
+      const data = q[i2];
+      if (data.pending !== NOTPENDING) {
+        const pending = data.pending;
+        data.pending = NOTPENDING;
+        writeSignal(data, pending);
+      }
+    }
+  }, false);
+  return result;
+}
+function untrack(fn) {
+  let result, listener = Listener;
+  Listener = null;
+  result = fn();
+  Listener = listener;
+  return result;
+}
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  return lookup(Owner, context.id) || context.defaultValue;
+}
+function children(fn) {
+  const children2 = createMemo(fn);
+  return createMemo(() => resolveChildren(children2()));
+}
+function readSignal() {
+  const runningTransition = Transition;
+  if (this.sources && (this.state || runningTransition)) {
+    const updates = Updates;
+    Updates = null;
+    this.state === STALE || runningTransition ? updateComputation(this) : lookDownstream(this);
+    Updates = updates;
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  if (node.comparator) {
+    if (node.comparator(node.value, value))
+      return value;
+  }
+  if (Pending) {
+    if (node.pending === NOTPENDING)
+      Pending.push(node);
+    node.pending = value;
+    return value;
+  }
+  let TransitionRunning = false;
+  node.value = value;
+  if (node.observers && node.observers.length) {
+    runUpdates(() => {
+      for (let i2 = 0; i2 < node.observers.length; i2 += 1) {
+        const o2 = node.observers[i2];
+        if (TransitionRunning && Transition.disposed.has(o2))
+          ;
+        if (o2.pure)
+          Updates.push(o2);
+        else
+          Effects.push(o2);
+        if (o2.observers && (TransitionRunning && !o2.tState || !TransitionRunning && !o2.state))
+          markUpstream(o2);
+        if (TransitionRunning)
+          ;
+        else
+          o2.state = STALE;
+      }
+      if (Updates.length > 1e6) {
+        Updates = [];
+        if (false)
+          ;
+        throw new Error();
+      }
+    }, false);
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const owner = Owner, listener = Listener, time = ExecCount;
+  Listener = Owner = node;
+  runComputation(node, node.value, time);
+  Listener = listener;
+  Owner = owner;
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    handleError(err);
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.observers && node.observers.length) {
+      writeSignal(node, nextValue);
+    } else
+      node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c2 = {
+    fn,
+    state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: null,
+    pure
+  };
+  if (Owner === null)
+    ;
+  else if (Owner !== UNOWNED) {
+    {
+      if (!Owner.owned)
+        Owner.owned = [c2];
+      else
+        Owner.owned.push(c2);
+    }
+  }
+  return c2;
+}
+function runTop(node) {
+  const runningTransition = Transition;
+  if (node.state !== STALE)
+    return node.state = 0;
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (node.state || runningTransition)
+      ancestors.push(node);
+  }
+  for (let i2 = ancestors.length - 1; i2 >= 0; i2--) {
+    node = ancestors[i2];
+    if (node.state === STALE || runningTransition) {
+      updateComputation(node);
+    } else if (node.state === PENDING || runningTransition) {
+      const updates = Updates;
+      Updates = null;
+      lookDownstream(node, ancestors[0]);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    return fn();
+  } catch (err) {
+    handleError(err);
+  } finally {
+    completeUpdates(wait);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    runQueue(Updates);
+    Updates = null;
+  }
+  if (wait)
+    return;
+  if (Effects.length)
+    batch(() => {
+      runEffects(Effects);
+      Effects = null;
+    });
+  else {
+    Effects = null;
+  }
+}
+function runQueue(queue) {
+  for (let i2 = 0; i2 < queue.length; i2++)
+    runTop(queue[i2]);
+}
+function lookDownstream(node, ignore) {
+  node.state = 0;
+  const runningTransition = Transition;
+  for (let i2 = 0; i2 < node.sources.length; i2 += 1) {
+    const source = node.sources[i2];
+    if (source.sources) {
+      if (source.state === STALE || runningTransition) {
+        if (source !== ignore)
+          runTop(source);
+      } else if (source.state === PENDING || runningTransition)
+        lookDownstream(source, ignore);
+    }
+  }
+}
+function markUpstream(node) {
+  const runningTransition = Transition;
+  for (let i2 = 0; i2 < node.observers.length; i2 += 1) {
+    const o2 = node.observers[i2];
+    if (!o2.state || runningTransition) {
+      o2.state = PENDING;
+      if (o2.pure)
+        Updates.push(o2);
+      else
+        Effects.push(o2);
+      o2.observers && markUpstream(o2);
+    }
+  }
+}
+function cleanNode(node) {
+  let i2;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n2 = obs.pop(), s2 = source.observerSlots.pop();
+        if (index < obs.length) {
+          n2.sourceSlots[s2] = index;
+          obs[index] = n2;
+          source.observerSlots[index] = s2;
+        }
+      }
+    }
+  }
+  if (node.owned) {
+    for (i2 = 0; i2 < node.owned.length; i2++)
+      cleanNode(node.owned[i2]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i2 = 0; i2 < node.cleanups.length; i2++)
+      node.cleanups[i2]();
+    node.cleanups = null;
+  }
+  node.state = 0;
+  node.context = null;
+}
+function handleError(err) {
+  throw err;
+}
+function lookup(owner, key) {
+  return owner && (owner.context && owner.context[key] !== void 0 ? owner.context[key] : owner.owner && lookup(owner.owner, key));
+}
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
+    const results = [];
+    for (let i2 = 0; i2 < children2.length; i2++) {
+      const result = resolveChildren(children2[i2]);
+      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    }
+    return results;
+  }
+  return children2;
+}
+function createProvider(id) {
+  return function provider(props) {
+    let res;
+    createComputed(() => res = untrack(() => {
+      Owner.context = {
+        [id]: props.value
+      };
+      return children(() => props.children);
+    }));
+    return res;
+  };
+}
+function trueFn() {
+  return true;
+}
+const propTraps = {
+  get(_, property, receiver) {
+    if (property === $PROXY)
+      return receiver;
+    return _.get(property);
+  },
+  has(_, property) {
+    return _.has(property);
+  },
+  set: trueFn,
+  deleteProperty: trueFn,
+  getOwnPropertyDescriptor(_, property) {
+    return {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return _.get(property);
+      },
+      set: trueFn,
+      deleteProperty: trueFn
+    };
+  },
+  ownKeys(_) {
+    return _.keys();
+  }
+};
+function resolveSource(s2) {
+  return typeof s2 === "function" ? s2() : s2;
+}
+function mergeProps(...sources) {
+  return new Proxy({
+    get(property) {
+      for (let i2 = sources.length - 1; i2 >= 0; i2--) {
+        const v = resolveSource(sources[i2])[property];
+        if (v !== void 0)
+          return v;
+      }
+    },
+    has(property) {
+      for (let i2 = sources.length - 1; i2 >= 0; i2--) {
+        if (property in resolveSource(sources[i2]))
+          return true;
+      }
+      return false;
+    },
+    keys() {
+      const keys = [];
+      for (let i2 = 0; i2 < sources.length; i2++)
+        keys.push(...Object.keys(resolveSource(sources[i2])));
+      return [...new Set(keys)];
+    }
+  }, propTraps);
+}
+function splitProps(props, ...keys) {
+  const blocked = new Set(keys.flat());
+  const descriptors = Object.getOwnPropertyDescriptors(props);
+  const res = keys.map((k) => {
+    const clone = {};
+    for (let i2 = 0; i2 < k.length; i2++) {
+      const key = k[i2];
+      Object.defineProperty(clone, key, descriptors[key] ? descriptors[key] : {
+        get() {
+          return props[key];
+        },
+        set() {
+          return true;
+        }
+      });
+    }
+    return clone;
+  });
+  res.push(new Proxy({
+    get(property) {
+      return blocked.has(property) ? void 0 : props[property];
+    },
+    has(property) {
+      return blocked.has(property) ? false : property in props;
+    },
+    keys() {
+      return Object.keys(props).filter((k) => !blocked.has(k));
+    }
+  }, propTraps));
+  return res;
+}
+const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"];
+const Properties = /* @__PURE__ */ new Set(["className", "value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
+const ChildProperties = /* @__PURE__ */ new Set(["innerHTML", "textContent", "innerText", "children"]);
+const Aliases = {
+  className: "class",
+  htmlFor: "for"
+};
+const PropAliases = {
+  class: "className",
+  formnovalidate: "formNoValidate",
+  ismap: "isMap",
+  nomodule: "noModule",
+  playsinline: "playsInline",
+  readonly: "readOnly"
+};
+const DelegatedEvents = /* @__PURE__ */ new Set(["beforeinput", "click", "dblclick", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]);
+const SVGNamespace = {
+  xlink: "http://www.w3.org/1999/xlink",
+  xml: "http://www.w3.org/XML/1998/namespace"
+};
+function reconcileArrays(parentNode, a2, b) {
+  let bLength = b.length, aEnd = a2.length, bEnd = bLength, aStart = 0, bStart = 0, after = a2[aEnd - 1].nextSibling, map = null;
+  while (aStart < aEnd || bStart < bEnd) {
+    if (a2[aStart] === b[bStart]) {
+      aStart++;
+      bStart++;
+      continue;
+    }
+    while (a2[aEnd - 1] === b[bEnd - 1]) {
+      aEnd--;
+      bEnd--;
+    }
+    if (aEnd === aStart) {
+      const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
+      while (bStart < bEnd)
+        parentNode.insertBefore(b[bStart++], node);
+    } else if (bEnd === bStart) {
+      while (aStart < aEnd) {
+        if (!map || !map.has(a2[aStart]))
+          a2[aStart].remove();
+        aStart++;
+      }
+    } else if (a2[aStart] === b[bEnd - 1] && b[bStart] === a2[aEnd - 1]) {
+      const node = a2[--aEnd].nextSibling;
+      parentNode.insertBefore(b[bStart++], a2[aStart++].nextSibling);
+      parentNode.insertBefore(b[--bEnd], node);
+      a2[aEnd] = b[bEnd];
+    } else {
+      if (!map) {
+        map = /* @__PURE__ */ new Map();
+        let i2 = bStart;
+        while (i2 < bEnd)
+          map.set(b[i2], i2++);
+      }
+      const index = map.get(a2[aStart]);
+      if (index != null) {
+        if (bStart < index && index < bEnd) {
+          let i2 = aStart, sequence = 1, t2;
+          while (++i2 < aEnd && i2 < bEnd) {
+            if ((t2 = map.get(a2[i2])) == null || t2 !== index + sequence)
+              break;
+            sequence++;
+          }
+          if (sequence > index - bStart) {
+            const node = a2[aStart];
+            while (bStart < index)
+              parentNode.insertBefore(b[bStart++], node);
+          } else
+            parentNode.replaceChild(b[bStart++], a2[aStart++]);
+        } else
+          aStart++;
+      } else
+        a2[aStart++].remove();
+    }
+  }
+}
+const $$EVENTS = "_$DX_DELEGATE";
+function delegateEvents(eventNames, document2 = window.document) {
+  const e2 = document2[$$EVENTS] || (document2[$$EVENTS] = /* @__PURE__ */ new Set());
+  for (let i2 = 0, l2 = eventNames.length; i2 < l2; i2++) {
+    const name = eventNames[i2];
+    if (!e2.has(name)) {
+      e2.add(name);
+      document2.addEventListener(name, eventHandler);
+    }
+  }
+}
+function setAttribute(node, name, value) {
+  if (value == null)
+    node.removeAttribute(name);
+  else
+    node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+  if (value == null)
+    node.removeAttributeNS(namespace, name);
+  else
+    node.setAttributeNS(namespace, name, value);
+}
+function addEventListener(node, name, handler, delegate) {
+  if (delegate) {
+    if (Array.isArray(handler)) {
+      node[`$$${name}`] = handler[0];
+      node[`$$${name}Data`] = handler[1];
+    } else
+      node[`$$${name}`] = handler;
+  } else if (Array.isArray(handler)) {
+    node.addEventListener(name, (e2) => handler[0](handler[1], e2));
+  } else
+    node.addEventListener(name, handler);
+}
+function classList(node, value, prev = {}) {
+  const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
+  let i2, len;
+  for (i2 = 0, len = prevKeys.length; i2 < len; i2++) {
+    const key = prevKeys[i2];
+    if (!key || key === "undefined" || value[key])
+      continue;
+    toggleClassKey(node, key, false);
+    delete prev[key];
+  }
+  for (i2 = 0, len = classKeys.length; i2 < len; i2++) {
+    const key = classKeys[i2], classValue = !!value[key];
+    if (!key || key === "undefined" || prev[key] === classValue || !classValue)
+      continue;
+    toggleClassKey(node, key, true);
+    prev[key] = classValue;
+  }
+  return prev;
+}
+function style(node, value, prev = {}) {
+  const nodeStyle = node.style;
+  if (value == null || typeof value === "string")
+    return nodeStyle.cssText = value;
+  typeof prev === "string" && (prev = {});
+  let v, s2;
+  for (s2 in prev) {
+    value[s2] == null && nodeStyle.removeProperty(s2);
+    delete prev[s2];
+  }
+  for (s2 in value) {
+    v = value[s2];
+    if (v !== prev[s2]) {
+      nodeStyle.setProperty(s2, v);
+      prev[s2] = v;
+    }
+  }
+  return prev;
+}
+function spread(node, accessor, isSVG, skipChildren) {
+  if (typeof accessor === "function") {
+    createRenderEffect((current) => spreadExpression(node, accessor(), current, isSVG, skipChildren));
+  } else
+    spreadExpression(node, accessor, void 0, isSVG, skipChildren);
+}
+function assign(node, props, isSVG, skipChildren, prevProps = {}) {
+  for (const prop in prevProps) {
+    if (!(prop in props)) {
+      if (prop === "children")
+        continue;
+      assignProp(node, prop, null, prevProps[prop], isSVG);
+    }
+  }
+  for (const prop in props) {
+    if (prop === "children") {
+      if (!skipChildren)
+        insertExpression(node, props.children);
+      continue;
+    }
+    const value = props[prop];
+    prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG);
+  }
+}
+function toPropertyName(name) {
+  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function toggleClassKey(node, key, value) {
+  const classNames = key.trim().split(/\s+/);
+  for (let i2 = 0, nameLen = classNames.length; i2 < nameLen; i2++)
+    node.classList.toggle(classNames[i2], value);
+}
+function assignProp(node, prop, value, prev, isSVG) {
+  let isCE, isProp, isChildProp;
+  if (prop === "style")
+    return style(node, value, prev);
+  if (prop === "classList")
+    return classList(node, value, prev);
+  if (value === prev)
+    return prev;
+  if (prop === "ref") {
+    value(node);
+  } else if (prop.slice(0, 3) === "on:") {
+    node.addEventListener(prop.slice(3), value);
+  } else if (prop.slice(0, 10) === "oncapture:") {
+    node.addEventListener(prop.slice(10), value, true);
+  } else if (prop.slice(0, 2) === "on") {
+    const name = prop.slice(2).toLowerCase();
+    const delegate = DelegatedEvents.has(name);
+    addEventListener(node, name, value, delegate);
+    delegate && delegateEvents([name]);
+  } else if ((isChildProp = ChildProperties.has(prop)) || !isSVG && (PropAliases[prop] || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) {
+    if (isCE && !isProp && !isChildProp)
+      node[toPropertyName(prop)] = value;
+    else
+      node[PropAliases[prop] || prop] = value;
+  } else {
+    const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
+    if (ns)
+      setAttributeNS(node, ns, prop, value);
+    else
+      setAttribute(node, Aliases[prop] || prop, value);
+  }
+  return value;
+}
+function eventHandler(e2) {
+  const key = `$$${e2.type}`;
+  let node = e2.composedPath && e2.composedPath()[0] || e2.target;
+  if (e2.target !== node) {
+    Object.defineProperty(e2, "target", {
+      configurable: true,
+      value: node
+    });
+  }
+  Object.defineProperty(e2, "currentTarget", {
+    configurable: true,
+    get() {
+      return node || document;
+    }
+  });
+  while (node !== null) {
+    const handler = node[key];
+    if (handler && !node.disabled) {
+      const data = node[`${key}Data`];
+      data !== void 0 ? handler(data, e2) : handler(e2);
+      if (e2.cancelBubble)
+        return;
+    }
+    node = node.host && node.host !== node && node.host instanceof Node ? node.host : node.parentNode;
+  }
+}
+function spreadExpression(node, props, prevProps = {}, isSVG, skipChildren) {
+  if (!skipChildren && "children" in props) {
+    createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+  }
+  createRenderEffect(() => assign(node, props, isSVG, true, prevProps));
+  return prevProps;
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+  while (typeof current === "function")
+    current = current();
+  if (value === current)
+    return current;
+  const t2 = typeof value, multi = marker !== void 0;
+  parent = multi && current[0] && current[0].parentNode || parent;
+  if (t2 === "string" || t2 === "number") {
+    if (t2 === "number")
+      value = value.toString();
+    if (multi) {
+      let node = current[0];
+      if (node && node.nodeType === 3) {
+        node.data = value;
+      } else
+        node = document.createTextNode(value);
+      current = cleanChildren(parent, current, marker, node);
+    } else {
+      if (current !== "" && typeof current === "string") {
+        current = parent.firstChild.data = value;
+      } else
+        current = parent.textContent = value;
+    }
+  } else if (value == null || t2 === "boolean") {
+    current = cleanChildren(parent, current, marker);
+  } else if (t2 === "function") {
+    createRenderEffect(() => {
+      let v = value();
+      while (typeof v === "function")
+        v = v();
+      current = insertExpression(parent, v, current, marker);
+    });
+    return () => current;
+  } else if (Array.isArray(value)) {
+    const array = [];
+    if (normalizeIncomingArray(array, value, unwrapArray)) {
+      createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+      return () => current;
+    }
+    if (array.length === 0) {
+      current = cleanChildren(parent, current, marker);
+      if (multi)
+        return current;
+    } else if (Array.isArray(current)) {
+      if (current.length === 0) {
+        appendNodes(parent, array, marker);
+      } else
+        reconcileArrays(parent, current, array);
+    } else {
+      current && cleanChildren(parent);
+      appendNodes(parent, array);
+    }
+    current = array;
+  } else if (value instanceof Node) {
+    if (Array.isArray(current)) {
+      if (multi)
+        return current = cleanChildren(parent, current, marker, value);
+      cleanChildren(parent, current, null, value);
+    } else if (current == null || current === "" || !parent.firstChild) {
+      parent.appendChild(value);
+    } else
+      parent.replaceChild(value, parent.firstChild);
+    current = value;
+  } else
+    ;
+  return current;
+}
+function normalizeIncomingArray(normalized, array, unwrap) {
+  let dynamic = false;
+  for (let i2 = 0, len = array.length; i2 < len; i2++) {
+    let item = array[i2], t2;
+    if (item instanceof Node) {
+      normalized.push(item);
+    } else if (item == null || item === true || item === false)
+      ;
+    else if (Array.isArray(item)) {
+      dynamic = normalizeIncomingArray(normalized, item) || dynamic;
+    } else if ((t2 = typeof item) === "string") {
+      normalized.push(document.createTextNode(item));
+    } else if (t2 === "function") {
+      if (unwrap) {
+        while (typeof item === "function")
+          item = item();
+        dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic;
+      } else {
+        normalized.push(item);
+        dynamic = true;
+      }
+    } else
+      normalized.push(document.createTextNode(item.toString()));
+  }
+  return dynamic;
+}
+function appendNodes(parent, array, marker) {
+  for (let i2 = 0, len = array.length; i2 < len; i2++)
+    parent.insertBefore(array[i2], marker);
+}
+function cleanChildren(parent, current, marker, replacement) {
+  if (marker === void 0)
+    return parent.textContent = "";
+  const node = replacement || document.createTextNode("");
+  if (current.length) {
+    let inserted = false;
+    for (let i2 = current.length - 1; i2 >= 0; i2--) {
+      const el = current[i2];
+      if (node !== el) {
+        const isParent = el.parentNode === parent;
+        if (!inserted && !i2)
+          isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
+        else
+          isParent && el.remove();
+      } else
+        inserted = true;
+    }
+  } else
+    parent.insertBefore(node, marker);
+  return [node];
+}
+function ssr(template, ...nodes) {
+}
+function ssrSpread(accessor) {
+}
+const isServer = false;
+const ThemeContext = createContext();
+function makeStyled(tag) {
+  let _ctx = this || {};
+  return (...args) => {
+    const Styled = (props) => {
+      const theme = useContext(ThemeContext);
+      const withTheme = mergeProps(props, { theme });
+      const clone = mergeProps(withTheme, {
+        get className() {
+          const pClassName = withTheme.className, append = "className" in withTheme && /^go[0-9]+/.test(pClassName);
+          let className = u.apply({ target: _ctx.target, o: append, p: withTheme, g: _ctx.g }, args);
+          return [pClassName, className].filter(Boolean).join(" ");
+        }
+      });
+      const [local, newProps] = splitProps(clone, ["as"]);
+      const createTag = local.as || tag;
+      let el;
+      if (typeof createTag === "function") {
+        el = createTag(newProps);
+      } else if (isServer) {
+        const [local2, others] = splitProps(newProps, ["children"]);
+        el = ssr([`<${createTag} `, ">", `</${createTag}>`], ssrSpread(), local2.children || "");
+      } else {
+        el = document.createElement(createTag);
+        spread(el, newProps);
+      }
+      return el;
+    };
+    Styled.className = (props) => {
+      return untrack(() => {
+        return u.apply({ target: _ctx.target, p: props, g: _ctx.g }, args);
+      });
+    };
+    return Styled;
+  };
+}
+const styled = new Proxy(makeStyled, {
+  get(target, tag) {
+    return target(tag);
+  }
+});
+function checkIsCSSLength(str) {
+  if (typeof str !== "string")
+    return false;
+  return [
+    /^[0-9]{0,10000}\.?[0-9]{1,10000}(vmin|vmax|vh|vw|%|ch|ex|em|rem|in|cm|mm|pt|pc|px)$/,
+    /^var\(--\D{1,100}\)$/
+  ].some((regex) => regex.test(str));
+}
+const spacing = {
+  none: "0px",
+  xxs: "0.0625rem",
+  xs: "0.125rem",
+  sm: "0.25rem",
+  md: "0.5rem",
+  mdLg: "0.75rem",
+  lg: "1rem",
+  lgXl: "1.5rem",
+  xl: "2rem",
+  xlXXl: "3rem",
+  xxl: "4rem"
+};
+function fromEntries(entries) {
+  return entries.reduce((acc, [key, value]) => {
+    return __spreadProps(__spreadValues({}, acc), { [key]: value });
+  }, {});
+}
+const getSpacingValue = (spacingKey, theme) => {
+  var _a, _b;
+  const maybeSpaceingOrDefault = (_b = (_a = theme == null ? void 0 : theme.space) != null ? _a : theme == null ? void 0 : theme.spacing) != null ? _b : spacing;
+  const safeSpacings = fromEntries(Object.entries(maybeSpaceingOrDefault).map(([spaceKey, value]) => [
+    spaceKey,
+    typeof value === "number" ? `${value}px` : value
+  ]));
+  const spacingVal = safeSpacings[spacingKey];
+  const isCSSLength = checkIsCSSLength(spacingVal);
+  return isCSSLength ? spacingVal : void 0;
+};
+const Stack = styled("div")`
+  @property --gutter {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 0;
+  }
+
+  --gutter: ${(props) => {
+  var _a;
+  return props.gutter ? (_a = getSpacingValue(props.gutter, props.theme)) != null ? _a : "0px" : "0px";
+}};
+  box-sizing: border-box;
+  > * {
+    margin: 0;
+  }
+  display: flex;
+  flex-direction: column;
+
+  gap: var(--gutter, 0px);
+  align-content: start;
+
+  & > [data-bedrock-column] {
+    grid-column: span 1 / auto;
+  }
+`;
+const Grid = styled("div")`
+  @property --gutter {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 0;
+  }
+
+  @property --minItemWidth {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 639px;
+  }
+
+  --gutter: ${(props) => {
+  var _a;
+  return props.gutter ? (_a = getSpacingValue(props.gutter, props.theme)) != null ? _a : "0px" : "0px";
+}};
+  --minItemWidth: ${(props) => {
+  var _a;
+  return typeof props.minItemWidth === "string" ? props.minItemWidth : `${(_a = props.minItemWidth) != null ? _a : 0}px`;
+}};
+
+  box-sizing: border-box;
+  > * {
+    margin: 0;
+  }
+
+  display: grid;
+  gap: var(--gutter, 0px);
+
+  grid-template-columns: repeat(
+    auto-fit,
+    minmax(min(var(--minItemWidth, 639px), 100%), 1fr)
+  );
+`;
+function getSafeMaxWidth(maxWidth) {
+  if (maxWidth === void 0)
+    return "100%";
+  if (typeof maxWidth === "number")
+    return `${maxWidth}px`;
+  return maxWidth;
+}
+const Center = styled("div")`
+  @property --maxWidth {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 100%;
+  }
+
+  --maxWidth: ${(props) => getSafeMaxWidth(props.maxWidth)};
+
+  box-sizing: content-box;
+
+  margin-inline-start: auto;
+  margin-inline-end: auto;
+  margin-inline: auto;
+
+  max-inline-size: var(--maxWidth, 100%);
+
+  ${(props) => props.centerChildren ? u`
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+        ` : ""}
+
+  ${(props) => props.centerText ? u`
+          text-align: center;
+        ` : ""}
+`;
+function getSafeBasis(basis) {
+  if (basis === void 0)
+    return "100%";
+  if (typeof basis === "number")
+    return `${basis}px`;
+  return basis;
+}
+const ColumnDrop = styled("div")`
+  @property --basis {
+    syntax: "<length-percentage>";
+    inherits: true;
+    initial-value: 100%;
+  }
+
+  @property --gutter {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 0px;
+  }
+
+  --basis: ${(props) => getSafeBasis(props.basis)};
+  --gutter: ${(props) => {
+  var _a;
+  return props.gutter ? (_a = getSpacingValue(props.gutter, props.theme)) != null ? _a : "0px" : "0px";
+}};
+
+  box-sizing: border-box;
+  > * {
+    margin: 0;
+    flex-basis: var(--basis, 100%);
+    flex-grow: ${(props) => props.noStretchedColumns ? "0" : "1"};
+    flex-shrink: 1;
+  }
+
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--gutter, 0px);
+`;
+function checkIsRatio(ratio) {
+  const isCorrectArray = Array.isArray(ratio) && ratio.length === 2 && ratio.every(Number.isFinite);
+  return isCorrectArray || typeof ratio === "string" && /^\d{1,1000}\/\d{1,1000}$/.test(ratio);
+}
+function getRatioString(ratio) {
+  return Array.isArray(ratio) ? ratio.join("/") : ratio;
+}
+function getSafeRatio(ratio) {
+  const isRatio = checkIsRatio(ratio);
+  return isRatio ? getRatioString(ratio) : void 0;
+}
+const Frame = styled.div`
+  box-sizing: border-box;
+  display: block;
+  inline-size: 100%;
+  position: relative;
+  overflow: hidden;
+
+  ${(props) => {
+  const maybeRatio = getSafeRatio(props.ratio);
+  if (maybeRatio) {
+    return u`
+        aspect-ratio: ${maybeRatio};
+      `;
+  }
+  return "";
+}};
+
+  > * {
+    position: absolute;
+
+    inset-block-start: 0;
+    inset-block-end: 0;
+    inset-inline-start: 0;
+    inset-inline-end: 0;
+
+    inset-block: 0;
+    inset-inline: 0;
+
+    display: flex;
+    justify-content: center;
+    align-items: center;
+  }
+
+  > :is(img, video) {
+    inline-size: 100%;
+    block-size: 100%;
+    size: 100%;
+
+    object-fit: cover;
+    object-position: ${(props) => typeof props.position === "string" ? props.position : "50%"};
+  }
+`;
+export { Center, ColumnDrop, Frame, Grid, Stack, checkIsCSSLength, getSpacingValue, spacing };