@stokr/components-library 3.0.66 → 3.0.67

package/dist/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js

@@ -0,0 +1,495 @@
+var MapShim = (function() {
+  if (typeof Map !== "undefined") {
+    return Map;
+  }
+  function getIndex(arr, key) {
+    var result = -1;
+    arr.some(function(entry, index2) {
+      if (entry[0] === key) {
+        result = index2;
+        return true;
+      }
+      return false;
+    });
+    return result;
+  }
+  return (
+    /** @class */
+    (function() {
+      function class_1() {
+        this.__entries__ = [];
+      }
+      Object.defineProperty(class_1.prototype, "size", {
+        /**
+         * @returns {boolean}
+         */
+        get: function() {
+          return this.__entries__.length;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      class_1.prototype.get = function(key) {
+        var index2 = getIndex(this.__entries__, key);
+        var entry = this.__entries__[index2];
+        return entry && entry[1];
+      };
+      class_1.prototype.set = function(key, value) {
+        var index2 = getIndex(this.__entries__, key);
+        if (~index2) {
+          this.__entries__[index2][1] = value;
+        } else {
+          this.__entries__.push([key, value]);
+        }
+      };
+      class_1.prototype.delete = function(key) {
+        var entries = this.__entries__;
+        var index2 = getIndex(entries, key);
+        if (~index2) {
+          entries.splice(index2, 1);
+        }
+      };
+      class_1.prototype.has = function(key) {
+        return !!~getIndex(this.__entries__, key);
+      };
+      class_1.prototype.clear = function() {
+        this.__entries__.splice(0);
+      };
+      class_1.prototype.forEach = function(callback, ctx) {
+        if (ctx === void 0) {
+          ctx = null;
+        }
+        for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
+          var entry = _a[_i];
+          callback.call(ctx, entry[1], entry[0]);
+        }
+      };
+      return class_1;
+    })()
+  );
+})();
+var isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && window.document === document;
+var global$1 = (function() {
+  if (typeof global !== "undefined" && global.Math === Math) {
+    return global;
+  }
+  if (typeof self !== "undefined" && self.Math === Math) {
+    return self;
+  }
+  if (typeof window !== "undefined" && window.Math === Math) {
+    return window;
+  }
+  return Function("return this")();
+})();
+var requestAnimationFrame$1 = (function() {
+  if (typeof requestAnimationFrame === "function") {
+    return requestAnimationFrame.bind(global$1);
+  }
+  return function(callback) {
+    return setTimeout(function() {
+      return callback(Date.now());
+    }, 1e3 / 60);
+  };
+})();
+var trailingTimeout = 2;
+function throttle(callback, delay) {
+  var leadingCall = false, trailingCall = false, lastCallTime = 0;
+  function resolvePending() {
+    if (leadingCall) {
+      leadingCall = false;
+      callback();
+    }
+    if (trailingCall) {
+      proxy();
+    }
+  }
+  function timeoutCallback() {
+    requestAnimationFrame$1(resolvePending);
+  }
+  function proxy() {
+    var timeStamp = Date.now();
+    if (leadingCall) {
+      if (timeStamp - lastCallTime < trailingTimeout) {
+        return;
+      }
+      trailingCall = true;
+    } else {
+      leadingCall = true;
+      trailingCall = false;
+      setTimeout(timeoutCallback, delay);
+    }
+    lastCallTime = timeStamp;
+  }
+  return proxy;
+}
+var REFRESH_DELAY = 20;
+var transitionKeys = ["top", "right", "bottom", "left", "width", "height", "size", "weight"];
+var mutationObserverSupported = typeof MutationObserver !== "undefined";
+var ResizeObserverController = (
+  /** @class */
+  (function() {
+    function ResizeObserverController2() {
+      this.connected_ = false;
+      this.mutationEventsAdded_ = false;
+      this.mutationsObserver_ = null;
+      this.observers_ = [];
+      this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
+      this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
+    }
+    ResizeObserverController2.prototype.addObserver = function(observer) {
+      if (!~this.observers_.indexOf(observer)) {
+        this.observers_.push(observer);
+      }
+      if (!this.connected_) {
+        this.connect_();
+      }
+    };
+    ResizeObserverController2.prototype.removeObserver = function(observer) {
+      var observers2 = this.observers_;
+      var index2 = observers2.indexOf(observer);
+      if (~index2) {
+        observers2.splice(index2, 1);
+      }
+      if (!observers2.length && this.connected_) {
+        this.disconnect_();
+      }
+    };
+    ResizeObserverController2.prototype.refresh = function() {
+      var changesDetected = this.updateObservers_();
+      if (changesDetected) {
+        this.refresh();
+      }
+    };
+    ResizeObserverController2.prototype.updateObservers_ = function() {
+      var activeObservers = this.observers_.filter(function(observer) {
+        return observer.gatherActive(), observer.hasActive();
+      });
+      activeObservers.forEach(function(observer) {
+        return observer.broadcastActive();
+      });
+      return activeObservers.length > 0;
+    };
+    ResizeObserverController2.prototype.connect_ = function() {
+      if (!isBrowser || this.connected_) {
+        return;
+      }
+      document.addEventListener("transitionend", this.onTransitionEnd_);
+      window.addEventListener("resize", this.refresh);
+      if (mutationObserverSupported) {
+        this.mutationsObserver_ = new MutationObserver(this.refresh);
+        this.mutationsObserver_.observe(document, {
+          attributes: true,
+          childList: true,
+          characterData: true,
+          subtree: true
+        });
+      } else {
+        document.addEventListener("DOMSubtreeModified", this.refresh);
+        this.mutationEventsAdded_ = true;
+      }
+      this.connected_ = true;
+    };
+    ResizeObserverController2.prototype.disconnect_ = function() {
+      if (!isBrowser || !this.connected_) {
+        return;
+      }
+      document.removeEventListener("transitionend", this.onTransitionEnd_);
+      window.removeEventListener("resize", this.refresh);
+      if (this.mutationsObserver_) {
+        this.mutationsObserver_.disconnect();
+      }
+      if (this.mutationEventsAdded_) {
+        document.removeEventListener("DOMSubtreeModified", this.refresh);
+      }
+      this.mutationsObserver_ = null;
+      this.mutationEventsAdded_ = false;
+      this.connected_ = false;
+    };
+    ResizeObserverController2.prototype.onTransitionEnd_ = function(_a) {
+      var _b = _a.propertyName, propertyName = _b === void 0 ? "" : _b;
+      var isReflowProperty = transitionKeys.some(function(key) {
+        return !!~propertyName.indexOf(key);
+      });
+      if (isReflowProperty) {
+        this.refresh();
+      }
+    };
+    ResizeObserverController2.getInstance = function() {
+      if (!this.instance_) {
+        this.instance_ = new ResizeObserverController2();
+      }
+      return this.instance_;
+    };
+    ResizeObserverController2.instance_ = null;
+    return ResizeObserverController2;
+  })()
+);
+var defineConfigurable = (function(target, props) {
+  for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {
+    var key = _a[_i];
+    Object.defineProperty(target, key, {
+      value: props[key],
+      enumerable: false,
+      writable: false,
+      configurable: true
+    });
+  }
+  return target;
+});
+var getWindowOf = (function(target) {
+  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
+  return ownerGlobal || global$1;
+});
+var emptyRect = createRectInit(0, 0, 0, 0);
+function toFloat(value) {
+  return parseFloat(value) || 0;
+}
+function getBordersSize(styles) {
+  var positions = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    positions[_i - 1] = arguments[_i];
+  }
+  return positions.reduce(function(size, position) {
+    var value = styles["border-" + position + "-width"];
+    return size + toFloat(value);
+  }, 0);
+}
+function getPaddings(styles) {
+  var positions = ["top", "right", "bottom", "left"];
+  var paddings = {};
+  for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
+    var position = positions_1[_i];
+    var value = styles["padding-" + position];
+    paddings[position] = toFloat(value);
+  }
+  return paddings;
+}
+function getSVGContentRect(target) {
+  var bbox = target.getBBox();
+  return createRectInit(0, 0, bbox.width, bbox.height);
+}
+function getHTMLElementContentRect(target) {
+  var clientWidth = target.clientWidth, clientHeight = target.clientHeight;
+  if (!clientWidth && !clientHeight) {
+    return emptyRect;
+  }
+  var styles = getWindowOf(target).getComputedStyle(target);
+  var paddings = getPaddings(styles);
+  var horizPad = paddings.left + paddings.right;
+  var vertPad = paddings.top + paddings.bottom;
+  var width = toFloat(styles.width), height = toFloat(styles.height);
+  if (styles.boxSizing === "border-box") {
+    if (Math.round(width + horizPad) !== clientWidth) {
+      width -= getBordersSize(styles, "left", "right") + horizPad;
+    }
+    if (Math.round(height + vertPad) !== clientHeight) {
+      height -= getBordersSize(styles, "top", "bottom") + vertPad;
+    }
+  }
+  if (!isDocumentElement(target)) {
+    var vertScrollbar = Math.round(width + horizPad) - clientWidth;
+    var horizScrollbar = Math.round(height + vertPad) - clientHeight;
+    if (Math.abs(vertScrollbar) !== 1) {
+      width -= vertScrollbar;
+    }
+    if (Math.abs(horizScrollbar) !== 1) {
+      height -= horizScrollbar;
+    }
+  }
+  return createRectInit(paddings.left, paddings.top, width, height);
+}
+var isSVGGraphicsElement = (function() {
+  if (typeof SVGGraphicsElement !== "undefined") {
+    return function(target) {
+      return target instanceof getWindowOf(target).SVGGraphicsElement;
+    };
+  }
+  return function(target) {
+    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === "function";
+  };
+})();
+function isDocumentElement(target) {
+  return target === getWindowOf(target).document.documentElement;
+}
+function getContentRect(target) {
+  if (!isBrowser) {
+    return emptyRect;
+  }
+  if (isSVGGraphicsElement(target)) {
+    return getSVGContentRect(target);
+  }
+  return getHTMLElementContentRect(target);
+}
+function createReadOnlyRect(_a) {
+  var x = _a.x, y = _a.y, width = _a.width, height = _a.height;
+  var Constr = typeof DOMRectReadOnly !== "undefined" ? DOMRectReadOnly : Object;
+  var rect = Object.create(Constr.prototype);
+  defineConfigurable(rect, {
+    x,
+    y,
+    width,
+    height,
+    top: y,
+    right: x + width,
+    bottom: height + y,
+    left: x
+  });
+  return rect;
+}
+function createRectInit(x, y, width, height) {
+  return { x, y, width, height };
+}
+var ResizeObservation = (
+  /** @class */
+  (function() {
+    function ResizeObservation2(target) {
+      this.broadcastWidth = 0;
+      this.broadcastHeight = 0;
+      this.contentRect_ = createRectInit(0, 0, 0, 0);
+      this.target = target;
+    }
+    ResizeObservation2.prototype.isActive = function() {
+      var rect = getContentRect(this.target);
+      this.contentRect_ = rect;
+      return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
+    };
+    ResizeObservation2.prototype.broadcastRect = function() {
+      var rect = this.contentRect_;
+      this.broadcastWidth = rect.width;
+      this.broadcastHeight = rect.height;
+      return rect;
+    };
+    return ResizeObservation2;
+  })()
+);
+var ResizeObserverEntry = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function ResizeObserverEntry2(target, rectInit) {
+      var contentRect = createReadOnlyRect(rectInit);
+      defineConfigurable(this, { target, contentRect });
+    }
+    return ResizeObserverEntry2;
+  })()
+);
+var ResizeObserverSPI = (
+  /** @class */
+  (function() {
+    function ResizeObserverSPI2(callback, controller, callbackCtx) {
+      this.activeObservations_ = [];
+      this.observations_ = new MapShim();
+      if (typeof callback !== "function") {
+        throw new TypeError("The callback provided as parameter 1 is not a function.");
+      }
+      this.callback_ = callback;
+      this.controller_ = controller;
+      this.callbackCtx_ = callbackCtx;
+    }
+    ResizeObserverSPI2.prototype.observe = function(target) {
+      if (!arguments.length) {
+        throw new TypeError("1 argument required, but only 0 present.");
+      }
+      if (typeof Element === "undefined" || !(Element instanceof Object)) {
+        return;
+      }
+      if (!(target instanceof getWindowOf(target).Element)) {
+        throw new TypeError('parameter 1 is not of type "Element".');
+      }
+      var observations = this.observations_;
+      if (observations.has(target)) {
+        return;
+      }
+      observations.set(target, new ResizeObservation(target));
+      this.controller_.addObserver(this);
+      this.controller_.refresh();
+    };
+    ResizeObserverSPI2.prototype.unobserve = function(target) {
+      if (!arguments.length) {
+        throw new TypeError("1 argument required, but only 0 present.");
+      }
+      if (typeof Element === "undefined" || !(Element instanceof Object)) {
+        return;
+      }
+      if (!(target instanceof getWindowOf(target).Element)) {
+        throw new TypeError('parameter 1 is not of type "Element".');
+      }
+      var observations = this.observations_;
+      if (!observations.has(target)) {
+        return;
+      }
+      observations.delete(target);
+      if (!observations.size) {
+        this.controller_.removeObserver(this);
+      }
+    };
+    ResizeObserverSPI2.prototype.disconnect = function() {
+      this.clearActive();
+      this.observations_.clear();
+      this.controller_.removeObserver(this);
+    };
+    ResizeObserverSPI2.prototype.gatherActive = function() {
+      var _this = this;
+      this.clearActive();
+      this.observations_.forEach(function(observation) {
+        if (observation.isActive()) {
+          _this.activeObservations_.push(observation);
+        }
+      });
+    };
+    ResizeObserverSPI2.prototype.broadcastActive = function() {
+      if (!this.hasActive()) {
+        return;
+      }
+      var ctx = this.callbackCtx_;
+      var entries = this.activeObservations_.map(function(observation) {
+        return new ResizeObserverEntry(observation.target, observation.broadcastRect());
+      });
+      this.callback_.call(ctx, entries, ctx);
+      this.clearActive();
+    };
+    ResizeObserverSPI2.prototype.clearActive = function() {
+      this.activeObservations_.splice(0);
+    };
+    ResizeObserverSPI2.prototype.hasActive = function() {
+      return this.activeObservations_.length > 0;
+    };
+    return ResizeObserverSPI2;
+  })()
+);
+var observers = typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : new MapShim();
+var ResizeObserver = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function ResizeObserver2(callback) {
+      if (!(this instanceof ResizeObserver2)) {
+        throw new TypeError("Cannot call a class as a function.");
+      }
+      if (!arguments.length) {
+        throw new TypeError("1 argument required, but only 0 present.");
+      }
+      var controller = ResizeObserverController.getInstance();
+      var observer = new ResizeObserverSPI(callback, controller, this);
+      observers.set(this, observer);
+    }
+    return ResizeObserver2;
+  })()
+);
+[
+  "observe",
+  "unobserve",
+  "disconnect"
+].forEach(function(method) {
+  ResizeObserver.prototype[method] = function() {
+    var _a;
+    return (_a = observers.get(this))[method].apply(_a, arguments);
+  };
+});
+var index = (function() {
+  if (typeof global$1.ResizeObserver !== "undefined") {
+    return global$1.ResizeObserver;
+  }
+  return ResizeObserver;
+})();
+export {
+  index as default
+};

