@jetbrains/ring-ui 5.1.23 → 5.1.24

package/dist/global/linear-function.js

@@ -0,0 +1,15 @@
+function linearFunction(x0, y0, a) {
+  return {
+    y(x) {
+      return +y0 + (x - x0) * a;
+    },
+    x(y) {
+      return +x0 + (y - y0) / a;
+    }
+  };
+}
+function interpolateLinear(x0, x1, phase) {
+  return linearFunction(x0, x0, phase).y(x1);
+}
+
+export { linearFunction as default, interpolateLinear };

package/dist/global/listeners.d.ts

@@ -0,0 +1,8 @@
+export type Handler<PM extends Record<string, [unknown, unknown]>, E extends keyof PM> = (data: PM[E][0]) => PM[E][1] | Promise<PM[E][1]>;
+export default class Listeners<PM extends Record<string, [unknown, unknown]> = Record<string, [void, unknown]>> {
+    _all: Map<keyof PM, Set<Handler<PM, keyof PM>>>;
+    trigger<E extends keyof PM>(...[event, data]: PM[E][0] extends void ? [E] : [E, PM[E][0]]): Promise<PM[E][1][]>;
+    add<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    remove<E extends keyof PM>(event: E, handler: Handler<PM, E>): void;
+    removeAll(): void;
+}

package/dist/global/listeners.js

@@ -0,0 +1,58 @@
+import { d as _createClass, l as _toConsumableArray, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.set.js';
+
+var Listeners = /*#__PURE__*/function () {
+  function Listeners() {
+    _classCallCheck(this, Listeners);
+    _defineProperty(this, "_all", new Map());
+  }
+  _createClass(Listeners, [{
+    key: "trigger",
+    value: function trigger() {
+      for (var _len = arguments.length, _ref = new Array(_len), _key = 0; _key < _len; _key++) {
+        _ref[_key] = arguments[_key];
+      }
+      var event = _ref[0],
+        data = _ref[1];
+      var handlers = this._all.get(event);
+      if (handlers) {
+        return Promise.all(_toConsumableArray(handlers).map(function (fn) {
+          return fn(data);
+        }));
+      }
+      return Promise.resolve([]);
+    }
+  }, {
+    key: "add",
+    value: function add(event, handler) {
+      var handlers = this._all.get(event);
+      if (!handlers) {
+        handlers = new Set();
+        this._all.set(event, handlers);
+      }
+      handlers.add(handler);
+    }
+  }, {
+    key: "remove",
+    value: function remove(event, handler) {
+      var handlers = this._all.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+      }
+    }
+  }, {
+    key: "removeAll",
+    value: function removeAll() {
+      this._all = new Map();
+    }
+  }]);
+  return Listeners;
+}();
+
+export { Listeners as default };

package/dist/global/memoize.d.ts

@@ -0,0 +1 @@
+export default function memoize<A = void, T = void>(fn: (arg: A) => T): (arg: A) => T;

package/dist/global/memoize.js

@@ -0,0 +1,23 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+
+function memoize(fn) {
+  var primitiveCache = new Map();
+  var objectCache = new WeakMap();
+  return function memoized(arg) {
+    var key = arg !== null && arg !== void 0 ? arg : '__singleValue__';
+    var cache = key instanceof Object ? objectCache : primitiveCache;
+    var cached = cache.get(key);
+    if (cached != null) {
+      return cached;
+    }
+    var value = fn(arg);
+    cache.set(key, value);
+    return value;
+  };
+}
+
+export { memoize as default };

package/dist/global/normalize-indent.d.ts

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

package/dist/global/normalize-indent.js

