@bedrock-layout/solid 0.7.0 → 0.8.0

package/lib/index.m.js

@@ -5,915 +5,31 @@ 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) => {
+var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
     if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a2, prop, b[prop]);
+      __defNormalProp(a, prop, b[prop]);
   if (__getOwnPropSymbols)
     for (var prop of __getOwnPropSymbols(b)) {
       if (__propIsEnum.call(b, prop))
-        __defNormalProp(a2, prop, b[prop]);
+        __defNormalProp(a, prop, b[prop]);
     }
-  return a2;
+  return a;
 };
-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"
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
 };
-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);
-  }
-});
+import { styled, css } from "solid-styled-components";
 function checkIsCSSLength(str) {
   if (typeof str !== "string")
     return false;
@@ -958,7 +74,7 @@ function getSafeMaxWidth(maxWidth) {
     return `${maxWidth}px`;
   return maxWidth;
 }
-const Center = styled("div")`
+const Center = styled.div`
   @property --maxWidth {
     syntax: "<length-percentage>";
     inherits: false;
@@ -969,19 +85,21 @@ const Center = styled("div")`
 
   box-sizing: content-box;
 
-  margin-inline-start: auto;
-  margin-inline-end: auto;
-  margin-inline: auto;
+  && {
+    margin-inline-start: auto;
+    margin-inline-end: auto;
+    margin-inline: auto;
+  }
 
   max-inline-size: var(--maxWidth, 100%);
 
-  ${(props) => props.centerChildren ? u`
+  ${(props) => props.centerChildren ? css`
           display: flex;
           flex-direction: column;
           align-items: center;
         ` : ""}
 
-  ${(props) => props.centerText ? u`
+  ${(props) => props.centerText ? css`
           text-align: center;
         ` : ""}
 `;
@@ -1044,7 +162,7 @@ const Frame = styled.div`
   ${(props) => {
   const maybeRatio = getSafeRatio(props.ratio);
   if (maybeRatio) {
-    return u`
+    return css`
         aspect-ratio: ${maybeRatio};
       `;
   }
@@ -1139,7 +257,7 @@ const InlineCluster = styled.div`
   align-items: ${(props) => typeof props.align !== "undefined" && alignMap[props.align] ? alignMap[props.align] : alignMap.start};
 `;
 function shouldUseSwitch(switchAt) {
-  if (switchAt && switchAt > -1) {
+  if (typeof switchAt === "number" && switchAt > -1) {
     return true;
   }
   if (typeof switchAt === "string" && typeof CSS !== void 0) {
@@ -1156,7 +274,7 @@ const Inline = styled(InlineCluster)`
   flex-wrap: nowrap;
   ${(props) => props.stretch === "all" ? `> *  { flex: 1 }` : props.stretch === "start" ? `> :first-child { flex: 1 }` : props.stretch === "end" ? `> :last-child { flex: 1 }` : typeof props.stretch === "number" ? `> :nth-child(${props.stretch + 1}) { flex: 1 }` : ""}
 
-  ${(props) => shouldUseSwitch(props.switchAt) ? u`
+  ${(props) => shouldUseSwitch(props.switchAt) ? `
           --switchAt: ${typeof props.switchAt === "string" ? props.switchAt : `${props.switchAt}px`};
           flex-wrap: wrap;
           > * {
@@ -1166,14 +284,6 @@ const Inline = styled(InlineCluster)`
             );
           }
         ` : ""}
-
-  &[style*="--switchAt"] {
-    flex-wrap: wrap;
-    > * {
-      min-inline-size: fit-content;
-      flex-basis: calc((var(--switchAt) - (100% - var(--gutter, 0px))) * 999);
-    }
-  }
 `;
 const validKeys = /* @__PURE__ */ new Set([
   "left",
@@ -1222,11 +332,11 @@ function paddingToString(theme, padding) {
     console.error("Invalid padding Type");
   }
   const getPadding = paddingOrDefault(theme);
-  return typeof padding === "object" && !Array.isArray(padding) ? Object.entries(padding).reduce((acc, [key, val]) => validKeys.has(key) ? acc + keyToProperty(key, getPadding(val)) : acc, "") : padding ? `padding: ${Array.from(Array.isArray(padding) ? padding : [padding]).map((pad) => getPadding(pad)).join(" ")}` : "";
+  return typeof padding === "object" && !Array.isArray(padding) ? Object.entries(padding).reduce((acc, [key, val]) => validKeys.has(key) ? acc + keyToProperty(key, getPadding(val)) : acc, "") : padding !== void 0 ? `padding: ${Array.from(Array.isArray(padding) ? padding : [padding]).map((pad) => getPadding(pad)).join(" ")};` : "";
 }
 const PadBox = styled.div`
   box-sizing: border-box;
-  ${(props) => paddingToString(props.theme, props.padding)}
+  ${(props) => (console.log(paddingToString(props.theme, props.padding)), paddingToString(props.theme, props.padding))}
 `;
 const Reel = styled.div`
   box-sizing: border-box;
@@ -1287,4 +397,59 @@ const Stack = styled("div")`
     grid-column: span 1 / auto;
   }
 `;
-export { Center, ColumnDrop, Frame, Grid, Inline, InlineCluster, PadBox, Reel, Stack, checkIsCSSLength, getSpacingValue, spacing };
+function getSafeMinHeight(minHeight) {
+  if (typeof minHeight === "number")
+    return `${minHeight}px`;
+  return minHeight && checkIsCSSLength(minHeight) ? minHeight : "100vh";
+}
+const CoverWrapper = styled.div`
+  @property --gutter {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 0;
+  }
+
+  @property --minHeight {
+    syntax: "<length-percentage>";
+    inherits: false;
+    initial-value: 100vh;
+  }
+
+  --gutter: ${(props) => {
+  var _a;
+  return props.gutter ? (_a = getSpacingValue(props.gutter, props.theme)) != null ? _a : "0px" : "0px";
+}};
+
+  --minHeight: ${(props) => getSafeMinHeight(props.minHeight)};
+
+  > * {
+    margin: 0;
+  }
+
+  display: flex;
+  flex-direction: column;
+  gap: var(--gutter, 0px);
+
+  min-block-size: var(--minHeight, 100vh);
+
+  > [data-bedrock-cover-centered] {
+    margin-block-start: auto;
+    margin-block-end: auto;
+
+    ${({ stretchContent }) => stretchContent === true ? `
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            > * {
+              flex: 1;
+            }
+          ` : ""};
+  }
+`;
+const Cover = (props) => {
+  const _a = props, { top, bottom, children } = _a, rest = __objRest(_a, ["top", "bottom", "children"]);
+  return /* @__PURE__ */ React.createElement(CoverWrapper, __spreadValues({}, rest), props.top, /* @__PURE__ */ React.createElement("div", {
+    "data-bedrock-cover-centered": true
+  }, props.children), props.bottom);
+};
+export { Center, ColumnDrop, Cover, Frame, Grid, Inline, InlineCluster, PadBox, Reel, Stack, checkIsCSSLength, getSpacingValue, spacing };