package/dist/node_modules/string-convert/camel2hyphen.js

@@ -0,0 +1,16 @@
+var camel2hyphen_1;
+var hasRequiredCamel2hyphen;
+function requireCamel2hyphen() {
+  if (hasRequiredCamel2hyphen) return camel2hyphen_1;
+  hasRequiredCamel2hyphen = 1;
+  var camel2hyphen = function(str) {
+    return str.replace(/[A-Z]/g, function(match) {
+      return "-" + match.toLowerCase();
+    }).toLowerCase();
+  };
+  camel2hyphen_1 = camel2hyphen;
+  return camel2hyphen_1;
+}
+export {
+  requireCamel2hyphen as __require
+};

package/dist/node_modules/style-to-js/cjs/index.js

@@ -0,0 +1,31 @@
+import { __require as requireCjs$1 } from "../../style-to-object/cjs/index.js";
+import { __require as requireUtilities } from "./utilities.js";
+var cjs;
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  var style_to_object_1 = __importDefault(requireCjs$1());
+  var utilities_1 = requireUtilities();
+  function StyleToJS(style, options) {
+    var output = {};
+    if (!style || typeof style !== "string") {
+      return output;
+    }
+    (0, style_to_object_1.default)(style, function(property, value) {
+      if (property && value) {
+        output[(0, utilities_1.camelCase)(property, options)] = value;
+      }
+    });
+    return output;
+  }
+  StyleToJS.default = StyleToJS;
+  cjs = StyleToJS;
+  return cjs;
+}
+export {
+  requireCjs as __require
+};