@@ -0,0 +1,60 @@
+import { l as _toConsumableArray, m as _createForOfIteratorHelper } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.slice.js';
+
+function normalizeIndent(string) {
+  var nonemptyRE = /\S/;
+  var indentRE = /^\s*/;
+  var lines = string.split(/\n/g);
+  var linesCopy = _toConsumableArray(lines);
+  //remove empty lines at the beginning and the end
+  var _iterator = _createForOfIteratorHelper(linesCopy),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      if (nonemptyRE.test(line)) {
+        break;
+      } else {
+        lines.shift();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var _iterator2 = _createForOfIteratorHelper(linesCopy.reverse()),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _line = _step2.value;
+      if (nonemptyRE.test(_line)) {
+        break;
+      } else {
+        lines.pop();
+      }
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var indents = lines.filter(function (line) {
+    return nonemptyRE.test(line);
+  }).map(function (line) {
+    var _line$match$0$length, _line$match;
+    return (_line$match$0$length = (_line$match = line.match(indentRE)) === null || _line$match === void 0 ? void 0 : _line$match[0].length) !== null && _line$match$0$length !== void 0 ? _line$match$0$length : 0;
+  });
+  var minIndent = Math.min.apply(Math, _toConsumableArray(indents));
+  return lines.map(function (line) {
+    return line.slice(minIndent);
+  }).join('\n');
+}
+
+export { normalizeIndent as default };

package/dist/global/promise-with-timeout.d.ts

@@ -0,0 +1,5 @@
+export interface PromiseWithTimeoutConfig {
+    error?: Error | null | undefined;
+    onTimeout?: () => void | undefined;
+}
+export default function promiseWithTimeout<T>(promise: Promise<T>, timeout: number, { error, onTimeout }: PromiseWithTimeoutConfig): Promise<unknown>;

package/dist/global/promise-with-timeout.js

@@ -0,0 +1,19 @@
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
+
+// Useful for using fetch with timeout
+// https://github.com/github/fetch/issues/175#issuecomment-284787564
+function promiseWithTimeout(promise, timeout, _ref) {
+  var error = _ref.error,
+    _ref$onTimeout = _ref.onTimeout,
+    onTimeout = _ref$onTimeout === void 0 ? function () {} : _ref$onTimeout;
+  return new Promise(function (resolve, reject) {
+    setTimeout(function () {
+      onTimeout();
+      reject(error || new Error('Timeout'));
+    }, timeout);
+    promise.then(resolve, reject);
+  });
+}
+
+export { promiseWithTimeout as default };

package/dist/global/prop-types.d.ts

@@ -0,0 +1,4 @@
+import PropTypes from 'prop-types';
+export declare const refObject: <T>(value: PropTypes.Validator<T>) => PropTypes.Requireable<PropTypes.InferProps<{
+    current: PropTypes.Validator<T>;
+}>>;

package/dist/global/prop-types.js

@@ -0,0 +1,9 @@
+import PropTypes from 'prop-types';
+
+var refObject = function refObject(value) {
+  return PropTypes.shape({
+    current: value
+  });
+};
+
+export { refObject };

package/dist/global/react-dom-renderer.d.ts

@@ -0,0 +1,16 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+export interface RendererProps {
+    className?: string | undefined;
+    nodes: readonly Node[] | NodeList;
+}
+export default class Renderer extends Component<RendererProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        nodes: PropTypes.Requireable<object>;
+    };
+    componentDidMount(): void;
+    node?: HTMLElement | null;
+    nodeRef: (node: HTMLElement | null) => void;
+    render(): React.JSX.Element;
+}

package/dist/global/react-dom-renderer.js

@@ -0,0 +1,54 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.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.from.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+
+var Renderer = /*#__PURE__*/function (_Component) {
+  _inherits(Renderer, _Component);
+  var _super = _createSuper(Renderer);
+  function Renderer() {
+    var _this;
+    _classCallCheck(this, Renderer);
+    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), "node", void 0);
+    _defineProperty(_assertThisInitialized(_this), "nodeRef", function (node) {
+      _this.node = node;
+    });
+    return _this;
+  }
+  _createClass(Renderer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var node = this.node;
+      var nodes = this.props.nodes;
+      if (!node || !nodes || !nodes.length) {
+        return;
+      }
+      Array.from(this.props.nodes).forEach(function (nodeToRender) {
+        return node.appendChild(nodeToRender);
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var className = this.props.className;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className,
+        ref: this.nodeRef
+      });
+    }
+  }]);
+  return Renderer;
+}(Component);
+_defineProperty(Renderer, "propTypes", {
+  className: PropTypes.string,
+  nodes: PropTypes.oneOfType([PropTypes.array, PropTypes.object])
+});
+
+export { Renderer as default };

