@selvajs/selva 4.6.20 → 4.6.21-beta.1

package/build/server/chunks/chunks/copy.js-8IzAWpdM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copy.js-8IzAWpdM.js","sources":["../../../../.svelte-kit/output/server/chunks/copy.js"],"sourcesContent":["import { j as spread_props } from \"./index3.js\";\nimport { I as Icon } from \"./utils3.js\";\nfunction Copy($$renderer, $$props) {\n  let { $$slots, $$events, ...props } = $$props;\n  const iconNode = [\n    [\n      \"rect\",\n      {\n        \"width\": \"14\",\n        \"height\": \"14\",\n        \"x\": \"8\",\n        \"y\": \"8\",\n        \"rx\": \"2\",\n        \"ry\": \"2\"\n      }\n    ],\n    [\n      \"path\",\n      {\n        \"d\": \"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\"\n      }\n    ]\n  ];\n  Icon($$renderer, spread_props([{ name: \"copy\" }, props, { iconNode }]));\n}\nexport {\n  Copy as C\n};\n"],"names":[],"mappings":";;;AAEA,SAAS,IAAI,CAAC,UAAU,EAAE,OAAO,EAAE;AACnC,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,GAAG,OAAO;AAC/C,EAAE,MAAM,QAAQ,GAAG;AACnB,IAAI;AACJ,MAAM,MAAM;AACZ,MAAM;AACN,QAAQ,OAAO,EAAE,IAAI;AACrB,QAAQ,QAAQ,EAAE,IAAI;AACtB,QAAQ,GAAG,EAAE,GAAG;AAChB,QAAQ,GAAG,EAAE,GAAG;AAChB,QAAQ,IAAI,EAAE,GAAG;AACjB,QAAQ,IAAI,EAAE;AACd;AACA,KAAK;AACL,IAAI;AACJ,MAAM,MAAM;AACZ,MAAM;AACN,QAAQ,GAAG,EAAE;AACb;AACA;AACA,GAAG;AACH,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AACzE;;;;"}

package/build/server/chunks/chunks/create-id.js-DLd1XgVR.js

