@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/stylis/src/Parser.js

@@ -0,0 +1,157 @@
+import { DECLARATION, COMMENT, RULESET } from "./Enum.js";
+import { strlen, append, charat, replace, indexof, sizeof, substr, abs, trim, from } from "./Utility.js";
+import { dealloc, alloc, next, peek, delimit, identifier, commenter, escaping, whitespace, node, char, prev, caret } from "./Tokenizer.js";
+function compile(value) {
+  return dealloc(parse("", null, null, null, [""], value = alloc(value), 0, [0], value));
+}
+function parse(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+  var index = 0;
+  var offset = 0;
+  var length = pseudo;
+  var atrule = 0;
+  var property = 0;
+  var previous = 0;
+  var variable = 1;
+  var scanning = 1;
+  var ampersand = 1;
+  var character = 0;
+  var type = "";
+  var props = rules;
+  var children = rulesets;
+  var reference = rule;
+  var characters = type;
+  while (scanning)
+    switch (previous = character, character = next()) {
+      // (
+      case 40:
+        if (previous != 108 && charat(characters, length - 1) == 58) {
+          if (indexof(characters += replace(delimit(character), "&", "&\f"), "&\f") != -1)
+            ampersand = -1;
+          break;
+        }
+      // " ' [
+      case 34:
+      case 39:
+      case 91:
+        characters += delimit(character);
+        break;
+      // \t \n \r \s
+      case 9:
+      case 10:
+      case 13:
+      case 32:
+        characters += whitespace(previous);
+        break;
+      // \
+      case 92:
+        characters += escaping(caret() - 1, 7);
+        continue;
+      // /
+      case 47:
+        switch (peek()) {
+          case 42:
+          case 47:
+            append(comment(commenter(next(), caret()), root, parent), declarations);
+            break;
+          default:
+            characters += "/";
+        }
+        break;
+      // {
+      case 123 * variable:
+        points[index++] = strlen(characters) * ampersand;
+      // } ; \0
+      case 125 * variable:
+      case 59:
+      case 0:
+        switch (character) {
+          // \0 }
+          case 0:
+          case 125:
+            scanning = 0;
+          // ;
+          case 59 + offset:
+            if (ampersand == -1) characters = replace(characters, /\f/g, "");
+            if (property > 0 && strlen(characters) - length)
+              append(property > 32 ? declaration(characters + ";", rule, parent, length - 1) : declaration(replace(characters, " ", "") + ";", rule, parent, length - 2), declarations);
+            break;
+          // @ ;
+          case 59:
+            characters += ";";
+          // { rule/at-rule
+          default:
+            append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets);
+            if (character === 123)
+              if (offset === 0)
+                parse(characters, root, reference, reference, props, rulesets, length, points, children);
+              else
+                switch (atrule === 99 && charat(characters, 3) === 110 ? 100 : atrule) {
+                  // d l m s
+                  case 100:
+                  case 108:
+                  case 109:
+                  case 115:
+                    parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children);
+                    break;
+                  default:
+                    parse(characters, reference, reference, reference, [""], children, 0, points, children);
+                }
+        }
+        index = offset = property = 0, variable = ampersand = 1, type = characters = "", length = pseudo;
+        break;
+      // :
+      case 58:
+        length = 1 + strlen(characters), property = previous;
+      default:
+        if (variable < 1) {
+          if (character == 123)
+            --variable;
+          else if (character == 125 && variable++ == 0 && prev() == 125)
+            continue;
+        }
+        switch (characters += from(character), character * variable) {
+          // &
+          case 38:
+            ampersand = offset > 0 ? 1 : (characters += "\f", -1);
+            break;
+          // ,
+          case 44:
+            points[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1;
+            break;
+          // @
+          case 64:
+            if (peek() === 45)
+              characters += delimit(next());
+            atrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++;
+            break;
+          // -
+          case 45:
+            if (previous === 45 && strlen(characters) == 2)
+              variable = 0;
+        }
+    }
+  return rulesets;
+}
+function ruleset(value, root, parent, index, offset, rules, points, type, props, children, length) {
+  var post = offset - 1;
+  var rule = offset === 0 ? rules : [""];
+  var size = sizeof(rule);
+  for (var i = 0, j = 0, k = 0; i < index; ++i)
+    for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
+      if (z = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x])))
+        props[k++] = z;
+  return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length);
+}
+function comment(value, root, parent) {
+  return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0);
+}
+function declaration(value, root, parent, length) {
+  return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length);
+}
+export {
+  comment,
+  compile,
+  declaration,
+  parse,
+  ruleset
+};

