@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/global/data-tests.d.ts

@@ -0,0 +1,3 @@
+type AttrsMap = Record<string, boolean | null | undefined>;
+export default function joinDataTestAttributes(...attrs: Array<string | AttrsMap | null | undefined>): string;
+export {};

package/dist/global/data-tests.js

@@ -0,0 +1,30 @@
+import { l as _toConsumableArray, j as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.concat.js';
+
+function expandMap(attrsMap) {
+  return Object.entries(attrsMap).reduce(function (result, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    return value ? [].concat(_toConsumableArray(result), [key]) : result;
+  }, []);
+}
+function joinDataTestAttributes() {
+  for (var _len = arguments.length, attrs = new Array(_len), _key = 0; _key < _len; _key++) {
+    attrs[_key] = arguments[_key];
+  }
+  return attrs.reduce(function (result, attr) {
+    if (!attr) {
+      return result;
+    }
+    if (typeof attr === 'object') {
+      return [].concat(_toConsumableArray(result), _toConsumableArray(expandMap(attr)));
+    }
+    return [].concat(_toConsumableArray(result), [attr]);
+  }, []).join(' ');
+}
+
+export { joinDataTestAttributes as default };

package/dist/global/dom.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @name DOM
+ */
+import { SyntheticEvent } from 'react';
+import type { PropertiesHyphen } from 'csstype';
+export declare const getStyles: ((elt: Element, pseudoElt?: string | null | undefined) => CSSStyleDeclaration) & typeof getComputedStyle;
+export declare function isMounted(node: Node | Range | null | undefined): boolean;
+export interface Rect {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export declare function getRect(node: Element | Range | null | undefined): Rect;
+export declare function getPixelRatio(): number;
+export declare function getWindowHeight(): number;
+export declare function getWindowWidth(): number;
+export declare function isNodeInVisiblePartOfPage(node: Element | Range): boolean;
+export declare function getDocumentScrollTop(): number;
+export declare function getDocumentScrollLeft(): number;
+export declare const applyMethodToClasses: (method: 'add' | 'remove') => (classList: DOMTokenList, classes?: string) => void;
+export declare const addClasses: (classList: DOMTokenList, classes?: string) => void;
+export declare const removeClasses: (classList: DOMTokenList, classes?: string) => void;
+export declare const toggleClasses: (classList: DOMTokenList, classes: Record<string, boolean>) => void;
+export declare function setRootStyleProperties(properties?: PropertiesHyphen): void;
+export declare function resetRootStyleProperties(properties?: Partial<Record<keyof PropertiesHyphen, unknown>>): void;
+export declare class Listeners {
+    private _all;
+    add<K extends keyof HTMLElementEventMap>(el: HTMLElement, event: K, handler: (this: HTMLElement, ev: HTMLElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    add<K extends keyof WindowEventMap>(el: Window, event: K, handler: (this: Window, ev: WindowEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    add<K extends keyof DocumentEventMap>(el: Document, event: K, handler: (this: Window, ev: DocumentEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    remove(fn: () => void): void;
+    removeAll(): void;
+}
+export declare function preventDefault(e: Event | SyntheticEvent): void;

package/dist/global/dom.js

@@ -0,0 +1,151 @@
+import { j as _slicedToArray, d as _createClass, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.object.entries.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.set.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+
+/**
+ * @name DOM
+ */
+var getStyles = window.getComputedStyle.bind(window);
+function isMounted(node) {
+  if (node === document) {
+    return true;
+  }
+  return node instanceof Node && document.documentElement.contains(node.parentNode);
+}
+var rectStub = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0,
+  width: 0,
+  height: 0
+};
+function getRect(node) {
+  if (node instanceof Range || node != null && isMounted(node)) {
+    var _node$getBoundingClie = node.getBoundingClientRect(),
+      top = _node$getBoundingClie.top,
+      right = _node$getBoundingClie.right,
+      bottom = _node$getBoundingClie.bottom,
+      left = _node$getBoundingClie.left,
+      width = _node$getBoundingClie.width,
+      height = _node$getBoundingClie.height;
+    return {
+      top,
+      right,
+      bottom,
+      left,
+      width,
+      height
+    };
+  } else {
+    return Object.assign({}, rectStub);
+  }
+}
+function getPixelRatio() {
+  return 'devicePixelRatio' in window ? window.devicePixelRatio : 1;
+}
+function getWindowHeight() {
+  return window.innerHeight;
+}
+function getWindowWidth() {
+  return window.innerWidth;
+}
+function isNodeInVisiblePartOfPage(node) {
+  var _getRect = getRect(node),
+    top = _getRect.top,
+    bottom = _getRect.bottom,
+    left = _getRect.left,
+    right = _getRect.right;
+  return !(bottom < 0 || right < 0 || getWindowHeight() - top < 0 || getWindowWidth() - left < 0);
+}
+function getDocumentScrollTop() {
+  return document.documentElement && document.documentElement.scrollTop || document.body.scrollTop;
+}
+function getDocumentScrollLeft() {
+  return document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft;
+}
+var applyMethodToClasses = function applyMethodToClasses(method) {
+  return function (classList) {
+    var classes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    classes.split(/\s+/g).filter(function (className) {
+      return !!className;
+    }).forEach(function (className) {
+      return classList[method](className);
+    });
+  };
+};
+var addClasses = applyMethodToClasses('add');
+var removeClasses = applyMethodToClasses('remove');
+var toggleClasses = function toggleClasses(classList, classes) {
+  return Object.entries(classes).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      className = _ref2[0],
+      on = _ref2[1];
+    return classList.toggle(className, on);
+  });
+};
+function setRootStyleProperties() {
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var rootStyle = document.documentElement.style;
+  Object.entries(properties).forEach(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    rootStyle.setProperty(key, value);
+  });
+}
+function resetRootStyleProperties() {
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var rootStyle = document.documentElement.style;
+  Object.keys(properties).forEach(function (key) {
+    return rootStyle.removeProperty(key);
+  });
+}
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
+    _defineProperty(this, "_all", new Set());
+  }
+  _createClass(Listeners, [{
+    key: "add",
+    value: function add(el, event, handler, options) {
+      el.addEventListener(event, handler, options);
+      var dispatchFn = function dispatchFn() {
+        return el.removeEventListener(event, handler, options);
+      };
+      this._all.add(dispatchFn);
+      return dispatchFn;
+    }
+  }, {
+    key: "remove",
+    value: function remove(fn) {
+      fn();
+      this._all.delete(fn);
+    }
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      var _this = this;
+      this._all.forEach(function (fn) {
+        return _this.remove(fn);
+      });
+    }
+  }]);
+  return Listeners;
+}();
+// Synthetic events from Combokeys#trigger are plain objects
+function preventDefault(e) {
+  if (e.preventDefault) {
+    e.preventDefault();
+  }
+}
+
+export { Listeners, addClasses, applyMethodToClasses, getDocumentScrollLeft, getDocumentScrollTop, getPixelRatio, getRect, getStyles, getWindowHeight, getWindowWidth, isMounted, isNodeInVisiblePartOfPage, preventDefault, removeClasses, resetRootStyleProperties, setRootStyleProperties, toggleClasses };

package/dist/global/focus-sensor-hoc.d.ts

@@ -0,0 +1,19 @@
+import { ComponentType, Ref } from 'react';
+export interface FocusSensorOuterProps<T extends HTMLElement> {
+    focused?: boolean | undefined;
+    autofocus?: boolean | undefined;
+    scrollOnTableFocus?: boolean;
+    onFocus?: (() => void) | undefined;
+    onBlur?: (() => void) | undefined;
+    innerRef?: Ref<T> | null | undefined;
+}
+export interface FocusSensorAddProps<T extends HTMLElement> {
+    innerRef: Ref<T>;
+    focused: boolean;
+    onFocusReset: () => void;
+    onFocusRestore: () => void;
+}
+type RestProps<P, T extends HTMLElement> = Omit<P, keyof FocusSensorAddProps<T>>;
+export type FocusSensorProps<P extends FocusSensorAddProps<T>, T extends HTMLElement, C extends ComponentType<P>> = RestProps<JSX.LibraryManagedAttributes<C, P>, T> & FocusSensorOuterProps<T>;
+export default function focusSensorHOC<T extends HTMLElement, P extends FocusSensorAddProps<T>, C extends ComponentType<P>>(ComposedComponent: C): ComponentType<FocusSensorProps<P, T, typeof ComposedComponent>>;
+export {};

package/dist/global/focus-sensor-hoc.js

@@ -0,0 +1,165 @@
+import { g as _objectSpread2, e as _objectWithoutProperties, a as _inherits, b as _createSuper, c as _classCallCheck, _ as _defineProperty, k as _assertThisInitialized, d as _createClass, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { refObject } from './prop-types.js';
+import composeRefs from './composeRefs.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+var _excluded = ["innerRef", "focused", "onFocusReset", "onFocusRestore"],
+  _excluded2 = ["autofocus", "focused", "onFocus", "onBlur", "innerRef", "scrollOnTableFocus"];
+function extractPropTypes(_ref) {
+  var propTypes = _ref.propTypes;
+  if (propTypes == null) {
+    return propTypes;
+  }
+  propTypes.innerRef;
+    propTypes.focused;
+    propTypes.onFocusReset;
+    propTypes.onFocusRestore;
+    var restPropTypes = _objectWithoutProperties(propTypes, _excluded);
+  return restPropTypes;
+}
+function focusSensorHOC(ComposedComponent) {
+  var FocusSensor = /*#__PURE__*/function (_Component) {
+    _inherits(FocusSensor, _Component);
+    var _super = _createSuper(FocusSensor);
+    function FocusSensor() {
+      var _this;
+      _classCallCheck(this, FocusSensor);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "state", {
+        focused: _this.props.focused
+      });
+      _defineProperty(_assertThisInitialized(_this), "node", void 0);
+      _defineProperty(_assertThisInitialized(_this), "_skipNextCapture", false);
+      _defineProperty(_assertThisInitialized(_this), "onRefUpdate", function (node) {
+        if (node) {
+          _this.node = node;
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusCapture", function (_ref2) {
+        var _this$node;
+        var target = _ref2.target;
+        if (_this._skipNextCapture) {
+          _this._skipNextCapture = false;
+          return;
+        }
+        var focused = target instanceof Node && ((_this$node = _this.node) === null || _this$node === void 0 ? void 0 : _this$node.contains(target));
+        if (focused && !_this.state.focused) {
+          var _this$props$onFocus, _this$props;
+          _this.setState({
+            focused: true
+          });
+          (_this$props$onFocus = (_this$props = _this.props).onFocus) === null || _this$props$onFocus === void 0 || _this$props$onFocus.call(_this$props);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onBlurCapture", function (_ref3) {
+        var target = _ref3.target;
+        var _assertThisInitialize = _assertThisInitialized(_this),
+          focused = _assertThisInitialize.state.focused,
+          node = _assertThisInitialize.node;
+        if (focused) {
+          setTimeout(function () {
+            var blurred = target instanceof Node && (node === null || node === void 0 ? void 0 : node.contains(target)) && !node.contains(document.activeElement);
+            if (blurred) {
+              var _this$props$onBlur, _this$props2;
+              _this.setState({
+                focused: false
+              });
+              (_this$props$onBlur = (_this$props2 = _this.props).onBlur) === null || _this$props$onBlur === void 0 || _this$props$onBlur.call(_this$props2);
+            }
+          }, 1);
+        }
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusRestore", function () {
+        var _this$node2;
+        _this._skipNextCapture = true;
+        (_this$node2 = _this.node) === null || _this$node2 === void 0 || _this$node2.focus({
+          preventScroll: !_this.props.scrollOnTableFocus
+        });
+      });
+      _defineProperty(_assertThisInitialized(_this), "onFocusReset", function () {
+        var _this$node3;
+        (_this$node3 = _this.node) === null || _this$node3 === void 0 || _this$node3.blur();
+      });
+      return _this;
+    }
+    _createClass(FocusSensor, [{
+      key: "componentDidMount",
+      value: function componentDidMount() {
+        var _this$props3 = this.props,
+          autofocus = _this$props3.autofocus,
+          scrollOnTableFocus = _this$props3.scrollOnTableFocus,
+          node = this.node;
+        node === null || node === void 0 || node.setAttribute('tabindex', '0');
+        if (node != null) {
+          node.style.outline = 'none';
+        }
+        document.addEventListener('focus', this.onFocusCapture, true);
+        document.addEventListener('blur', this.onBlurCapture, true);
+        if (autofocus) {
+          node === null || node === void 0 || node.focus({
+            preventScroll: !scrollOnTableFocus
+          });
+        }
+      }
+    }, {
+      key: "componentDidUpdate",
+      value: function componentDidUpdate(prevProps) {
+        var focused = this.props.focused;
+        if (focused && !prevProps.focused) {
+          this.onFocusRestore();
+        } else if (!focused && prevProps.focused) {
+          this.onFocusReset();
+        }
+      }
+    }, {
+      key: "componentWillUnmount",
+      value: function componentWillUnmount() {
+        document.removeEventListener('focus', this.onFocusCapture, true);
+        document.removeEventListener('blur', this.onBlurCapture, true);
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props4 = this.props;
+          _this$props4.autofocus;
+          _this$props4.focused;
+          _this$props4.onFocus;
+          _this$props4.onBlur;
+          var innerRef = _this$props4.innerRef;
+          _this$props4.scrollOnTableFocus;
+          var rest = _objectWithoutProperties(_this$props4, _excluded2);
+        return /*#__PURE__*/React.createElement(ComposedComponent, _extends({}, rest, {
+          innerRef: composeRefs(innerRef, this.onRefUpdate),
+          focused: this.state.focused,
+          onFocusReset: this.onFocusReset,
+          onFocusRestore: this.onFocusRestore
+        }));
+      }
+    }]);
+    return FocusSensor;
+  }(Component);
+  FocusSensor.propTypes = _objectSpread2(_objectSpread2({}, extractPropTypes(ComposedComponent)), {}, {
+    focused: PropTypes.bool,
+    autofocus: PropTypes.bool,
+    onFocus: PropTypes.func,
+    onBlur: PropTypes.func,
+    innerRef: PropTypes.oneOfType([PropTypes.func, refObject(PropTypes.instanceOf(HTMLElement))])
+  });
+  FocusSensor.defaultProps = _objectSpread2(_objectSpread2({}, ComposedComponent.defaultProps), {}, {
+    focused: false,
+    autofocus: false,
+    scrollOnTableFocus: true,
+    onFocus: function onFocus() {},
+    onBlur: function onBlur() {}
+  });
+  return FocusSensor;
+}
+
+export { focusSensorHOC as default };

package/dist/global/fuzzy-highlight.d.ts

@@ -0,0 +1,11 @@
+/** https://github.com/bevacqua/fuzzysearch + highlighting with Markdown */
+type Match = {
+    from: number;
+    to: number;
+};
+export default function fuzzyHighlight(needle: string, haystack: string, caseSensitive?: boolean): {
+    matched: boolean;
+    matches: Match[];
+    highlight: string;
+};
+export {};

package/dist/global/fuzzy-highlight.js

@@ -0,0 +1,90 @@
+import { m as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+
+/** https://github.com/bevacqua/fuzzysearch + highlighting with Markdown */
+function fuzzyHighlight(needle, haystack) {
+  var caseSensitive = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var ndl = caseSensitive ? needle : needle.toLowerCase();
+  var hstck = caseSensitive ? haystack : haystack.toLowerCase();
+  var result = function result(matched) {
+    var matches = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var highlight = haystack;
+    if (matches.length > 0) {
+      highlight = '';
+      var prevMatch = {
+        to: 0
+      };
+      var _iterator = _createForOfIteratorHelper(matches),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var match = _step.value;
+          highlight += "".concat(haystack.slice(prevMatch.to, match.from), "**").concat(haystack.slice(match.from, match.to), "**");
+          prevMatch = match;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      highlight += haystack.slice(prevMatch.to);
+    }
+    return {
+      matched,
+      matches,
+      highlight
+    };
+  };
+  var hlen = hstck.length;
+  var nlen = ndl.length;
+  if (nlen > hlen) {
+    return result(false);
+  }
+  if (nlen === hlen) {
+    var matched = ndl === hstck;
+    return result(matched, matched ? [{
+      from: 0,
+      to: haystack.length
+    }] : []);
+  }
+  var on = false;
+  var j = 0;
+  var matches = [];
+  var from = 0;
+  /* eslint-disable no-labels */
+  outer: for (var i = 0; i < nlen; i++) {
+    var nch = ndl[i];
+    while (j < hlen) {
+      var hch = hstck[j];
+      var match = hch === nch;
+      // Don't turn highlight on for space characters
+      var nextOn = match && /\S/.test(hch);
+      if (nextOn && !on) {
+        from = j;
+      } else if (!nextOn && on) {
+        matches.push({
+          from,
+          to: j
+        });
+      }
+      j++;
+      on = nextOn;
+      if (match) {
+        continue outer;
+      }
+    }
+    return result(false);
+  }
+  /* eslint-enable */
+  if (on) {
+    matches.push({
+      from,
+      to: j
+    });
+  }
+  return result(true, matches);
+}
+
+export { fuzzyHighlight as default };

package/dist/global/get-event-key.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export default function getEventKey(nativeEvent: KeyboardEvent | React.KeyboardEvent): string;

package/dist/global/get-event-key.js

@@ -0,0 +1,101 @@
+var normalizeKey = {
+  Esc: 'Escape',
+  Spacebar: ' ',
+  Left: 'ArrowLeft',
+  Up: 'ArrowUp',
+  Right: 'ArrowRight',
+  Down: 'ArrowDown',
+  Del: 'Delete',
+  Win: 'OS',
+  Menu: 'ContextMenu',
+  Apps: 'ContextMenu',
+  Scroll: 'ScrollLock',
+  MozPrintableKey: 'Unidentified'
+};
+var translateToKey = {
+  8: 'Backspace',
+  9: 'Tab',
+  12: 'Clear',
+  13: 'Enter',
+  16: 'Shift',
+  17: 'Control',
+  18: 'Alt',
+  19: 'Pause',
+  20: 'CapsLock',
+  27: 'Escape',
+  32: ' ',
+  33: 'PageUp',
+  34: 'PageDown',
+  35: 'End',
+  36: 'Home',
+  37: 'ArrowLeft',
+  38: 'ArrowUp',
+  39: 'ArrowRight',
+  40: 'ArrowDown',
+  45: 'Insert',
+  46: 'Delete',
+  112: 'F1',
+  113: 'F2',
+  114: 'F3',
+  115: 'F4',
+  116: 'F5',
+  117: 'F6',
+  118: 'F7',
+  119: 'F8',
+  120: 'F9',
+  121: 'F10',
+  122: 'F11',
+  123: 'F12',
+  144: 'NumLock',
+  145: 'ScrollLock',
+  224: 'Meta'
+};
+var ENTER = 13;
+var SPACE = 32;
+function getEventCharCode(nativeEvent) {
+  var charCode;
+  var keyCode = nativeEvent.keyCode;
+  if ('charCode' in nativeEvent) {
+    charCode = nativeEvent.charCode;
+    // FF does not set `charCode` for the Enter-key, check against `keyCode`.
+    if (charCode === 0 && keyCode === ENTER) {
+      charCode = ENTER;
+    }
+  } else {
+    // IE8 does not implement `charCode`, but `keyCode` has the correct value.
+    charCode = keyCode;
+  }
+  // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.
+  // Must not discard the (non-)printable Enter-key.
+  if (charCode >= SPACE || charCode === ENTER) {
+    return charCode;
+  }
+  return 0;
+}
+function getEventKey(nativeEvent) {
+  if (nativeEvent.key) {
+    // Normalize inconsistent values reported by browsers due to
+    // implementations of a working draft specification.
+    // FireFox implements `key` but returns `MozPrintableKey` for all
+    // printable characters (normalized to `Unidentified`), ignore it.
+    var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
+    if (key !== 'Unidentified') {
+      return key;
+    }
+  }
+  // Browser does not implement `key`, polyfill as much of it as we can.
+  if (nativeEvent.type === 'keypress') {
+    var charCode = getEventCharCode(nativeEvent);
+    // The enter-key is technically both printable and non-printable and can
+    // thus be captured by `keypress`, no other non-printable key should.
+    return charCode === SPACE ? 'Enter' : String.fromCharCode(charCode);
+  }
+  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {
+    // While user keyboard layout determines the actual meaning of each
+    // `keyCode` value, almost all function keys have a universal value.
+    return translateToKey[nativeEvent.keyCode] || 'Unidentified';
+  }
+  return '';
+}
+
+export { getEventKey as default };

package/dist/global/get-uid.d.ts

@@ -0,0 +1 @@
+export default function getUID(name: string): string;

package/dist/global/get-uid.js

@@ -0,0 +1,22 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.concat.js';
+
+var idCounters = {};
+function generateSalt() {
+  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+  return (Date.now() * Math.random()).toString(36).substring(0, 4);
+}
+var salt = generateSalt();
+function getUID(name) {
+  if (!name) {
+    throw Error('Argument "name" is required in getUID()');
+  }
+  if (!idCounters[name]) {
+    idCounters[name] = 0;
+  }
+  var id = String(idCounters[name]++);
+  return "".concat(name).concat(id, "-").concat(salt);
+}
+
+export { getUID as default };

package/dist/global/inject-styles.d.ts

@@ -0,0 +1,3 @@
+import type { PropertiesHyphen } from 'csstype';
+export declare const injectStyleSheet: (styles: string) => HTMLStyleElement;
+export declare const injectRuleSet: (selector: string, declarations: PropertiesHyphen) => HTMLStyleElement;

package/dist/global/inject-styles.js

@@ -0,0 +1,22 @@
+import { j as _slicedToArray } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.object.entries.js';
+
+var injectStyleSheet = function injectStyleSheet(styles) {
+  var styleTag = document.createElement('style');
+  styleTag.setAttribute('type', 'text/css');
+  styleTag.textContent = styles;
+  document.head.appendChild(styleTag);
+  return styleTag;
+};
+var injectRuleSet = function injectRuleSet(selector, declarations) {
+  return injectStyleSheet("\n".concat(selector, " {\n  ").concat(Object.entries(declarations).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      property = _ref2[0],
+      value = _ref2[1];
+    return "".concat(property, ": ").concat(value, ";");
+  }).join("\n  "), "\n}"));
+};
+
+export { injectRuleSet, injectStyleSheet };

package/dist/global/linear-function.d.ts

@@ -0,0 +1,6 @@
+export interface LinearFunction {
+    y(x: number): number;
+    x(y: number): number;
+}
+export default function linearFunction(x0: number, y0: number, a: number): LinearFunction;
+export declare function interpolateLinear(x0: number, x1: number, phase: number): number;