package/dist/global/react-render-adapter.d.ts

@@ -0,0 +1,29 @@
+import type { ReactChild, ReactElement, ReactNode } from 'react';
+import { unmountComponentAtNode as legacyUnmountComponentAtNode } from 'react-dom';
+export declare let render: (element: ReactElement, container: Element | DocumentFragment) => void;
+export declare let unmountComponentAtNode: typeof legacyUnmountComponentAtNode;
+export declare let hydrate: (element: ReactElement, container: Element | Document) => void;
+interface Root {
+    render(children: ReactChild | Iterable<ReactNode>): void;
+    unmount(): void;
+}
+interface RootOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown) => void;
+}
+interface HydrationOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onRecoverableError?: (error: unknown) => void;
+}
+interface Client {
+    createRoot(container: Element | DocumentFragment, options?: RootOptions): Root;
+    hydrateRoot(container: Element | Document, initialChildren: ReactChild | Iterable<ReactNode>, options?: HydrationOptions): Root;
+}
+export declare function setClient({ createRoot, hydrateRoot }: Client): void;
+export {};

package/dist/global/react-render-adapter.js

@@ -0,0 +1,35 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import { render as render$1, unmountComponentAtNode as unmountComponentAtNode$1, hydrate as hydrate$1 } from 'react-dom';
+
+/* eslint-enable */
+/* eslint-disable import/no-mutable-exports */
+var render = render$1;
+var unmountComponentAtNode = unmountComponentAtNode$1;
+var hydrate = hydrate$1;
+// TODO replace with a noop with warning in 6.0, remove in 7.0
+function setClient(_ref) {
+  var createRoot = _ref.createRoot,
+    hydrateRoot = _ref.hydrateRoot;
+  var roots = new WeakMap();
+  render = function render(element, container) {
+    var root = roots.get(container);
+    if (root == null) {
+      root = createRoot(container);
+      roots.set(container, root);
+    }
+    root.render(element);
+  };
+  unmountComponentAtNode = function unmountComponentAtNode(container) {
+    var _roots$get;
+    return (_roots$get = roots.get(container)) === null || _roots$get === void 0 ? void 0 : _roots$get.unmount();
+  };
+  hydrate = function hydrate(element, container) {
+    var root = hydrateRoot(container, element);
+    roots.set(container, root);
+  };
+}
+
+export { hydrate, render, setClient, unmountComponentAtNode };

package/dist/global/rerender-hoc.d.ts