package/dist/node_modules/stylis/src/Serializer.js

@@ -0,0 +1,29 @@
+import { RULESET, KEYFRAMES, COMMENT, DECLARATION, IMPORT, LAYER } from "./Enum.js";
+import { sizeof, strlen } from "./Utility.js";
+function serialize(children, callback) {
+  var output = "";
+  var length = sizeof(children);
+  for (var i = 0; i < length; i++)
+    output += callback(children[i], i, children, callback) || "";
+  return output;
+}
+function stringify(element, index, children, callback) {
+  switch (element.type) {
+    case LAYER:
+      if (element.children.length) break;
+    case IMPORT:
+    case DECLARATION:
+      return element.return = element.return || element.value;
+    case COMMENT:
+      return "";
+    case KEYFRAMES:
+      return element.return = element.value + "{" + serialize(element.children, callback) + "}";
+    case RULESET:
+      element.value = element.props.join(",");
+  }
+  return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
+}
+export {
+  serialize,
+  stringify
+};

package/dist/node_modules/stylis/src/Tokenizer.js

@@ -0,0 +1,160 @@
+import { strlen, charat, trim, from, substr, assign } from "./Utility.js";
+var line = 1;
+var column = 1;
+var length = 0;
+var position = 0;
+var character = 0;
+var characters = "";
+function node(value, root, parent, type, props, children, length2) {
+  return { value, root, parent, type, props, children, line, column, length: length2, return: "" };
+}
+function copy(root, props) {
+  return assign(node("", null, null, "", null, null, 0), root, { length: -root.length }, props);
+}
+function char() {
+  return character;
+}
+function prev() {
+  character = position > 0 ? charat(characters, --position) : 0;
+  if (column--, character === 10)
+    column = 1, line--;
+  return character;
+}
+function next() {
+  character = position < length ? charat(characters, position++) : 0;
+  if (column++, character === 10)
+    column = 1, line++;
+  return character;
+}
+function peek() {
+  return charat(characters, position);
+}
+function caret() {
+  return position;
+}
+function slice(begin, end) {
+  return substr(characters, begin, end);
+}
+function token(type) {
+  switch (type) {
+    // \0 \t \n \r \s whitespace token
+    case 0:
+    case 9:
+    case 10:
+    case 13:
+    case 32:
+      return 5;
+    // ! + , / > @ ~ isolate token
+    case 33:
+    case 43:
+    case 44:
+    case 47:
+    case 62:
+    case 64:
+    case 126:
+    // ; { } breakpoint token
+    case 59:
+    case 123:
+    case 125:
+      return 4;
+    // : accompanied token
+    case 58:
+      return 3;
+    // " ' ( [ opening delimit token
+    case 34:
+    case 39:
+    case 40:
+    case 91:
+      return 2;
+    // ) ] closing delimit token
+    case 41:
+    case 93:
+      return 1;
+  }
+  return 0;
+}
+function alloc(value) {
+  return line = column = 1, length = strlen(characters = value), position = 0, [];
+}
+function dealloc(value) {
+  return characters = "", value;
+}
+function delimit(type) {
+  return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
+}
+function whitespace(type) {
+  while (character = peek())
+    if (character < 33)
+      next();
+    else
+      break;
+  return token(type) > 2 || token(character) > 3 ? "" : " ";
+}
+function escaping(index, count) {
+  while (--count && next())
+    if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
+      break;
+  return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
+}
+function delimiter(type) {
+  while (next())
+    switch (character) {
+      // ] ) " '
+      case type:
+        return position;
+      // " '
+      case 34:
+      case 39:
+        if (type !== 34 && type !== 39)
+          delimiter(character);
+        break;
+      // (
+      case 40:
+        if (type === 41)
+          delimiter(type);
+        break;
+      // \
+      case 92:
+        next();
+        break;
+    }
+  return position;
+}
+function commenter(type, index) {
+  while (next())
+    if (type + character === 47 + 10)
+      break;
+    else if (type + character === 42 + 42 && peek() === 47)
+      break;
+  return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
+}
+function identifier(index) {
+  while (!token(peek()))
+    next();
+  return slice(index, position);
+}
+export {
+  alloc,
+  caret,
+  char,
+  character,
+  characters,
+  column,
+  commenter,
+  copy,
+  dealloc,
+  delimit,
+  delimiter,
+  escaping,
+  identifier,
+  length,
+  line,
+  next,
+  node,
+  peek,
+  position,
+  prev,
+  slice,
+  token,
+  whitespace
+};