package/dist/node_modules/style-to-js/cjs/utilities.js

@@ -0,0 +1,42 @@
+import { __exports as utilities } from "../../../_virtual/utilities3.js";
+var hasRequiredUtilities;
+function requireUtilities() {
+  if (hasRequiredUtilities) return utilities;
+  hasRequiredUtilities = 1;
+  Object.defineProperty(utilities, "__esModule", { value: true });
+  utilities.camelCase = void 0;
+  var CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+  var HYPHEN_REGEX = /-([a-z])/g;
+  var NO_HYPHEN_REGEX = /^[^-]+$/;
+  var VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+  var MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+  var skipCamelCase = function(property) {
+    return !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+  };
+  var capitalize = function(match, character) {
+    return character.toUpperCase();
+  };
+  var trimHyphen = function(match, prefix) {
+    return "".concat(prefix, "-");
+  };
+  var camelCase = function(property, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    if (skipCamelCase(property)) {
+      return property;
+    }
+    property = property.toLowerCase();
+    if (options.reactCompat) {
+      property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+    } else {
+      property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+    }
+    return property.replace(HYPHEN_REGEX, capitalize);
+  };
+  utilities.camelCase = camelCase;
+  return utilities;
+}
+export {
+  requireUtilities as __require
+};

package/dist/node_modules/style-to-object/cjs/index.js