@@ -0,0 +1,41 @@
+import { Component, RefAttributes } from 'react';
+export interface RerenderableComponent<P, S> extends Component<P, S> {
+    node?: HTMLElement | null;
+}
+export interface RerenderableComponentClass<P, S> {
+    new (props: P): RerenderableComponent<P, S>;
+}
+/**
+ * Wraps a component to add a "rerender" method
+ * @param ComposedComponent
+ * @param captureNode, whether the wrapper should capture this.node itself. Set to false if the component already has "node" property captured
+ * @returns {Rerenderer}
+ */
+export default function rerenderHOC<P extends {}, S>(ComposedComponent: RerenderableComponentClass<P, S>): {
+    new (props: P): {
+        _propsCache: P & RefAttributes<unknown>;
+        rerender(props?: Partial<P>, callback?: () => void): void;
+        node?: HTMLElement | null | undefined;
+        context: unknown;
+        setState<K extends keyof S>(state: S | ((prevState: Readonly<S>, props: Readonly<P>) => S | Pick<S, K> | null) | Pick<S, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        render(): import("react").ReactNode;
+        readonly props: Readonly<P>;
+        state: Readonly<S>;
+        refs: {
+            [key: string]: import("react").ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>): any;
+        componentDidUpdate?(prevProps: Readonly<P>, prevState: Readonly<S>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P>, nextState: Readonly<S>, nextContext: any): void;
+    };
+};

package/dist/global/rerender-hoc.js

@@ -0,0 +1,57 @@
+import { a as _inherits, b as _createSuper, d as _createClass, c as _classCallCheck, _ as _defineProperty, k as _assertThisInitialized } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.object.assign.js';
+import { createElement } from 'react';
+import { render } from './react-render-adapter.js';
+import composeRefs from './composeRefs.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react-dom';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+/**
+ * Wraps a component to add a "rerender" method
+ * @param ComposedComponent
+ * @param captureNode, whether the wrapper should capture this.node itself. Set to false if the component already has "node" property captured
+ * @returns {Rerenderer}
+ */
+function rerenderHOC(ComposedComponent) {
+  return /*#__PURE__*/function (_ComposedComponent) {
+    _inherits(Rerenderer, _ComposedComponent);
+    var _super = _createSuper(Rerenderer);
+    function Rerenderer() {
+      var _this;
+      _classCallCheck(this, Rerenderer);
+      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), "_propsCache", _this.props);
+      return _this;
+    }
+    _createClass(Rerenderer, [{
+      key: "rerender",
+      value: function rerender() {
+        var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var callback = arguments.length > 1 ? arguments[1] : undefined;
+        var container;
+        try {
+          var _this$node;
+          container = (_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.parentNode;
+        } finally {
+          if (!container || !(container instanceof Element)) {
+            throw new Error("".concat(this.constructor.name, " component isn't mounted"));
+          }
+        }
+        this._propsCache = Object.assign({}, this.props, this._propsCache, props);
+        this._propsCache.ref = composeRefs(this._propsCache.ref, callback);
+        render( /*#__PURE__*/createElement(this.constructor, this._propsCache), container);
+      }
+    }]);
+    return Rerenderer;
+  }(ComposedComponent);
+}
+
+export { rerenderHOC as default };

package/dist/global/ring-angular-component.js