package/dist/node_modules/stylis/src/Utility.js

@@ -0,0 +1,52 @@
+var abs = Math.abs;
+var from = String.fromCharCode;
+var assign = Object.assign;
+function hash(value, length) {
+  return charat(value, 0) ^ 45 ? (((length << 2 ^ charat(value, 0)) << 2 ^ charat(value, 1)) << 2 ^ charat(value, 2)) << 2 ^ charat(value, 3) : 0;
+}
+function trim(value) {
+  return value.trim();
+}
+function match(value, pattern) {
+  return (value = pattern.exec(value)) ? value[0] : value;
+}
+function replace(value, pattern, replacement) {
+  return value.replace(pattern, replacement);
+}
+function indexof(value, search) {
+  return value.indexOf(search);
+}
+function charat(value, index) {
+  return value.charCodeAt(index) | 0;
+}
+function substr(value, begin, end) {
+  return value.slice(begin, end);
+}
+function strlen(value) {
+  return value.length;
+}
+function sizeof(value) {
+  return value.length;
+}
+function append(value, array) {
+  return array.push(value), value;
+}
+function combine(array, callback) {
+  return array.map(callback).join("");
+}
+export {
+  abs,
+  append,
+  assign,
+  charat,
+  combine,
+  from,
+  hash,
+  indexof,
+  match,
+  replace,
+  sizeof,
+  strlen,
+  substr,
+  trim
+};

package/dist/node_modules/tiny-case/index.js