@@ -0,0 +1,38 @@
+import { __exports as cjs } from "../../../_virtual/index31.js";
+import { __require as requireCjs$1 } from "../../inline-style-parser/cjs/index.js";
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var __importDefault = cjs && cjs.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+  };
+  Object.defineProperty(cjs, "__esModule", { value: true });
+  cjs.default = StyleToObject;
+  const inline_style_parser_1 = __importDefault(requireCjs$1());
+  function StyleToObject(style, iterator) {
+    let styleObject = null;
+    if (!style || typeof style !== "string") {
+      return styleObject;
+    }
+    const declarations = (0, inline_style_parser_1.default)(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;
+  }
+  return cjs;
+}
+export {
+  requireCjs as __require
+};

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

@@ -0,0 +1,20 @@
+var MS = "-ms-";
+var MOZ = "-moz-";
+var WEBKIT = "-webkit-";
+var COMMENT = "comm";
+var RULESET = "rule";
+var DECLARATION = "decl";
+var IMPORT = "@import";
+var KEYFRAMES = "@keyframes";
+var LAYER = "@layer";
+export {
+  COMMENT,
+  DECLARATION,
+  IMPORT,
+  KEYFRAMES,
+  LAYER,
+  MOZ,
+  MS,
+  RULESET,
+  WEBKIT
+};

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

@@ -0,0 +1,22 @@
+import { sizeof } from "./Utility.js";
+function middleware(collection) {
+  var length = sizeof(collection);
+  return function(element, index, children, callback) {
+    var output = "";
+    for (var i = 0; i < length; i++)
+      output += collection[i](element, index, children, callback) || "";
+    return output;
+  };
+}
+function rulesheet(callback) {
+  return function(element) {
+    if (!element.root) {
+      if (element = element.return)
+        callback(element);
+    }
+  };
+}
+export {
+  middleware,
+  rulesheet
+};