@@ -0,0 +1,653 @@
+import { clsx } from 'clsx';
+import { R as derived, a5 as run, aj as ATTACHMENT_KEY } from './index3.js-1TgPl-ig.js';
+
+var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+var NEWLINE_REGEX = /\n/g;
+var WHITESPACE_REGEX = /^\s*/;
+var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+var COLON_REGEX = /^:\s*/;
+var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+var SEMICOLON_REGEX = /^[;\s]*/;
+var TRIM_REGEX = /^\s+|\s+$/g;
+var NEWLINE = "\n";
+var FORWARD_SLASH = "/";
+var ASTERISK = "*";
+var EMPTY_STRING = "";
+var TYPE_COMMENT = "comment";
+var TYPE_DECLARATION = "declaration";
+function index(style, options) {
+  if (typeof style !== "string") {
+    throw new TypeError("First argument must be a string");
+  }
+  if (!style) return [];
+  options = options || {};
+  var lineno = 1;
+  var column = 1;
+  function updatePosition(str) {
+    var lines = str.match(NEWLINE_REGEX);
+    if (lines) lineno += lines.length;
+    var i = str.lastIndexOf(NEWLINE);
+    column = ~i ? str.length - i : column + str.length;
+  }
+  function position() {
+    var start = { line: lineno, column };
+    return function(node) {
+      node.position = new Position(start);
+      whitespace();
+      return node;
+    };
+  }
+  function Position(start) {
+    this.start = start;
+    this.end = { line: lineno, column };
+    this.source = options.source;
+  }
+  Position.prototype.content = style;
+  function error(msg) {
+    var err = new Error(
+      options.source + ":" + lineno + ":" + column + ": " + msg
+    );
+    err.reason = msg;
+    err.filename = options.source;
+    err.line = lineno;
+    err.column = column;
+    err.source = style;
+    if (options.silent) ;
+    else {
+      throw err;
+    }
+  }
+  function match(re) {
+    var m = re.exec(style);
+    if (!m) return;
+    var str = m[0];
+    updatePosition(str);
+    style = style.slice(str.length);
+    return m;
+  }
+  function whitespace() {
+    match(WHITESPACE_REGEX);
+  }
+  function comments(rules) {
+    var c;
+    rules = rules || [];
+    while (c = comment()) {
+      if (c !== false) {
+        rules.push(c);
+      }
+    }
+    return rules;
+  }
+  function comment() {
+    var pos = position();
+    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+    var i = 2;
+    while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
+      ++i;
+    }
+    i += 2;
+    if (EMPTY_STRING === style.charAt(i - 1)) {
+      return error("End of comment missing");
+    }
+    var str = style.slice(2, i - 2);
+    column += 2;
+    updatePosition(str);
+    style = style.slice(i);
+    column += 2;
+    return pos({
+      type: TYPE_COMMENT,
+      comment: str
+    });
+  }
+  function declaration() {
+    var pos = position();
+    var prop = match(PROPERTY_REGEX);
+    if (!prop) return;
+    comment();
+    if (!match(COLON_REGEX)) return error("property missing ':'");
+    var val = match(VALUE_REGEX);
+    var ret = pos({
+      type: TYPE_DECLARATION,
+      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+      value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+    });
+    match(SEMICOLON_REGEX);
+    return ret;
+  }
+  function declarations() {
+    var decls = [];
+    comments(decls);
+    var decl;
+    while (decl = declaration()) {
+      if (decl !== false) {
+        decls.push(decl);
+        comments(decls);
+      }
+    }
+    return decls;
+  }
+  whitespace();
+  return declarations();
+}
+function trim(str) {
+  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+}
+function StyleToObject(style, iterator) {
+  let styleObject = null;
+  if (!style || typeof style !== "string") {
+    return styleObject;
+  }
+  const declarations = index(style);
+  const hasIterator = typeof iterator === "function";
+  declarations.forEach((declaration) => {
+    if (declaration.type !== "declaration") {
+      return;
+    }
+    const { property, value } = declaration;
+    if (hasIterator) {
+      iterator(property, value, declaration);
+    } else if (value) {
+      styleObject = styleObject || {};
+      styleObject[property] = value;
+    }
+  });
+  return styleObject;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+const CLASS_VALUE_PRIMITIVE_TYPES = ["string", "number", "bigint", "boolean"];
+function isClassValue(value) {
+  if (value === null || value === void 0)
+    return true;
+  if (CLASS_VALUE_PRIMITIVE_TYPES.includes(typeof value))
+    return true;
+  if (Array.isArray(value))
+    return value.every((item) => isClassValue(item));
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype)
+      return false;
+    return true;
+  }
+  return false;
+}
+const BoxSymbol = /* @__PURE__ */ Symbol("box");
+const isWritableSymbol = /* @__PURE__ */ Symbol("is-writable");
+function boxWith(getter, setter) {
+  const derived$1 = derived(getter);
+  if (setter) {
+    return {
+      [BoxSymbol]: true,
+      [isWritableSymbol]: true,
+      get current() {
+        return derived$1();
+      },
+      set current(v) {
+        setter(v);
+      }
+    };
+  }
+  return {
+    [BoxSymbol]: true,
+    get current() {
+      return getter();
+    }
+  };
+}
+function isBox(value) {
+  return isObject(value) && BoxSymbol in value;
+}
+function isWritableBox(value) {
+  return isBox(value) && isWritableSymbol in value;
+}
+function boxFrom(value) {
+  if (isBox(value)) return value;
+  if (isFunction(value)) return boxWith(value);
+  return simpleBox(value);
+}
+function boxFlatten(boxes) {
+  return Object.entries(boxes).reduce(
+    (acc, [key, b]) => {
+      if (!isBox(b)) {
+        return Object.assign(acc, { [key]: b });
+      }
+      if (isWritableBox(b)) {
+        Object.defineProperty(acc, key, {
+          get() {
+            return b.current;
+          },
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          set(v) {
+            b.current = v;
+          }
+        });
+      } else {
+        Object.defineProperty(acc, key, {
+          get() {
+            return b.current;
+          }
+        });
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function toReadonlyBox(b) {
+  if (!isWritableBox(b)) return b;
+  return {
+    [BoxSymbol]: true,
+    get current() {
+      return b.current;
+    }
+  };
+}
+function simpleBox(initialValue) {
+  let current = initialValue;
+  return {
+    [BoxSymbol]: true,
+    [isWritableSymbol]: true,
+    get current() {
+      return current;
+    },
+    set current(v) {
+      current = v;
+    }
+  };
+}
+function composeHandlers(...handlers) {
+  return function(e) {
+    for (const handler of handlers) {
+      if (!handler)
+        continue;
+      if (e.defaultPrevented)
+        return;
+      if (typeof handler === "function") {
+        handler.call(this, e);
+      } else {
+        handler.current?.call(this, e);
+      }
+    }
+  };
+}
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = ["-", "_", "/", "."];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char))
+    return void 0;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str) {
+  const parts = [];
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = STR_SPLITTERS.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = void 0;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function pascalCase(str) {
+  if (!str)
+    return "";
+  return splitByCase(str).map((p) => upperFirst(p)).join("");
+}
+function camelCase(str) {
+  return lowerFirst(pascalCase(str || ""));
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function cssToStyleObj(css) {
+  if (!css)
+    return {};
+  const styleObj = {};
+  function iterator(name, value) {
+    if (name.startsWith("-moz-") || name.startsWith("-webkit-") || name.startsWith("-ms-") || name.startsWith("-o-")) {
+      styleObj[pascalCase(name)] = value;
+      return;
+    }
+    if (name.startsWith("--")) {
+      styleObj[name] = value;
+      return;
+    }
+    styleObj[camelCase(name)] = value;
+  }
+  StyleToObject(css, iterator);
+  return styleObj;
+}
+function executeCallbacks(...callbacks) {
+  return (...args) => {
+    for (const callback of callbacks) {
+      if (typeof callback === "function") {
+        callback(...args);
+      }
+    }
+  };
+}
+function createParser(matcher, replacer) {
+  const regex = RegExp(matcher, "g");
+  return (str) => {
+    if (typeof str !== "string") {
+      throw new TypeError(`expected an argument of type string, but got ${typeof str}`);
+    }
+    if (!str.match(regex))
+      return str;
+    return str.replace(regex, replacer);
+  };
+}
+const camelToKebab = createParser(/[A-Z]/, (match) => `-${match.toLowerCase()}`);
+function styleToCSS(styleObj) {
+  if (!styleObj || typeof styleObj !== "object" || Array.isArray(styleObj)) {
+    throw new TypeError(`expected an argument of type object, but got ${typeof styleObj}`);
+  }
+  return Object.keys(styleObj).map((property) => `${camelToKebab(property)}: ${styleObj[property]};`).join("\n");
+}
+function styleToString(style = {}) {
+  return styleToCSS(style).replace("\n", " ");
+}
+const EVENT_LIST = [
+  "onabort",
+  "onanimationcancel",
+  "onanimationend",
+  "onanimationiteration",
+  "onanimationstart",
+  "onauxclick",
+  "onbeforeinput",
+  "onbeforetoggle",
+  "onblur",
+  "oncancel",
+  "oncanplay",
+  "oncanplaythrough",
+  "onchange",
+  "onclick",
+  "onclose",
+  "oncompositionend",
+  "oncompositionstart",
+  "oncompositionupdate",
+  "oncontextlost",
+  "oncontextmenu",
+  "oncontextrestored",
+  "oncopy",
+  "oncuechange",
+  "oncut",
+  "ondblclick",
+  "ondrag",
+  "ondragend",
+  "ondragenter",
+  "ondragleave",
+  "ondragover",
+  "ondragstart",
+  "ondrop",
+  "ondurationchange",
+  "onemptied",
+  "onended",
+  "onerror",
+  "onfocus",
+  "onfocusin",
+  "onfocusout",
+  "onformdata",
+  "ongotpointercapture",
+  "oninput",
+  "oninvalid",
+  "onkeydown",
+  "onkeypress",
+  "onkeyup",
+  "onload",
+  "onloadeddata",
+  "onloadedmetadata",
+  "onloadstart",
+  "onlostpointercapture",
+  "onmousedown",
+  "onmouseenter",
+  "onmouseleave",
+  "onmousemove",
+  "onmouseout",
+  "onmouseover",
+  "onmouseup",
+  "onpaste",
+  "onpause",
+  "onplay",
+  "onplaying",
+  "onpointercancel",
+  "onpointerdown",
+  "onpointerenter",
+  "onpointerleave",
+  "onpointermove",
+  "onpointerout",
+  "onpointerover",
+  "onpointerup",
+  "onprogress",
+  "onratechange",
+  "onreset",
+  "onresize",
+  "onscroll",
+  "onscrollend",
+  "onsecuritypolicyviolation",
+  "onseeked",
+  "onseeking",
+  "onselect",
+  "onselectionchange",
+  "onselectstart",
+  "onslotchange",
+  "onstalled",
+  "onsubmit",
+  "onsuspend",
+  "ontimeupdate",
+  "ontoggle",
+  "ontouchcancel",
+  "ontouchend",
+  "ontouchmove",
+  "ontouchstart",
+  "ontransitioncancel",
+  "ontransitionend",
+  "ontransitionrun",
+  "ontransitionstart",
+  "onvolumechange",
+  "onwaiting",
+  "onwebkitanimationend",
+  "onwebkitanimationiteration",
+  "onwebkitanimationstart",
+  "onwebkittransitionend",
+  "onwheel"
+];
+const EVENT_LIST_SET = new Set(EVENT_LIST);
+function isEventHandler(key) {
+  return EVENT_LIST_SET.has(key);
+}
+function mergeProps(...args) {
+  const result = { ...args[0] };
+  for (let i = 1; i < args.length; i++) {
+    const props = args[i];
+    if (!props)
+      continue;
+    for (const key of Object.keys(props)) {
+      const a = result[key];
+      const b = props[key];
+      const aIsFunction = typeof a === "function";
+      const bIsFunction = typeof b === "function";
+      if (aIsFunction && typeof bIsFunction && isEventHandler(key)) {
+        const aHandler = a;
+        const bHandler = b;
+        result[key] = composeHandlers(aHandler, bHandler);
+      } else if (aIsFunction && bIsFunction) {
+        result[key] = executeCallbacks(a, b);
+      } else if (key === "class") {
+        const aIsClassValue = isClassValue(a);
+        const bIsClassValue = isClassValue(b);
+        if (aIsClassValue && bIsClassValue) {
+          result[key] = clsx(a, b);
+        } else if (aIsClassValue) {
+          result[key] = clsx(a);
+        } else if (bIsClassValue) {
+          result[key] = clsx(b);
+        }
+      } else if (key === "style") {
+        const aIsObject = typeof a === "object";
+        const bIsObject = typeof b === "object";
+        const aIsString = typeof a === "string";
+        const bIsString = typeof b === "string";
+        if (aIsObject && bIsObject) {
+          result[key] = { ...a, ...b };
+        } else if (aIsObject && bIsString) {
+          const parsedStyle = cssToStyleObj(b);
+          result[key] = { ...a, ...parsedStyle };
+        } else if (aIsString && bIsObject) {
+          const parsedStyle = cssToStyleObj(a);
+          result[key] = { ...parsedStyle, ...b };
+        } else if (aIsString && bIsString) {
+          const parsedStyleA = cssToStyleObj(a);
+          const parsedStyleB = cssToStyleObj(b);
+          result[key] = { ...parsedStyleA, ...parsedStyleB };
+        } else if (aIsObject) {
+          result[key] = a;
+        } else if (bIsObject) {
+          result[key] = b;
+        } else if (aIsString) {
+          result[key] = a;
+        } else if (bIsString) {
+          result[key] = b;
+        }
+      } else {
+        result[key] = b !== void 0 ? b : a;
+      }
+    }
+    for (const key of Object.getOwnPropertySymbols(props)) {
+      const a = result[key];
+      const b = props[key];
+      result[key] = b !== void 0 ? b : a;
+    }
+  }
+  if (typeof result.style === "object") {
+    result.style = styleToString(result.style).replaceAll("\n", " ");
+  }
+  if (result.hidden === false) {
+    result.hidden = void 0;
+    delete result.hidden;
+  }
+  if (result.disabled === false) {
+    result.disabled = void 0;
+    delete result.disabled;
+  }
+  return result;
+}
+function createAttachmentKey() {
+  return Symbol(ATTACHMENT_KEY);
+}
+function attachRef(ref, onChange) {
+  return {
+    [createAttachmentKey()]: (node) => {
+      if (isBox(ref)) {
+        ref.current = node;
+        run(() => onChange?.(node));
+        return () => {
+          if ("isConnected" in node && node.isConnected)
+            return;
+          ref.current = null;
+          onChange?.(null);
+        };
+      }
+      ref(node);
+      run(() => onChange?.(node));
+      return () => {
+        if ("isConnected" in node && node.isConnected)
+          return;
+        ref(null);
+        onChange?.(null);
+      };
+    }
+  };
+}
+function boolToStr(condition) {
+  return condition ? "true" : "false";
+}
+function boolToStrTrueOrUndef(condition) {
+  return condition ? "true" : void 0;
+}
+function boolToEmptyStrOrUndef(condition) {
+  return condition ? "" : void 0;
+}
+function boolToTrueOrUndef(condition) {
+  return condition ? true : void 0;
+}
+function getDataOpenClosed(condition) {
+  return condition ? "open" : "closed";
+}
+function getDataTransitionAttrs(state) {
+  if (state === "starting")
+    return { "data-starting-style": "" };
+  if (state === "ending")
+    return { "data-ending-style": "" };
+  return {};
+}
+function getAriaChecked(checked, indeterminate) {
+  if (indeterminate)
+    return "mixed";
+  return checked ? "true" : "false";
+}
+class BitsAttrs {
+  #variant;
+  #prefix;
+  attrs;
+  constructor(config) {
+    this.#variant = config.getVariant ? config.getVariant() : null;
+    this.#prefix = this.#variant ? `data-${this.#variant}-` : `data-${config.component}-`;
+    this.getAttr = this.getAttr.bind(this);
+    this.selector = this.selector.bind(this);
+    this.attrs = Object.fromEntries(config.parts.map((part) => [part, this.getAttr(part)]));
+  }
+  getAttr(part, variantOverride) {
+    if (variantOverride)
+      return `data-${variantOverride}-${part}`;
+    return `${this.#prefix}${part}`;
+  }
+  selector(part, variantOverride) {
+    return `[${this.getAttr(part, variantOverride)}]`;
+  }
+}
+function createBitsAttrs(config) {
+  const bitsAttrs = new BitsAttrs(config);
+  return {
+    ...bitsAttrs.attrs,
+    selector: bitsAttrs.selector,
+    getAttr: bitsAttrs.getAttr
+  };
+}
+function createId(prefixOrUid, uid) {
+  return `bits-${prefixOrUid}`;
+}
+
+export { BoxSymbol as B, StyleToObject as S, boxWith as a, boxFrom as b, boxFlatten as c, isBox as d, isWritableBox as e, createBitsAttrs as f, executeCallbacks as g, composeHandlers as h, isWritableSymbol as i, isObject as j, attachRef as k, getDataOpenClosed as l, boolToEmptyStrOrUndef as m, boolToStr as n, getDataTransitionAttrs as o, mergeProps as p, createId as q, styleToString as r, simpleBox as s, toReadonlyBox as t, boolToTrueOrUndef as u, boolToStrTrueOrUndef as v, cssToStyleObj as w, createAttachmentKey as x, getAriaChecked as y };
+//# sourceMappingURL=create-id.js-DLd1XgVR.js.map