@@ -0,0 +1,33 @@
+var tinyCase;
+var hasRequiredTinyCase;
+function requireTinyCase() {
+  if (hasRequiredTinyCase) return tinyCase;
+  hasRequiredTinyCase = 1;
+  const reWords = /[A-Z\xc0-\xd6\xd8-\xde]?[a-z\xdf-\xf6\xf8-\xff]+(?:['’](?:d|ll|m|re|s|t|ve))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde]|$)|(?:[A-Z\xc0-\xd6\xd8-\xde]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:D|LL|M|RE|S|T|VE))?(?=[\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000]|[A-Z\xc0-\xd6\xd8-\xde](?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])|$)|[A-Z\xc0-\xd6\xd8-\xde]?(?:[a-z\xdf-\xf6\xf8-\xff]|[^\ud800-\udfff\xac\xb1\xd7\xf7\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\xbf\u2000-\u206f \t\x0b\f\xa0\ufeff\n\r\u2028\u2029\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000\d+\u2700-\u27bfa-z\xdf-\xf6\xf8-\xffA-Z\xc0-\xd6\xd8-\xde])+(?:['’](?:d|ll|m|re|s|t|ve))?|[A-Z\xc0-\xd6\xd8-\xde]+(?:['’](?:D|LL|M|RE|S|T|VE))?|\d*(?:1ST|2ND|3RD|(?![123])\dTH)(?=\b|[a-z_])|\d*(?:1st|2nd|3rd|(?![123])\dth)(?=\b|[A-Z_])|\d+|(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?(?:\u200d(?:[^\ud800-\udfff]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff])[\ufe0e\ufe0f]?(?:[\u0300-\u036f\ufe20-\ufe2f\u20d0-\u20ff]|\ud83c[\udffb-\udfff])?)*/g;
+  const words = (str) => str.match(reWords) || [];
+  const upperFirst = (str) => str[0].toUpperCase() + str.slice(1);
+  const join = (str, d) => words(str).join(d).toLowerCase();
+  const camelCase = (str) => words(str).reduce(
+    (acc, next) => `${acc}${!acc ? next.toLowerCase() : next[0].toUpperCase() + next.slice(1).toLowerCase()}`,
+    ""
+  );
+  const pascalCase = (str) => upperFirst(camelCase(str));
+  const snakeCase = (str) => join(str, "_");
+  const kebabCase = (str) => join(str, "-");
+  const sentenceCase = (str) => upperFirst(join(str, " "));
+  const titleCase = (str) => words(str).map(upperFirst).join(" ");
+  tinyCase = {
+    words,
+    upperFirst,
+    camelCase,
+    pascalCase,
+    snakeCase,
+    kebabCase,
+    sentenceCase,
+    titleCase
+  };
+  return tinyCase;
+}
+export {
+  requireTinyCase as __require
+};

package/dist/node_modules/tiny-warning/dist/tiny-warning.esm.js

@@ -0,0 +1,16 @@
+var isProduction = process.env.NODE_ENV === "production";
+function warning(condition, message) {
+  if (!isProduction) {
+    var text = "Warning: " + message;
+    if (typeof console !== "undefined") {
+      console.warn(text);
+    }
+    try {
+      throw Error(text);
+    } catch (x) {
+    }
+  }
+}
+export {
+  warning as default
+};

package/dist/node_modules/to-camel-case/index.js

@@ -0,0 +1,18 @@
+import { __require as requireToSpaceCase } from "../to-space-case/index.js";
+var toCamelCase_1;
+var hasRequiredToCamelCase;
+function requireToCamelCase() {
+  if (hasRequiredToCamelCase) return toCamelCase_1;
+  hasRequiredToCamelCase = 1;
+  var space = requireToSpaceCase();
+  toCamelCase_1 = toCamelCase;
+  function toCamelCase(string) {
+    return space(string).replace(/\s(\w)/g, function(matches, letter) {
+      return letter.toUpperCase();
+    });
+  }
+  return toCamelCase_1;
+}
+export {
+  requireToCamelCase as __require
+};

package/dist/node_modules/to-no-case/index.js

@@ -0,0 +1,32 @@
+var toNoCase_1;
+var hasRequiredToNoCase;
+function requireToNoCase() {
+  if (hasRequiredToNoCase) return toNoCase_1;
+  hasRequiredToNoCase = 1;
+  toNoCase_1 = toNoCase;
+  var hasSpace = /\s/;
+  var hasSeparator = /(_|-|\.|:)/;
+  var hasCamel = /([a-z][A-Z]|[A-Z][a-z])/;
+  function toNoCase(string) {
+    if (hasSpace.test(string)) return string.toLowerCase();
+    if (hasSeparator.test(string)) return (unseparate(string) || string).toLowerCase();
+    if (hasCamel.test(string)) return uncamelize(string).toLowerCase();
+    return string.toLowerCase();
+  }
+  var separatorSplitter = /[\W_]+(.|$)/g;
+  function unseparate(string) {
+    return string.replace(separatorSplitter, function(m, next) {
+      return next ? " " + next : "";
+    });
+  }
+  var camelSplitter = /(.)([A-Z]+)/g;
+  function uncamelize(string) {
+    return string.replace(camelSplitter, function(m, previous, uppers) {
+      return previous + " " + uppers.toLowerCase().split("").join(" ");
+    });
+  }
+  return toNoCase_1;
+}
+export {
+  requireToNoCase as __require
+};

package/dist/node_modules/to-space-case/index.js

@@ -0,0 +1,18 @@
+import { __require as requireToNoCase } from "../to-no-case/index.js";
+var toSpaceCase_1;
+var hasRequiredToSpaceCase;
+function requireToSpaceCase() {
+  if (hasRequiredToSpaceCase) return toSpaceCase_1;
+  hasRequiredToSpaceCase = 1;
+  var clean = requireToNoCase();
+  toSpaceCase_1 = toSpaceCase;
+  function toSpaceCase(string) {
+    return clean(string).replace(/[\W_]+(.|$)/g, function(matches, match) {
+      return match ? " " + match : "";
+    }).trim();
+  }
+  return toSpaceCase_1;
+}
+export {
+  requireToSpaceCase as __require
+};

package/dist/node_modules/toggle-selection/index.js

@@ -0,0 +1,42 @@
+var toggleSelection;
+var hasRequiredToggleSelection;
+function requireToggleSelection() {
+  if (hasRequiredToggleSelection) return toggleSelection;
+  hasRequiredToggleSelection = 1;
+  toggleSelection = function() {
+    var selection = document.getSelection();
+    if (!selection.rangeCount) {
+      return function() {
+      };
+    }
+    var active = document.activeElement;
+    var ranges = [];
+    for (var i = 0; i < selection.rangeCount; i++) {
+      ranges.push(selection.getRangeAt(i));
+    }
+    switch (active.tagName.toUpperCase()) {
+      // .toUpperCase handles XHTML
+      case "INPUT":
+      case "TEXTAREA":
+        active.blur();
+        break;
+      default:
+        active = null;
+        break;
+    }
+    selection.removeAllRanges();
+    return function() {
+      selection.type === "Caret" && selection.removeAllRanges();
+      if (!selection.rangeCount) {
+        ranges.forEach(function(range) {
+          selection.addRange(range);
+        });
+      }
+      active && active.focus();
+    };
+  };
+  return toggleSelection;
+}
+export {
+  requireToggleSelection as __require
+};

package/dist/node_modules/toposort/index.js

@@ -0,0 +1,79 @@
+import { __module as toposort } from "../../_virtual/index24.js";
+var hasRequiredToposort;
+function requireToposort() {
+  if (hasRequiredToposort) return toposort.exports;
+  hasRequiredToposort = 1;
+  toposort.exports = function(edges) {
+    return toposort$1(uniqueNodes(edges), edges);
+  };
+  toposort.exports.array = toposort$1;
+  function toposort$1(nodes, edges) {
+    var cursor = nodes.length, sorted = new Array(cursor), visited = {}, i = cursor, outgoingEdges = makeOutgoingEdges(edges), nodesHash = makeNodesHash(nodes);
+    edges.forEach(function(edge) {
+      if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+        throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+      }
+    });
+    while (i--) {
+      if (!visited[i]) visit(nodes[i], i, /* @__PURE__ */ new Set());
+    }
+    return sorted;
+    function visit(node, i2, predecessors) {
+      if (predecessors.has(node)) {
+        var nodeRep;
+        try {
+          nodeRep = ", node was:" + JSON.stringify(node);
+        } catch (e) {
+          nodeRep = "";
+        }
+        throw new Error("Cyclic dependency" + nodeRep);
+      }
+      if (!nodesHash.has(node)) {
+        throw new Error("Found unknown node. Make sure to provided all involved nodes. Unknown node: " + JSON.stringify(node));
+      }
+      if (visited[i2]) return;
+      visited[i2] = true;
+      var outgoing = outgoingEdges.get(node) || /* @__PURE__ */ new Set();
+      outgoing = Array.from(outgoing);
+      if (i2 = outgoing.length) {
+        predecessors.add(node);
+        do {
+          var child = outgoing[--i2];
+          visit(child, nodesHash.get(child), predecessors);
+        } while (i2);
+        predecessors.delete(node);
+      }
+      sorted[--cursor] = node;
+    }
+  }
+  function uniqueNodes(arr) {
+    var res = /* @__PURE__ */ new Set();
+    for (var i = 0, len = arr.length; i < len; i++) {
+      var edge = arr[i];
+      res.add(edge[0]);
+      res.add(edge[1]);
+    }
+    return Array.from(res);
+  }
+  function makeOutgoingEdges(arr) {
+    var edges = /* @__PURE__ */ new Map();
+    for (var i = 0, len = arr.length; i < len; i++) {
+      var edge = arr[i];
+      if (!edges.has(edge[0])) edges.set(edge[0], /* @__PURE__ */ new Set());
+      if (!edges.has(edge[1])) edges.set(edge[1], /* @__PURE__ */ new Set());
+      edges.get(edge[0]).add(edge[1]);
+    }
+    return edges;
+  }
+  function makeNodesHash(arr) {
+    var res = /* @__PURE__ */ new Map();
+    for (var i = 0, len = arr.length; i < len; i++) {
+      res.set(arr[i], i);
+    }
+    return res;
+  }
+  return toposort.exports;
+}
+export {
+  requireToposort as __require
+};

package/dist/node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js

@@ -0,0 +1,5 @@
+import { useLayoutEffect } from "react";
+var index = useLayoutEffect;
+export {
+  index as default
+};