js-draw 0.25.0 → 1.0.0

package/dist/mjs/types.d.ts

@@ -1,77 +1,9 @@
-import EventDispatcher from './EventDispatcher';
-import Mat33 from './math/Mat33';
-import { Point2, Vec2 } from './math/Vec2';
-import Vec3 from './math/Vec3';
-import BaseTool from './tools/BaseTool';
-import AbstractComponent from './components/AbstractComponent';
-import Rect2 from './math/shapes/Rect2';
-import Pointer from './Pointer';
-import Color4 from './Color4';
-import Command from './commands/Command';
-import BaseWidget from './toolbar/widgets/BaseWidget';
-export type HTMLPointerEventName = 'pointerdown' | 'pointermove' | 'pointerup' | 'pointercancel';
-export type HTMLPointerEventFilter = (eventName: HTMLPointerEventName, event: PointerEvent) => boolean;
-export interface PointerEvtListener {
-    onPointerDown(event: PointerEvt): boolean;
-    onPointerMove(event: PointerEvt): void;
-    onPointerUp(event: PointerEvt): void;
-    onGestureCancel(): void;
-}
-export declare enum InputEvtType {
-    PointerDownEvt = 0,
-    PointerMoveEvt = 1,
-    PointerUpEvt = 2,
-    GestureCancelEvt = 3,
-    WheelEvt = 4,
-    KeyPressEvent = 5,
-    KeyUpEvent = 6,
-    CopyEvent = 7,
-    PasteEvent = 8
-}
-export interface WheelEvt {
-    readonly kind: InputEvtType.WheelEvt;
-    readonly delta: Vec3;
-    readonly screenPos: Point2;
-}
-export interface KeyPressEvent {
-    readonly kind: InputEvtType.KeyPressEvent;
-    readonly key: string;
-    readonly ctrlKey: boolean | undefined;
-    readonly altKey: boolean | undefined;
-}
-export interface KeyUpEvent {
-    readonly kind: InputEvtType.KeyUpEvent;
-    readonly key: string;
-    readonly ctrlKey: boolean | undefined;
-    readonly altKey: boolean | undefined;
-}
-export interface CopyEvent {
-    readonly kind: InputEvtType.CopyEvent;
-    setData(mime: string, data: string): void;
-}
-export interface PasteEvent {
-    readonly kind: InputEvtType.PasteEvent;
-    readonly data: string;
-    readonly mime: string;
-}
-export interface GestureCancelEvt {
-    readonly kind: InputEvtType.GestureCancelEvt;
-}
-interface PointerEvtBase {
-    readonly current: Pointer;
-    readonly allPointers: Pointer[];
-}
-export interface PointerDownEvt extends PointerEvtBase {
-    readonly kind: InputEvtType.PointerDownEvt;
-}
-export interface PointerMoveEvt extends PointerEvtBase {
-    readonly kind: InputEvtType.PointerMoveEvt;
-}
-export interface PointerUpEvt extends PointerEvtBase {
-    readonly kind: InputEvtType.PointerUpEvt;
-}
-export type PointerEvt = PointerDownEvt | PointerMoveEvt | PointerUpEvt;
-export type InputEvt = KeyPressEvent | KeyUpEvent | WheelEvt | GestureCancelEvt | PointerEvt | CopyEvent | PasteEvent;
+import type EventDispatcher from './EventDispatcher';
+import type { Mat33, Point2, Vec2, Rect2, Color4 } from '@js-draw/math';
+import type BaseTool from './tools/BaseTool';
+import type AbstractComponent from './components/AbstractComponent';
+import type Command from './commands/Command';
+import type { WidgetContentLayoutManager } from './toolbar/widgets/layout/types';
 export type EditorNotifier = EventDispatcher<EditorEventType, EditorEventDataType>;
 export declare enum EditorEventType {
     ToolEnabled = 0,
@@ -83,9 +15,13 @@ export declare enum EditorEventType {
     ObjectAdded = 6,
     ViewportChanged = 7,
     DisplayResized = 8,
-    ColorPickerToggled = 9,
-    ColorPickerColorSelected = 10,
-    ToolbarDropdownShown = 11
+    SelectionUpdated = 9,
+    /** @internal */
+    ColorPickerToggled = 10,
+    /** @internal */
+    ColorPickerColorSelected = 11,
+    /** @deprecated @internal */
+    ToolbarDropdownShown = 12
 }
 export declare enum UndoEventType {
     CommandDone = 0,
@@ -125,6 +61,11 @@ export interface CommandUndoneEvent {
     readonly kind: EditorEventType.CommandUndone;
     readonly command: Command;
 }
+export interface SelectionUpdated {
+    readonly kind: EditorEventType.SelectionUpdated;
+    readonly selectedComponents: AbstractComponent[];
+    readonly tool: BaseTool;
+}
 export interface ColorPickerToggled {
     readonly kind: EditorEventType.ColorPickerToggled;
     readonly open: boolean;
@@ -135,9 +76,10 @@ export interface ColorPickerColorSelected {
 }
 export interface ToolbarDropdownShownEvent {
     readonly kind: EditorEventType.ToolbarDropdownShown;
-    readonly parentWidget: BaseWidget;
+    readonly fromToplevelDropdown: boolean;
+    readonly layoutManager: WidgetContentLayoutManager;
 }
-export type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | ColorPickerToggled | ColorPickerColorSelected | ToolbarDropdownShownEvent;
+export type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | SelectionUpdated | ColorPickerToggled | ColorPickerColorSelected | ToolbarDropdownShownEvent;
 export type OnProgressListener = (amountProcessed: number, totalToProcess: number) => Promise<void> | null | void;
 export type ComponentAddedListener = (component: AbstractComponent) => Promise<void> | void;
 export type OnDetermineExportRectListener = (exportRect: Rect2) => void;
@@ -147,7 +89,7 @@ export interface ImageLoader {
 export interface StrokeDataPoint {
     pos: Point2;
     width: number;
-    /** Time in milliseconds (e.g. as returned by `new Date().getTime()`). */
+    /** Time in milliseconds (e.g. as returned by `performance.now()`). */
     time: number;
     color: Color4;
 }

package/dist/mjs/types.mjs

@@ -1,16 +1,4 @@
 // Types related to the image editor
-export var InputEvtType;
-(function (InputEvtType) {
-    InputEvtType[InputEvtType["PointerDownEvt"] = 0] = "PointerDownEvt";
-    InputEvtType[InputEvtType["PointerMoveEvt"] = 1] = "PointerMoveEvt";
-    InputEvtType[InputEvtType["PointerUpEvt"] = 2] = "PointerUpEvt";
-    InputEvtType[InputEvtType["GestureCancelEvt"] = 3] = "GestureCancelEvt";
-    InputEvtType[InputEvtType["WheelEvt"] = 4] = "WheelEvt";
-    InputEvtType[InputEvtType["KeyPressEvent"] = 5] = "KeyPressEvent";
-    InputEvtType[InputEvtType["KeyUpEvent"] = 6] = "KeyUpEvent";
-    InputEvtType[InputEvtType["CopyEvent"] = 7] = "CopyEvent";
-    InputEvtType[InputEvtType["PasteEvent"] = 8] = "PasteEvent";
-})(InputEvtType || (InputEvtType = {}));
 export var EditorEventType;
 (function (EditorEventType) {
     EditorEventType[EditorEventType["ToolEnabled"] = 0] = "ToolEnabled";
@@ -22,9 +10,13 @@ export var EditorEventType;
     EditorEventType[EditorEventType["ObjectAdded"] = 6] = "ObjectAdded";
     EditorEventType[EditorEventType["ViewportChanged"] = 7] = "ViewportChanged";
     EditorEventType[EditorEventType["DisplayResized"] = 8] = "DisplayResized";
-    EditorEventType[EditorEventType["ColorPickerToggled"] = 9] = "ColorPickerToggled";
-    EditorEventType[EditorEventType["ColorPickerColorSelected"] = 10] = "ColorPickerColorSelected";
-    EditorEventType[EditorEventType["ToolbarDropdownShown"] = 11] = "ToolbarDropdownShown";
+    EditorEventType[EditorEventType["SelectionUpdated"] = 9] = "SelectionUpdated";
+    /** @internal */
+    EditorEventType[EditorEventType["ColorPickerToggled"] = 10] = "ColorPickerToggled";
+    /** @internal */
+    EditorEventType[EditorEventType["ColorPickerColorSelected"] = 11] = "ColorPickerColorSelected";
+    /** @deprecated @internal */
+    EditorEventType[EditorEventType["ToolbarDropdownShown"] = 12] = "ToolbarDropdownShown";
 })(EditorEventType || (EditorEventType = {}));
 // Types of `EditorUndoStackUpdated` events.
 export var UndoEventType;

package/dist/mjs/util/ReactiveValue.d.ts

@@ -0,0 +1,65 @@
+type ListenerResult = {
+    remove(): void;
+};
+type UpdateCallback<T> = (value: T) => void;
+/**
+ * A `ReactiveValue` is a value that
+ * - updates periodically,
+ * - can fire listeners when it updates,
+ * - and can be chanined together with other `ReactiveValue`s.
+ *
+ * A `ReactiveValue` is a read-only view. See {@link MutableReactiveValue} for a
+ * read-write view.
+ *
+ * Static methods in the `ReactiveValue` and `MutableReactiveValue` classes are
+ * constructors (e.g. `fromImmutable`).
+ */
+export declare abstract class ReactiveValue<T> {
+    /**
+     * Returns a reference to the current value of this `ReactiveValue`.
+     *
+     * The result of this **should not be modified** (use `setValue` instead).
+     */
+    abstract get(): T;
+    /**
+     * Registers a listener that is notified when the value of this changes.
+     */
+    abstract onUpdate(listener: UpdateCallback<T>): ListenerResult;
+    /**
+     * Calls `callback` immediately, then registers `callback` as an onUpdateListener.
+     *
+     * @see {@link onUpdate}.
+     */
+    abstract onUpdateAndNow(callback: UpdateCallback<T>): ListenerResult;
+    /** Creates a `ReactiveValue` with an initial value, `initialValue`. */
+    static fromInitialValue<T>(initialValue: T): MutableReactiveValue<T>;
+    /** Returns a `ReactiveValue` that is **known** will never change. */
+    static fromImmutable<T>(value: T): ReactiveValue<T>;
+    /**
+     * Creates a `ReactiveValue` whose values come from `callback`.
+     *
+     * `callback` is called whenever any of `sourceValues` are updated and initially to
+     * set the initial value of the result.
+     */
+    static fromCallback<T>(callback: () => T, sourceValues: ReactiveValue<any>[]): ReactiveValue<T>;
+    /**
+     * Returns a reactive value derived from a single `source`.
+     *
+     * If `inverseMap` is `undefined`, the result is a read-only view.
+     */
+    static map<A, B>(source: ReactiveValue<A>, map: (a: A) => B, inverseMap?: undefined): ReactiveValue<B>;
+    /**
+     * Returns a reactive value derived from a single `source`.
+     */
+    static map<A, B>(source: ReactiveValue<A>, map: (a: A) => B, inverseMap: (b: B) => A): MutableReactiveValue<B>;
+}
+export declare abstract class MutableReactiveValue<T> extends ReactiveValue<T> {
+    /**
+     * Changes the value of this and fires all update listeners.
+     *
+     * @see {@link onUpdate}
+     */
+    abstract set(newValue: T): void;
+    static fromProperty<SourceType extends object, Name extends keyof SourceType>(sourceValue: MutableReactiveValue<SourceType>, propertyName: Name): MutableReactiveValue<SourceType[Name]>;
+}
+export default ReactiveValue;

package/dist/mjs/util/ReactiveValue.mjs

@@ -0,0 +1,161 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ReactiveValueImpl_value, _ReactiveValueImpl_onUpdateListeners;
+const noOpUpdateListenerResult = {
+    remove() { }
+};
+/**
+ * An update listener that does nothing. Useful for reactive values
+ * that will never change.
+ */
+const noOpSetUpdateListener = () => {
+    return noOpUpdateListenerResult;
+};
+/**
+ * A `ReactiveValue` is a value that
+ * - updates periodically,
+ * - can fire listeners when it updates,
+ * - and can be chanined together with other `ReactiveValue`s.
+ *
+ * A `ReactiveValue` is a read-only view. See {@link MutableReactiveValue} for a
+ * read-write view.
+ *
+ * Static methods in the `ReactiveValue` and `MutableReactiveValue` classes are
+ * constructors (e.g. `fromImmutable`).
+ */
+export class ReactiveValue {
+    /** Creates a `ReactiveValue` with an initial value, `initialValue`. */
+    static fromInitialValue(initialValue) {
+        return new ReactiveValueImpl(initialValue);
+    }
+    /** Returns a `ReactiveValue` that is **known** will never change. */
+    static fromImmutable(value) {
+        return {
+            get: () => value,
+            onUpdate: noOpSetUpdateListener,
+            onUpdateAndNow: callback => {
+                callback(value);
+                return noOpUpdateListenerResult;
+            },
+        };
+    }
+    /**
+     * Creates a `ReactiveValue` whose values come from `callback`.
+     *
+     * `callback` is called whenever any of `sourceValues` are updated and initially to
+     * set the initial value of the result.
+     */
+    static fromCallback(callback, sourceValues) {
+        const result = new ReactiveValueImpl(callback());
+        const resultRef = window.WeakRef ? new WeakRef(result) : { deref: () => result };
+        for (const value of sourceValues) {
+            const listener = value.onUpdate(() => {
+                // Use resultRef to allow `result` to be garbage collected
+                // despite this listener.
+                const value = resultRef.deref();
+                if (value) {
+                    value.set(callback());
+                }
+                else {
+                    listener.remove();
+                }
+            });
+        }
+        return result;
+    }
+    static map(source, map, inverseMap) {
+        const result = ReactiveValue.fromInitialValue(map(source.get()));
+        let expectedResultValue = result.get();
+        source.onUpdate(newValue => {
+            expectedResultValue = map(newValue);
+            result.set(expectedResultValue);
+        });
+        if (inverseMap) {
+            result.onUpdate(newValue => {
+                // Prevent infinite loops if inverseMap is not a true
+                // inverse.
+                if (newValue !== expectedResultValue) {
+                    source.set(inverseMap(newValue));
+                }
+            });
+        }
+        return result;
+    }
+}
+export class MutableReactiveValue extends ReactiveValue {
+    static fromProperty(sourceValue, propertyName) {
+        const child = ReactiveValue.fromInitialValue(sourceValue.get()[propertyName]);
+        const childRef = new WeakRef(child);
+        // When the source is updated...
+        const sourceListener = sourceValue.onUpdate(newValue => {
+            const childValue = childRef.deref();
+            if (childValue) {
+                childValue.set(newValue[propertyName]);
+            }
+            else {
+                // TODO: What if `sourceValue` would be dropped before
+                // the child value?
+                sourceListener.remove();
+            }
+        });
+        // When the child is updated, also apply the update to the
+        // parent.
+        child.onUpdate(newValue => {
+            sourceValue.set({
+                ...sourceValue.get(),
+                [propertyName]: newValue,
+            });
+        });
+        return child;
+    }
+}
+// @internal
+class ReactiveValueImpl extends MutableReactiveValue {
+    constructor(initialValue) {
+        super();
+        _ReactiveValueImpl_value.set(this, void 0);
+        _ReactiveValueImpl_onUpdateListeners.set(this, void 0);
+        __classPrivateFieldSet(this, _ReactiveValueImpl_value, initialValue, "f");
+        __classPrivateFieldSet(this, _ReactiveValueImpl_onUpdateListeners, [], "f");
+    }
+    set(newValue) {
+        if (__classPrivateFieldGet(this, _ReactiveValueImpl_value, "f") === newValue) {
+            return;
+        }
+        __classPrivateFieldSet(this, _ReactiveValueImpl_value, newValue, "f");
+        for (const listener of __classPrivateFieldGet(this, _ReactiveValueImpl_onUpdateListeners, "f")) {
+            listener(newValue);
+        }
+    }
+    get() {
+        return __classPrivateFieldGet(this, _ReactiveValueImpl_value, "f");
+    }
+    onUpdate(listener) {
+        // **Note**: If memory is a concern, listeners should avoid referencing this
+        // reactive value directly. Doing so allows the value to be garbage collected when
+        // no longer referenced.
+        __classPrivateFieldGet(this, _ReactiveValueImpl_onUpdateListeners, "f").push(listener);
+        return {
+            remove: () => {
+                __classPrivateFieldSet(this, _ReactiveValueImpl_onUpdateListeners, __classPrivateFieldGet(this, _ReactiveValueImpl_onUpdateListeners, "f").filter(otherListener => {
+                    return otherListener !== listener;
+                }), "f");
+            },
+        };
+    }
+    onUpdateAndNow(callback) {
+        callback(this.get());
+        return this.onUpdate(callback);
+    }
+}
+_ReactiveValueImpl_value = new WeakMap(), _ReactiveValueImpl_onUpdateListeners = new WeakMap();
+export default ReactiveValue;

package/dist/mjs/util/assertions.mjs

@@ -2,9 +2,9 @@
  * Compile-time assertion that a branch of code is unreachable.
  * @internal
  */
-export var assertUnreachable = function (key) {
+export const assertUnreachable = (key) => {
     // See https://stackoverflow.com/a/39419171/17055750
-    throw new Error("Should be unreachable. Key: ".concat(key, "."));
+    throw new Error(`Should be unreachable. Key: ${key}.`);
 };
 /**
  * Throws an exception if the typeof given value is not a number or `value` is NaN.
@@ -19,8 +19,7 @@ export var assertUnreachable = function (key) {
  *
  *
  */
-export var assertIsNumber = function (value, allowNaN) {
-    if (allowNaN === void 0) { allowNaN = false; }
+export const assertIsNumber = (value, allowNaN = false) => {
     if (typeof value !== 'number' || (!allowNaN && isNaN(value))) {
         throw new Error('Given value is not a number');
         // return false;
@@ -30,16 +29,14 @@ export var assertIsNumber = function (value, allowNaN) {
 /**
  * Throws if any of `values` is not of type number.
  */
-export var assertIsNumberArray = function (values, allowNaN) {
-    if (allowNaN === void 0) { allowNaN = false; }
+export const assertIsNumberArray = (values, allowNaN = false) => {
     if (typeof values !== 'object') {
         throw new Error('Asserting isNumberArray: Given entity is not an array');
     }
     if (!assertIsNumber(values['length'])) {
         return false;
     }
-    for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-        var value = values_1[_i];
+    for (const value of values) {
         if (!assertIsNumber(value, allowNaN)) {
             return false;
         }

package/dist/mjs/util/fileToBase64.mjs

@@ -1,11 +1,11 @@
-var fileToBase64 = function (file, onprogress) {
-    var reader = new FileReader();
-    return new Promise(function (resolve, reject) {
-        reader.onload = function () { return resolve(reader.result); };
+const fileToBase64 = (file, onprogress) => {
+    const reader = new FileReader();
+    return new Promise((resolve, reject) => {
+        reader.onload = () => resolve(reader.result);
         reader.onerror = reject;
         reader.onabort = reject;
-        reader.onprogress = function (evt) {
-            onprogress === null || onprogress === void 0 ? void 0 : onprogress(evt);
+        reader.onprogress = (evt) => {
+            onprogress?.(evt);
         };
         reader.readAsDataURL(file);
     });

package/dist/mjs/util/guessKeyCodeFromKey.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Attempts to guess the .code value corresponding to the given key.
+ *
+ * Use this to facilitate testing.
+ *
+ * If no matching keycode is found, returns `key`.
+ */
+declare const guessKeyCodeFromKey: (key: string) => string;
+export default guessKeyCodeFromKey;

package/dist/mjs/util/guessKeyCodeFromKey.mjs

@@ -0,0 +1,30 @@
+// See https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_code_values for
+// more
+const keyToKeyCode = {
+    'Control': 'ControlLeft',
+    '=': 'Equal',
+    '-': 'Minus',
+    ';': 'Semicolon',
+    ' ': 'Space',
+};
+/**
+ * Attempts to guess the .code value corresponding to the given key.
+ *
+ * Use this to facilitate testing.
+ *
+ * If no matching keycode is found, returns `key`.
+ */
+const guessKeyCodeFromKey = (key) => {
+    const upperKey = key.toUpperCase();
+    if ('A' <= upperKey && upperKey <= 'Z') {
+        return `Key${upperKey}`;
+    }
+    if ('0' <= key && key <= '9') {
+        return `Digit${key}`;
+    }
+    if (key in keyToKeyCode) {
+        return keyToKeyCode[key];
+    }
+    return key;
+};
+export default guessKeyCodeFromKey;

package/dist/mjs/util/listPrefixMatch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns true iff all elements in the shorter list equal (===) the elements
+ * in the longer list.
+ */
+declare const listPrefixMatch: <T>(a: T[], b: T[]) => boolean;
+export default listPrefixMatch;

package/dist/mjs/util/listPrefixMatch.mjs

@@ -0,0 +1,15 @@
+/**
+ * Returns true iff all elements in the shorter list equal (===) the elements
+ * in the longer list.
+ */
+const listPrefixMatch = (a, b) => {
+    const shorter = a.length < b.length ? a : b;
+    const longer = shorter === a ? b : a;
+    for (let i = 0; i < shorter.length; i++) {
+        if (shorter[i] !== longer[i]) {
+            return false;
+        }
+    }
+    return true;
+};
+export default listPrefixMatch;

package/dist/mjs/util/stopPropagationOfScrollingWheelEvents.d.ts

@@ -0,0 +1,2 @@
+declare const stopPropagationOfScrollingWheelEvents: (scrollingContainer: HTMLElement) => void;
+export default stopPropagationOfScrollingWheelEvents;

package/dist/mjs/util/stopPropagationOfScrollingWheelEvents.mjs

@@ -0,0 +1,15 @@
+const stopPropagationOfScrollingWheelEvents = (scrollingContainer) => {
+    scrollingContainer.onwheel = (event) => {
+        const hasScroll = scrollingContainer.clientWidth !== scrollingContainer.scrollWidth
+            && event.deltaX !== 0;
+        const eventScrollsPastLeft = scrollingContainer.scrollLeft + event.deltaX <= 0;
+        const scrollRight = scrollingContainer.scrollLeft + scrollingContainer.clientWidth;
+        const eventScrollsPastRight = scrollRight + event.deltaX > scrollingContainer.scrollWidth;
+        // Stop the editor from receiving the event if it will scroll the pen type selector
+        // instead.
+        if (hasScroll && !eventScrollsPastLeft && !eventScrollsPastRight) {
+            event.stopPropagation();
+        }
+    };
+};
+export default stopPropagationOfScrollingWheelEvents;

package/dist/mjs/util/untilNextAnimationFrame.mjs

@@ -1,7 +1,7 @@
 /** @internal */
-var untilNextAnimationFrame = function () {
-    return new Promise(function (resolve) {
-        requestAnimationFrame(function () { return resolve(); });
+const untilNextAnimationFrame = () => {
+    return new Promise((resolve) => {
+        requestAnimationFrame(() => resolve());
     });
 };
 export default untilNextAnimationFrame;

package/dist/mjs/util/waitForAll.mjs

@@ -2,13 +2,13 @@
  * Resolves when all given promises have resolved. If no promises are given,
  * does not return a Promise.
  */
-var waitForAll = function (results) {
+const waitForAll = (results) => {
     // If any are Promises...
-    if (results.some(function (command) { return command && command['then']; })) {
+    if (results.some(command => command && command['then'])) {
         // Wait for all commands to finish.
         return Promise.all(results)
             // Ensure we return a Promise<void> and not a Promise<void[]>
-            .then(function () { });
+            .then(() => { });
     }
     return;
 };

package/dist/mjs/util/waitForTimeout.mjs

@@ -1,7 +1,7 @@
 // Returns a promise that resolves after `timeout` milliseconds.
-var waitForTimeout = function (timeout) {
-    return new Promise(function (resolve) {
-        setTimeout(function () { return resolve(); }, timeout);
+const waitForTimeout = (timeout) => {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), timeout);
     });
 };
 export default waitForTimeout;

package/dist/mjs/version.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    number: string;
+};
+export default _default;

package/dist/mjs/version.mjs

@@ -0,0 +1,3 @@
+export default {
+    number: '1.0.0',
+};