@m4l/components 0.1.4 → 0.1.6

package/utils/index.js

@@ -0,0 +1,761 @@
+import require$$0 from "react";
+import { g as gatherActiveObservationsAtDepth, h as hasActiveObservations, b as broadcastActiveObservations, a as hasSkippedObservations, d as deliverResizeLoopError } from "../juggle.js";
+const getPaletteColor = function(palette, s) {
+  s = s.replace(/\[(\w+)\]/g, ".$1");
+  s = s.replace(/^\./, "");
+  let o = palette;
+  const a = s.split(".");
+  console.log();
+  for (let i = 0, n = a.length; i < n; ++i) {
+    const k = a[i];
+    if (k in o) {
+      o = o[k];
+    } else {
+      return palette.action.active;
+    }
+  }
+  return o;
+};
+const getVariantColor = (variant) => {
+  switch (variant) {
+    case "warning":
+      return "warning";
+    case "delete":
+      return "error";
+    case "info":
+      return "info";
+  }
+  return "primary";
+};
+const getThemeVariantColor = (theme, variant) => {
+  switch (variant) {
+    case "warning":
+      theme.palette.warning.main;
+      break;
+    case "delete":
+      theme.palette.error.main;
+      break;
+    case "info":
+      theme.palette.info.main;
+      break;
+  }
+  return theme.palette.text.primary;
+};
+var domFns = {};
+var shims = {};
+Object.defineProperty(shims, "__esModule", {
+  value: true
+});
+shims.dontSetMe = dontSetMe;
+shims.findInArray = findInArray;
+shims.int = int;
+shims.isFunction = isFunction;
+shims.isNum = isNum;
+function findInArray(array, callback) {
+  for (var i = 0, length = array.length; i < length; i++) {
+    if (callback.apply(callback, [array[i], i, array]))
+      return array[i];
+  }
+}
+function isFunction(func) {
+  return typeof func === "function" || Object.prototype.toString.call(func) === "[object Function]";
+}
+function isNum(num) {
+  return typeof num === "number" && !isNaN(num);
+}
+function int(a) {
+  return parseInt(a, 10);
+}
+function dontSetMe(props, propName, componentName) {
+  if (props[propName]) {
+    return new Error("Invalid prop ".concat(propName, " passed to ").concat(componentName, " - do not set this, set it on the child."));
+  }
+}
+var getPrefix$1 = {};
+Object.defineProperty(getPrefix$1, "__esModule", {
+  value: true
+});
+getPrefix$1.browserPrefixToKey = browserPrefixToKey;
+getPrefix$1.browserPrefixToStyle = browserPrefixToStyle;
+getPrefix$1.default = void 0;
+getPrefix$1.getPrefix = getPrefix;
+var prefixes = ["Moz", "Webkit", "O", "ms"];
+function getPrefix() {
+  var _window$document, _window$document$docu;
+  var prop = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "transform";
+  if (typeof window === "undefined")
+    return "";
+  var style = (_window$document = window.document) === null || _window$document === void 0 ? void 0 : (_window$document$docu = _window$document.documentElement) === null || _window$document$docu === void 0 ? void 0 : _window$document$docu.style;
+  if (!style)
+    return "";
+  if (prop in style)
+    return "";
+  for (var i = 0; i < prefixes.length; i++) {
+    if (browserPrefixToKey(prop, prefixes[i]) in style)
+      return prefixes[i];
+  }
+  return "";
+}
+function browserPrefixToKey(prop, prefix) {
+  return prefix ? "".concat(prefix).concat(kebabToTitleCase(prop)) : prop;
+}
+function browserPrefixToStyle(prop, prefix) {
+  return prefix ? "-".concat(prefix.toLowerCase(), "-").concat(prop) : prop;
+}
+function kebabToTitleCase(str) {
+  var out = "";
+  var shouldCapitalize = true;
+  for (var i = 0; i < str.length; i++) {
+    if (shouldCapitalize) {
+      out += str[i].toUpperCase();
+      shouldCapitalize = false;
+    } else if (str[i] === "-") {
+      shouldCapitalize = true;
+    } else {
+      out += str[i];
+    }
+  }
+  return out;
+}
+var _default = getPrefix();
+getPrefix$1.default = _default;
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+Object.defineProperty(domFns, "__esModule", {
+  value: true
+});
+domFns.addClassName = addClassName;
+domFns.addEvent = addEvent;
+domFns.addUserSelectStyles = addUserSelectStyles;
+domFns.createCSSTransform = createCSSTransform;
+domFns.createSVGTransform = createSVGTransform;
+domFns.getTouch = getTouch;
+domFns.getTouchIdentifier = getTouchIdentifier;
+domFns.getTranslation = getTranslation;
+domFns.innerHeight = innerHeight;
+domFns.innerWidth = innerWidth;
+domFns.matchesSelector = matchesSelector;
+domFns.matchesSelectorAndParentsTo = matchesSelectorAndParentsTo;
+domFns.offsetXYFromParent = offsetXYFromParent;
+domFns.outerHeight = outerHeight;
+domFns.outerWidth = outerWidth;
+domFns.removeClassName = removeClassName;
+domFns.removeEvent = removeEvent;
+domFns.removeUserSelectStyles = removeUserSelectStyles;
+var _shims$1 = shims;
+var _getPrefix = _interopRequireWildcard(getPrefix$1);
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache2(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") {
+    return { default: obj };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$1(Object(source), true).forEach(function(key) {
+      _defineProperty$1(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var matchesSelectorFunc = "";
+function matchesSelector(el, selector) {
+  if (!matchesSelectorFunc) {
+    matchesSelectorFunc = (0, _shims$1.findInArray)(["matches", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"], function(method) {
+      return (0, _shims$1.isFunction)(el[method]);
+    });
+  }
+  if (!(0, _shims$1.isFunction)(el[matchesSelectorFunc]))
+    return false;
+  return el[matchesSelectorFunc](selector);
+}
+function matchesSelectorAndParentsTo(el, selector, baseNode) {
+  var node = el;
+  do {
+    if (matchesSelector(node, selector))
+      return true;
+    if (node === baseNode)
+      return false;
+    node = node.parentNode;
+  } while (node);
+  return false;
+}
+function addEvent(el, event, handler, inputOptions) {
+  if (!el)
+    return;
+  var options = _objectSpread$1({
+    capture: true
+  }, inputOptions);
+  if (el.addEventListener) {
+    el.addEventListener(event, handler, options);
+  } else if (el.attachEvent) {
+    el.attachEvent("on" + event, handler);
+  } else {
+    el["on" + event] = handler;
+  }
+}
+function removeEvent(el, event, handler, inputOptions) {
+  if (!el)
+    return;
+  var options = _objectSpread$1({
+    capture: true
+  }, inputOptions);
+  if (el.removeEventListener) {
+    el.removeEventListener(event, handler, options);
+  } else if (el.detachEvent) {
+    el.detachEvent("on" + event, handler);
+  } else {
+    el["on" + event] = null;
+  }
+}
+function outerHeight(node) {
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height += (0, _shims$1.int)(computedStyle.borderTopWidth);
+  height += (0, _shims$1.int)(computedStyle.borderBottomWidth);
+  return height;
+}
+function outerWidth(node) {
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width += (0, _shims$1.int)(computedStyle.borderLeftWidth);
+  width += (0, _shims$1.int)(computedStyle.borderRightWidth);
+  return width;
+}
+function innerHeight(node) {
+  var height = node.clientHeight;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  height -= (0, _shims$1.int)(computedStyle.paddingTop);
+  height -= (0, _shims$1.int)(computedStyle.paddingBottom);
+  return height;
+}
+function innerWidth(node) {
+  var width = node.clientWidth;
+  var computedStyle = node.ownerDocument.defaultView.getComputedStyle(node);
+  width -= (0, _shims$1.int)(computedStyle.paddingLeft);
+  width -= (0, _shims$1.int)(computedStyle.paddingRight);
+  return width;
+}
+function offsetXYFromParent(evt, offsetParent, scale) {
+  var isBody = offsetParent === offsetParent.ownerDocument.body;
+  var offsetParentRect = isBody ? {
+    left: 0,
+    top: 0
+  } : offsetParent.getBoundingClientRect();
+  var x = (evt.clientX + offsetParent.scrollLeft - offsetParentRect.left) / scale;
+  var y = (evt.clientY + offsetParent.scrollTop - offsetParentRect.top) / scale;
+  return {
+    x,
+    y
+  };
+}
+function createCSSTransform(controlPos, positionOffset) {
+  var translation = getTranslation(controlPos, positionOffset, "px");
+  return _defineProperty$1({}, (0, _getPrefix.browserPrefixToKey)("transform", _getPrefix.default), translation);
+}
+function createSVGTransform(controlPos, positionOffset) {
+  var translation = getTranslation(controlPos, positionOffset, "");
+  return translation;
+}
+function getTranslation(_ref2, positionOffset, unitSuffix) {
+  var x = _ref2.x, y = _ref2.y;
+  var translation = "translate(".concat(x).concat(unitSuffix, ",").concat(y).concat(unitSuffix, ")");
+  if (positionOffset) {
+    var defaultX = "".concat(typeof positionOffset.x === "string" ? positionOffset.x : positionOffset.x + unitSuffix);
+    var defaultY = "".concat(typeof positionOffset.y === "string" ? positionOffset.y : positionOffset.y + unitSuffix);
+    translation = "translate(".concat(defaultX, ", ").concat(defaultY, ")") + translation;
+  }
+  return translation;
+}
+function getTouch(e, identifier) {
+  return e.targetTouches && (0, _shims$1.findInArray)(e.targetTouches, function(t) {
+    return identifier === t.identifier;
+  }) || e.changedTouches && (0, _shims$1.findInArray)(e.changedTouches, function(t) {
+    return identifier === t.identifier;
+  });
+}
+function getTouchIdentifier(e) {
+  if (e.targetTouches && e.targetTouches[0])
+    return e.targetTouches[0].identifier;
+  if (e.changedTouches && e.changedTouches[0])
+    return e.changedTouches[0].identifier;
+}
+function addUserSelectStyles(doc) {
+  if (!doc)
+    return;
+  var styleEl = doc.getElementById("react-draggable-style-el");
+  if (!styleEl) {
+    styleEl = doc.createElement("style");
+    styleEl.type = "text/css";
+    styleEl.id = "react-draggable-style-el";
+    styleEl.innerHTML = ".react-draggable-transparent-selection *::-moz-selection {all: inherit;}\n";
+    styleEl.innerHTML += ".react-draggable-transparent-selection *::selection {all: inherit;}\n";
+    doc.getElementsByTagName("head")[0].appendChild(styleEl);
+  }
+  if (doc.body)
+    addClassName(doc.body, "react-draggable-transparent-selection");
+}
+function removeUserSelectStyles(doc) {
+  if (!doc)
+    return;
+  try {
+    if (doc.body)
+      removeClassName(doc.body, "react-draggable-transparent-selection");
+    if (doc.selection) {
+      doc.selection.empty();
+    } else {
+      var selection = (doc.defaultView || window).getSelection();
+      if (selection && selection.type !== "Caret") {
+        selection.removeAllRanges();
+      }
+    }
+  } catch (e) {
+  }
+}
+function addClassName(el, className) {
+  if (el.classList) {
+    el.classList.add(className);
+  } else {
+    if (!el.className.match(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)")))) {
+      el.className += " ".concat(className);
+    }
+  }
+}
+function removeClassName(el, className) {
+  if (el.classList) {
+    el.classList.remove(className);
+  } else {
+    el.className = el.className.replace(new RegExp("(?:^|\\s)".concat(className, "(?!\\S)"), "g"), "");
+  }
+}
+var positionFns = {};
+Object.defineProperty(positionFns, "__esModule", {
+  value: true
+});
+positionFns.canDragX = canDragX;
+positionFns.canDragY = canDragY;
+positionFns.createCoreData = createCoreData;
+positionFns.createDraggableData = createDraggableData;
+positionFns.getBoundPosition = getBoundPosition;
+positionFns.getControlPosition = getControlPosition;
+positionFns.snapToGrid = snapToGrid;
+var _shims = shims;
+var _domFns = domFns;
+function getBoundPosition(draggable, x, y) {
+  if (!draggable.props.bounds)
+    return [x, y];
+  var bounds = draggable.props.bounds;
+  bounds = typeof bounds === "string" ? bounds : cloneBounds(bounds);
+  var node = findDOMNode(draggable);
+  if (typeof bounds === "string") {
+    var ownerDocument = node.ownerDocument;
+    var ownerWindow = ownerDocument.defaultView;
+    var boundNode;
+    if (bounds === "parent") {
+      boundNode = node.parentNode;
+    } else {
+      boundNode = ownerDocument.querySelector(bounds);
+    }
+    if (!(boundNode instanceof ownerWindow.HTMLElement)) {
+      throw new Error('Bounds selector "' + bounds + '" could not find an element.');
+    }
+    var boundNodeEl = boundNode;
+    var nodeStyle = ownerWindow.getComputedStyle(node);
+    var boundNodeStyle = ownerWindow.getComputedStyle(boundNodeEl);
+    bounds = {
+      left: -node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingLeft) + (0, _shims.int)(nodeStyle.marginLeft),
+      top: -node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingTop) + (0, _shims.int)(nodeStyle.marginTop),
+      right: (0, _domFns.innerWidth)(boundNodeEl) - (0, _domFns.outerWidth)(node) - node.offsetLeft + (0, _shims.int)(boundNodeStyle.paddingRight) - (0, _shims.int)(nodeStyle.marginRight),
+      bottom: (0, _domFns.innerHeight)(boundNodeEl) - (0, _domFns.outerHeight)(node) - node.offsetTop + (0, _shims.int)(boundNodeStyle.paddingBottom) - (0, _shims.int)(nodeStyle.marginBottom)
+    };
+  }
+  if ((0, _shims.isNum)(bounds.right))
+    x = Math.min(x, bounds.right);
+  if ((0, _shims.isNum)(bounds.bottom))
+    y = Math.min(y, bounds.bottom);
+  if ((0, _shims.isNum)(bounds.left))
+    x = Math.max(x, bounds.left);
+  if ((0, _shims.isNum)(bounds.top))
+    y = Math.max(y, bounds.top);
+  return [x, y];
+}
+function snapToGrid(grid, pendingX, pendingY) {
+  var x = Math.round(pendingX / grid[0]) * grid[0];
+  var y = Math.round(pendingY / grid[1]) * grid[1];
+  return [x, y];
+}
+function canDragX(draggable) {
+  return draggable.props.axis === "both" || draggable.props.axis === "x";
+}
+function canDragY(draggable) {
+  return draggable.props.axis === "both" || draggable.props.axis === "y";
+}
+function getControlPosition(e, touchIdentifier, draggableCore) {
+  var touchObj = typeof touchIdentifier === "number" ? (0, _domFns.getTouch)(e, touchIdentifier) : null;
+  if (typeof touchIdentifier === "number" && !touchObj)
+    return null;
+  var node = findDOMNode(draggableCore);
+  var offsetParent = draggableCore.props.offsetParent || node.offsetParent || node.ownerDocument.body;
+  return (0, _domFns.offsetXYFromParent)(touchObj || e, offsetParent, draggableCore.props.scale);
+}
+function createCoreData(draggable, x, y) {
+  var state = draggable.state;
+  var isStart = !(0, _shims.isNum)(state.lastX);
+  var node = findDOMNode(draggable);
+  if (isStart) {
+    return {
+      node,
+      deltaX: 0,
+      deltaY: 0,
+      lastX: x,
+      lastY: y,
+      x,
+      y
+    };
+  } else {
+    return {
+      node,
+      deltaX: x - state.lastX,
+      deltaY: y - state.lastY,
+      lastX: state.lastX,
+      lastY: state.lastY,
+      x,
+      y
+    };
+  }
+}
+function createDraggableData(draggable, coreData) {
+  var scale = draggable.props.scale;
+  return {
+    node: coreData.node,
+    x: draggable.state.x + coreData.deltaX / scale,
+    y: draggable.state.y + coreData.deltaY / scale,
+    deltaX: coreData.deltaX / scale,
+    deltaY: coreData.deltaY / scale,
+    lastX: draggable.state.x,
+    lastY: draggable.state.y
+  };
+}
+function cloneBounds(bounds) {
+  return {
+    left: bounds.left,
+    top: bounds.top,
+    right: bounds.right,
+    bottom: bounds.bottom
+  };
+}
+function findDOMNode(draggable) {
+  var node = draggable.findDOMNode();
+  if (!node) {
+    throw new Error("<DraggableCore>: Unmounted during event!");
+  }
+  return node;
+}
+var log$1 = {};
+Object.defineProperty(log$1, "__esModule", {
+  value: true
+});
+log$1.default = log;
+function log() {
+}
+var utils = {};
+utils.__esModule = true;
+utils.cloneElement = cloneElement;
+var _react = _interopRequireDefault(require$$0);
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function(key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function cloneElement(element, props) {
+  if (props.style && element.props.style) {
+    props.style = _objectSpread(_objectSpread({}, element.props.style), props.style);
+  }
+  if (props.className && element.props.className) {
+    props.className = element.props.className + " " + props.className;
+  }
+  return /* @__PURE__ */ _react.default.cloneElement(element, props);
+}
+var resizeObservers = [];
+var freeze = function(obj) {
+  return Object.freeze(obj);
+};
+var isSVG = function(target) {
+  return target instanceof SVGElement && "getBBox" in target;
+};
+var isHidden = function(target) {
+  if (isSVG(target)) {
+    var _a = target.getBBox(), width = _a.width, height = _a.height;
+    return !width && !height;
+  }
+  var _b = target, offsetWidth = _b.offsetWidth, offsetHeight = _b.offsetHeight;
+  return !(offsetWidth || offsetHeight || target.getClientRects().length);
+};
+var isElement = function(obj) {
+  var _a;
+  if (obj instanceof Element) {
+    return true;
+  }
+  var scope = (_a = obj === null || obj === void 0 ? void 0 : obj.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;
+  return !!(scope && obj instanceof scope.Element);
+};
+var isReplacedElement = function(target) {
+  switch (target.tagName) {
+    case "INPUT":
+      if (target.type !== "image") {
+        break;
+      }
+    case "VIDEO":
+    case "AUDIO":
+    case "EMBED":
+    case "OBJECT":
+    case "CANVAS":
+    case "IFRAME":
+    case "IMG":
+      return true;
+  }
+  return false;
+};
+var global = typeof window !== "undefined" ? window : {};
+var process = function() {
+  var depth = 0;
+  gatherActiveObservationsAtDepth(depth);
+  while (hasActiveObservations()) {
+    depth = broadcastActiveObservations();
+    gatherActiveObservationsAtDepth(depth);
+  }
+  if (hasSkippedObservations()) {
+    deliverResizeLoopError();
+  }
+  return depth > 0;
+};
+var trigger;
+var callbacks = [];
+var notify = function() {
+  return callbacks.splice(0).forEach(function(cb) {
+    return cb();
+  });
+};
+var queueMicroTask = function(callback) {
+  if (!trigger) {
+    var toggle_1 = 0;
+    var el_1 = document.createTextNode("");
+    var config = { characterData: true };
+    new MutationObserver(function() {
+      return notify();
+    }).observe(el_1, config);
+    trigger = function() {
+      el_1.textContent = "".concat(toggle_1 ? toggle_1-- : toggle_1++);
+    };
+  }
+  callbacks.push(callback);
+  trigger();
+};
+var queueResizeObserver = function(cb) {
+  queueMicroTask(function ResizeObserver() {
+    requestAnimationFrame(cb);
+  });
+};
+var watching = 0;
+var isWatching = function() {
+  return !!watching;
+};
+var CATCH_PERIOD = 250;
+var observerConfig = { attributes: true, characterData: true, childList: true, subtree: true };
+var events = [
+  "resize",
+  "load",
+  "transitionend",
+  "animationend",
+  "animationstart",
+  "animationiteration",
+  "keyup",
+  "keydown",
+  "mouseup",
+  "mousedown",
+  "mouseover",
+  "mouseout",
+  "blur",
+  "focus"
+];
+var time = function(timeout) {
+  if (timeout === void 0) {
+    timeout = 0;
+  }
+  return Date.now() + timeout;
+};
+var scheduled = false;
+var Scheduler = function() {
+  function Scheduler2() {
+    var _this = this;
+    this.stopped = true;
+    this.listener = function() {
+      return _this.schedule();
+    };
+  }
+  Scheduler2.prototype.run = function(timeout) {
+    var _this = this;
+    if (timeout === void 0) {
+      timeout = CATCH_PERIOD;
+    }
+    if (scheduled) {
+      return;
+    }
+    scheduled = true;
+    var until = time(timeout);
+    queueResizeObserver(function() {
+      var elementsHaveResized = false;
+      try {
+        elementsHaveResized = process();
+      } finally {
+        scheduled = false;
+        timeout = until - time();
+        if (!isWatching()) {
+          return;
+        }
+        if (elementsHaveResized) {
+          _this.run(1e3);
+        } else if (timeout > 0) {
+          _this.run(timeout);
+        } else {
+          _this.start();
+        }
+      }
+    });
+  };
+  Scheduler2.prototype.schedule = function() {
+    this.stop();
+    this.run();
+  };
+  Scheduler2.prototype.observe = function() {
+    var _this = this;
+    var cb = function() {
+      return _this.observer && _this.observer.observe(document.body, observerConfig);
+    };
+    document.body ? cb() : global.addEventListener("DOMContentLoaded", cb);
+  };
+  Scheduler2.prototype.start = function() {
+    var _this = this;
+    if (this.stopped) {
+      this.stopped = false;
+      this.observer = new MutationObserver(this.listener);
+      this.observe();
+      events.forEach(function(name) {
+        return global.addEventListener(name, _this.listener, true);
+      });
+    }
+  };
+  Scheduler2.prototype.stop = function() {
+    var _this = this;
+    if (!this.stopped) {
+      this.observer && this.observer.disconnect();
+      events.forEach(function(name) {
+        return global.removeEventListener(name, _this.listener, true);
+      });
+      this.stopped = true;
+    }
+  };
+  return Scheduler2;
+}();
+var scheduler = new Scheduler();
+var updateCount = function(n) {
+  !watching && n > 0 && scheduler.start();
+  watching += n;
+  !watching && scheduler.stop();
+};
+export { getThemeVariantColor as a, getVariantColor as b, global as c, isSVG as d, isReplacedElement as e, freeze as f, getPaletteColor as g, isElement as h, isHidden as i, shims as j, domFns as k, log$1 as l, utils as m, positionFns as p, resizeObservers as r, scheduler as s, updateCount as u };