@@ -0,0 +1,27 @@
+import { d as _createClass, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+
+var RingAngularComponent = /*#__PURE__*/function () {
+  function RingAngularComponent() {
+    var _this$constructor$$in,
+      _this = this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _classCallCheck(this, RingAngularComponent);
+    _defineProperty(this, "$inject", {});
+    ((_this$constructor$$in = this.constructor.$inject) !== null && _this$constructor$$in !== void 0 ? _this$constructor$$in : []).forEach(function (injectName, i) {
+      _this.$inject[injectName] = args[i];
+    });
+  }
+  _createClass(RingAngularComponent, null, [{
+    key: "controller",
+    get: function get() {
+      return this;
+    }
+  }]);
+  return RingAngularComponent;
+}();
+
+export { RingAngularComponent as default };

package/dist/global/schedule-raf.d.ts

@@ -0,0 +1 @@
+export default function scheduleRAF(trailingCall?: boolean): (cb: () => void) => void;

package/dist/global/schedule-raf.js

@@ -0,0 +1,28 @@
+function scheduleRAF(trailingCall) {
+  var scheduledCb;
+  var RAF;
+  var trailingCallScheduled = false;
+  function doSchedule() {
+    RAF = window.requestAnimationFrame(function () {
+      var _scheduledCb;
+      (_scheduledCb = scheduledCb) === null || _scheduledCb === void 0 || _scheduledCb();
+      if (trailingCallScheduled) {
+        trailingCallScheduled = false;
+        doSchedule();
+      } else {
+        RAF = null;
+        scheduledCb = null;
+      }
+    });
+  }
+  return function schedule(cb) {
+    scheduledCb = cb;
+    if (!RAF) {
+      doSchedule();
+    } else if (trailingCall) {
+      trailingCallScheduled = true;
+    }
+  };
+}
+
+export { scheduleRAF as default };

package/dist/global/sniffer.d.ts

@@ -0,0 +1,3 @@
+import Sniffr from 'sniffr';
+declare const sniffr: Sniffr;
+export default sniffr;

package/dist/global/sniffer.js

@@ -0,0 +1,6 @@
+import Sniffr from 'sniffr';
+
+var sniffr = new Sniffr();
+sniffr.sniff();
+
+export { sniffr as default };

package/dist/global/theme.d.ts

@@ -0,0 +1,21 @@
+import React, { HTMLAttributes, ReactElement } from 'react';
+declare enum Theme {
+    AUTO = "auto",
+    LIGHT = "light",
+    DARK = "dark"
+}
+export declare function useTheme(): Theme.LIGHT | Theme.DARK;
+export declare function useThemeClasses(theme: Theme): string;
+export interface WithThemeClassesProps {
+    theme: Theme;
+    children: (classes: string) => ReactElement;
+}
+export declare function WithThemeClasses({ theme, children }: WithThemeClassesProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export declare function applyTheme(theme: Theme.DARK | Theme.LIGHT, container: HTMLElement): void;
+export interface ThemeProviderProps extends HTMLAttributes<HTMLDivElement> {
+    theme?: Theme;
+    passToPopups?: boolean;
+    target?: HTMLElement;
+}
+export declare const ThemeProvider: React.ForwardRefExoticComponent<ThemeProviderProps & React.RefAttributes<HTMLDivElement>>;
+export default Theme;

package/dist/global/theme.js

@@ -0,0 +1,42 @@
+import '../_helpers/_rollupPluginBabelHelpers.js';
+import 'react';
+import 'classnames';
+import 'react-dom';
+import '../popup/popup.target.js';
+import '../popup/popup.js';
+export { a as ThemeProvider, W as WithThemeClasses, c as applyTheme, T as default, u as useTheme, b as useThemeClasses } from '../_helpers/theme.js';
+import './get-uid.js';
+import 'prop-types';
+import 'core-js/modules/es.array.concat.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.object.entries.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import './schedule-raf.js';
+import './dom.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.string.split.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';
+import '../shortcuts/shortcuts.js';
+import 'core-js/modules/es.array.map.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import './sniffer.js';
+import 'sniffr';
+import './data-tests.js';
+import 'core-js/modules/es.array.reduce.js';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
+import '../popup/popup.consts.js';

package/dist/global/trivial-template-tag.d.ts

@@ -0,0 +1 @@
+export default function trivialTemplateTag(f: (string: string) => void): (strings: TemplateStringsArray, ...interpolations: unknown[]) => void;

package/dist/global/trivial-template-tag.js

@@ -0,0 +1,21 @@
+import { l as _toConsumableArray } from '../_helpers/_rollupPluginBabelHelpers.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.splice.js';
+
+var TWO = 2;
+function trivialTemplateTag(f) {
+  return function (strings) {
+    var chunks = _toConsumableArray(strings);
+    // insert the interpolations where they belong to
+    for (var _len = arguments.length, interpolations = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      interpolations[_key - 1] = arguments[_key];
+    }
+    interpolations.forEach(function (value, i) {
+      return chunks.splice(TWO * i + 1, 0, value);
+    });
+    return f(chunks.join(''));
+  };
+}
+
+export { trivialTemplateTag as default };

package/dist/global/typescript-utils.d.ts

@@ -0,0 +1,2 @@
+export declare const isArray: (arg: unknown) => arg is readonly unknown[];
+export declare const isTruthy: <T>(arg: false | "" | 0 | T | null | undefined) => arg is T;

package/dist/global/typescript-utils.js

@@ -0,0 +1,8 @@
+var isArray = function isArray(arg) {
+  return Array.isArray(arg);
+};
+var isTruthy = function isTruthy(arg) {
+  return Boolean(arg);
+};
+
+export { isArray, isTruthy };