js-draw 0.18.1 → 0.18.2

package/dist/cjs/src/tools/lib.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * @packageDocumentation
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolbarShortcutHandler = exports.PasteHandler = exports.EraserTool = exports.SelectAllShortcutHandler = exports.SelectionTool = exports.TextTool = exports.PenTool = exports.PanZoomMode = exports.PanZoomTool = exports.ToolSwitcherShortcut = exports.UndoRedoShortcut = exports.ToolEnabledGroup = exports.ToolController = exports.BaseTool = void 0;
+var BaseTool_1 = require("./BaseTool");
+Object.defineProperty(exports, "BaseTool", { enumerable: true, get: function () { return __importDefault(BaseTool_1).default; } });
+var ToolController_1 = require("./ToolController");
+Object.defineProperty(exports, "ToolController", { enumerable: true, get: function () { return __importDefault(ToolController_1).default; } });
+var ToolEnabledGroup_1 = require("./ToolEnabledGroup");
+Object.defineProperty(exports, "ToolEnabledGroup", { enumerable: true, get: function () { return __importDefault(ToolEnabledGroup_1).default; } });
+var UndoRedoShortcut_1 = require("./UndoRedoShortcut");
+Object.defineProperty(exports, "UndoRedoShortcut", { enumerable: true, get: function () { return __importDefault(UndoRedoShortcut_1).default; } });
+var ToolSwitcherShortcut_1 = require("./ToolSwitcherShortcut");
+Object.defineProperty(exports, "ToolSwitcherShortcut", { enumerable: true, get: function () { return __importDefault(ToolSwitcherShortcut_1).default; } });
+var PanZoom_1 = require("./PanZoom");
+Object.defineProperty(exports, "PanZoomTool", { enumerable: true, get: function () { return __importDefault(PanZoom_1).default; } });
+Object.defineProperty(exports, "PanZoomMode", { enumerable: true, get: function () { return PanZoom_1.PanZoomMode; } });
+var Pen_1 = require("./Pen");
+Object.defineProperty(exports, "PenTool", { enumerable: true, get: function () { return __importDefault(Pen_1).default; } });
+var TextTool_1 = require("./TextTool");
+Object.defineProperty(exports, "TextTool", { enumerable: true, get: function () { return __importDefault(TextTool_1).default; } });
+var SelectionTool_1 = require("./SelectionTool/SelectionTool");
+Object.defineProperty(exports, "SelectionTool", { enumerable: true, get: function () { return __importDefault(SelectionTool_1).default; } });
+var SelectAllShortcutHandler_1 = require("./SelectionTool/SelectAllShortcutHandler");
+Object.defineProperty(exports, "SelectAllShortcutHandler", { enumerable: true, get: function () { return __importDefault(SelectAllShortcutHandler_1).default; } });
+var Eraser_1 = require("./Eraser");
+Object.defineProperty(exports, "EraserTool", { enumerable: true, get: function () { return __importDefault(Eraser_1).default; } });
+var PasteHandler_1 = require("./PasteHandler");
+Object.defineProperty(exports, "PasteHandler", { enumerable: true, get: function () { return __importDefault(PasteHandler_1).default; } });
+var ToolbarShortcutHandler_1 = require("./ToolbarShortcutHandler");
+Object.defineProperty(exports, "ToolbarShortcutHandler", { enumerable: true, get: function () { return __importDefault(ToolbarShortcutHandler_1).default; } });

package/dist/cjs/src/tools/localization.d.ts

@@ -0,0 +1,28 @@
+export interface ToolLocalization {
+    keyboardPanZoom: string;
+    penTool: (penId: number) => string;
+    selectionTool: string;
+    selectAllTool: string;
+    eraserTool: string;
+    touchPanTool: string;
+    twoFingerPanZoomTool: string;
+    undoRedoTool: string;
+    pipetteTool: string;
+    rightClickDragPanTool: string;
+    textTool: string;
+    enterTextToInsert: string;
+    changeTool: string;
+    pasteHandler: string;
+    findLabel: string;
+    toNextMatch: string;
+    closeFindDialog: string;
+    findDialogShown: string;
+    findDialogHidden: string;
+    focusedFoundText: (currentMatchNumber: number, totalMatches: number) => string;
+    anyDevicePanning: string;
+    copied: (count: number, description: string) => string;
+    pasted: (count: number, description: string) => string;
+    toolEnabledAnnouncement: (toolName: string) => string;
+    toolDisabledAnnouncement: (toolName: string) => string;
+}
+export declare const defaultToolLocalization: ToolLocalization;

package/dist/cjs/src/tools/localization.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultToolLocalization = void 0;
+exports.defaultToolLocalization = {
+    penTool: (penId) => `Pen ${penId}`,
+    selectionTool: 'Selection',
+    selectAllTool: 'Select all shortcut',
+    eraserTool: 'Eraser',
+    touchPanTool: 'Touch panning',
+    twoFingerPanZoomTool: 'Panning and zooming',
+    undoRedoTool: 'Undo/Redo',
+    rightClickDragPanTool: 'Right-click drag',
+    pipetteTool: 'Pick color from screen',
+    keyboardPanZoom: 'Keyboard pan/zoom shortcuts',
+    textTool: 'Text',
+    enterTextToInsert: 'Text to insert',
+    changeTool: 'Change tool',
+    pasteHandler: 'Copy paste handler',
+    findLabel: 'Find',
+    toNextMatch: 'Next',
+    closeFindDialog: 'Close',
+    findDialogShown: 'Find dialog shown',
+    findDialogHidden: 'Find dialog hidden',
+    focusedFoundText: (matchIdx, totalMatches) => `Viewing match ${matchIdx} of ${totalMatches}`,
+    anyDevicePanning: 'Any device panning',
+    copied: (count, description) => `Copied ${count} ${description}`,
+    pasted: (count, description) => `Pasted ${count} ${description}`,
+    toolEnabledAnnouncement: (toolName) => `${toolName} enabled`,
+    toolDisabledAnnouncement: (toolName) => `${toolName} disabled`,
+};

package/dist/cjs/src/types.d.ts

@@ -0,0 +1,151 @@
+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/Rect2';
+import Pointer from './Pointer';
+import Color4 from './Color4';
+import Command from './commands/Command';
+import BaseWidget from './toolbar/widgets/BaseWidget';
+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;
+export type EditorNotifier = EventDispatcher<EditorEventType, EditorEventDataType>;
+export declare enum EditorEventType {
+    ToolEnabled = 0,
+    ToolDisabled = 1,
+    ToolUpdated = 2,
+    UndoRedoStackUpdated = 3,
+    CommandDone = 4,
+    CommandUndone = 5,
+    ObjectAdded = 6,
+    ViewportChanged = 7,
+    DisplayResized = 8,
+    ColorPickerToggled = 9,
+    ColorPickerColorSelected = 10,
+    ToolbarDropdownShown = 11
+}
+export declare enum UndoEventType {
+    CommandDone = 0,
+    CommandUndone = 1,
+    CommandRedone = 2
+}
+type EditorToolEventType = EditorEventType.ToolEnabled | EditorEventType.ToolDisabled | EditorEventType.ToolUpdated;
+export interface EditorToolEvent {
+    readonly kind: EditorToolEventType;
+    readonly tool: BaseTool;
+}
+export interface EditorObjectEvent {
+    readonly kind: EditorEventType.ObjectAdded;
+    readonly object: AbstractComponent;
+}
+export interface EditorViewportChangedEvent {
+    readonly kind: EditorEventType.ViewportChanged;
+    readonly newTransform: Mat33;
+    readonly oldTransform: Mat33;
+}
+export interface DisplayResizedEvent {
+    readonly kind: EditorEventType.DisplayResized;
+    readonly newSize: Vec2;
+}
+export interface EditorUndoStackUpdated {
+    readonly kind: EditorEventType.UndoRedoStackUpdated;
+    readonly undoStackSize: number;
+    readonly redoStackSize: number;
+    readonly command?: Command;
+    readonly stackUpdateType: UndoEventType;
+}
+export interface CommandDoneEvent {
+    readonly kind: EditorEventType.CommandDone;
+    readonly command: Command;
+}
+export interface CommandUndoneEvent {
+    readonly kind: EditorEventType.CommandUndone;
+    readonly command: Command;
+}
+export interface ColorPickerToggled {
+    readonly kind: EditorEventType.ColorPickerToggled;
+    readonly open: boolean;
+}
+export interface ColorPickerColorSelected {
+    readonly kind: EditorEventType.ColorPickerColorSelected;
+    readonly color: Color4;
+}
+export interface ToolbarDropdownShownEvent {
+    readonly kind: EditorEventType.ToolbarDropdownShown;
+    readonly parentWidget: BaseWidget;
+}
+export type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | 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;
+export interface ImageLoader {
+    start(onAddComponent: ComponentAddedListener, onProgressListener: OnProgressListener, onDetermineExportRect?: OnDetermineExportRectListener): Promise<void>;
+}
+export interface StrokeDataPoint {
+    pos: Point2;
+    width: number;
+    time: number;
+    color: Color4;
+}
+export {};

package/dist/cjs/src/types.js

@@ -0,0 +1,38 @@
+"use strict";
+// Types related to the image editor
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndoEventType = exports.EditorEventType = exports.InputEvtType = void 0;
+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 = exports.InputEvtType || (exports.InputEvtType = {}));
+var EditorEventType;
+(function (EditorEventType) {
+    EditorEventType[EditorEventType["ToolEnabled"] = 0] = "ToolEnabled";
+    EditorEventType[EditorEventType["ToolDisabled"] = 1] = "ToolDisabled";
+    EditorEventType[EditorEventType["ToolUpdated"] = 2] = "ToolUpdated";
+    EditorEventType[EditorEventType["UndoRedoStackUpdated"] = 3] = "UndoRedoStackUpdated";
+    EditorEventType[EditorEventType["CommandDone"] = 4] = "CommandDone";
+    EditorEventType[EditorEventType["CommandUndone"] = 5] = "CommandUndone";
+    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 = exports.EditorEventType || (exports.EditorEventType = {}));
+// Types of `EditorUndoStackUpdated` events.
+var UndoEventType;
+(function (UndoEventType) {
+    UndoEventType[UndoEventType["CommandDone"] = 0] = "CommandDone";
+    UndoEventType[UndoEventType["CommandUndone"] = 1] = "CommandUndone";
+    UndoEventType[UndoEventType["CommandRedone"] = 2] = "CommandRedone";
+})(UndoEventType = exports.UndoEventType || (exports.UndoEventType = {}));

package/dist/cjs/src/util/assertions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Compile-time assertion that a branch of code is unreachable.
+ * @internal
+ */
+export declare const assertUnreachable: (key: never) => never;
+/**
+ * Throws an exception if the typeof given value is not a number or `value` is NaN.
+ *
+ * @example
+ * ```ts
+ * const foo: unknown = 3;
+ * assertIsNumber(foo);
+ *
+ * assertIsNumber('hello, world'); // throws an Error.
+ * ```
+ *
+ *
+ */
+export declare const assertIsNumber: (value: any, allowNaN?: boolean) => value is number;
+/**
+ * Throws if any of `values` is not of type number.
+ */
+export declare const assertIsNumberArray: (values: any[], allowNaN?: boolean) => values is number[];

package/dist/cjs/src/util/assertions.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertIsNumberArray = exports.assertIsNumber = exports.assertUnreachable = void 0;
+/**
+ * Compile-time assertion that a branch of code is unreachable.
+ * @internal
+ */
+const assertUnreachable = (key) => {
+    // See https://stackoverflow.com/a/39419171/17055750
+    throw new Error(`Should be unreachable. Key: ${key}.`);
+};
+exports.assertUnreachable = assertUnreachable;
+/**
+ * Throws an exception if the typeof given value is not a number or `value` is NaN.
+ *
+ * @example
+ * ```ts
+ * const foo: unknown = 3;
+ * assertIsNumber(foo);
+ *
+ * assertIsNumber('hello, world'); // throws an Error.
+ * ```
+ *
+ *
+ */
+const assertIsNumber = (value, allowNaN = false) => {
+    if (typeof value !== 'number' || (!allowNaN && isNaN(value))) {
+        throw new Error('Given value is not a number');
+        // return false;
+    }
+    return true;
+};
+exports.assertIsNumber = assertIsNumber;
+/**
+ * Throws if any of `values` is not of type number.
+ */
+const assertIsNumberArray = (values, allowNaN = false) => {
+    if (typeof values !== 'object') {
+        throw new Error('Asserting isNumberArray: Given entity is not an array');
+    }
+    if (!(0, exports.assertIsNumber)(values['length'])) {
+        return false;
+    }
+    for (const value of values) {
+        if (!(0, exports.assertIsNumber)(value, allowNaN)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.assertIsNumberArray = assertIsNumberArray;

package/dist/cjs/src/util/fileToBase64.d.ts

@@ -0,0 +1,3 @@
+type ProgressListener = (evt: ProgressEvent<FileReader>) => void;
+declare const fileToBase64: (file: File, onprogress?: ProgressListener) => Promise<string | null>;
+export default fileToBase64;

package/dist/cjs/src/util/fileToBase64.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = (evt) => {
+            onprogress === null || onprogress === void 0 ? void 0 : onprogress(evt);
+        };
+        reader.readAsDataURL(file);
+    });
+};
+exports.default = fileToBase64;

package/dist/cjs/src/util/untilNextAnimationFrame.d.ts

@@ -0,0 +1,3 @@
+/** @internal */
+declare const untilNextAnimationFrame: () => Promise<void>;
+export default untilNextAnimationFrame;

package/dist/cjs/src/util/untilNextAnimationFrame.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @internal */
+const untilNextAnimationFrame = () => {
+    return new Promise((resolve) => {
+        requestAnimationFrame(() => resolve());
+    });
+};
+exports.default = untilNextAnimationFrame;

package/dist/cjs/src/util/waitForTimeout.d.ts

@@ -0,0 +1,2 @@
+declare const waitForTimeout: (timeout: number) => Promise<void>;
+export default waitForTimeout;

package/dist/cjs/src/util/waitForTimeout.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Returns a promise that resolves after `timeout` milliseconds.
+const waitForTimeout = (timeout) => {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), timeout);
+    });
+};
+exports.default = waitForTimeout;

package/dist/mjs/src/Color4.d.ts

@@ -0,0 +1,61 @@
+export default class Color4 {
+    /** Red component. Should be in the range [0, 1]. */
+    readonly r: number;
+    /** Green component. `g` ∈ [0, 1] */
+    readonly g: number;
+    /** Blue component. `b` ∈ [0, 1] */
+    readonly b: number;
+    /** Alpha/transparent component. `a` ∈ [0, 1]. 0 = transparent */
+    readonly a: number;
+    private constructor();
+    /**
+     * Create a color from red, green, blue components. The color is fully opaque (`a = 1.0`).
+     *
+     * Each component should be in the range [0, 1].
+     */
+    static ofRGB(red: number, green: number, blue: number): Color4;
+    static ofRGBA(red: number, green: number, blue: number, alpha: number): Color4;
+    static fromHex(hexString: string): Color4;
+    /** Like fromHex, but can handle additional colors if an `HTMLCanvasElement` is available. */
+    static fromString(text: string): Color4;
+    /** @returns true if `this` and `other` are approximately equal. */
+    eq(other: Color4 | null | undefined): boolean;
+    /**
+     * If `fractionTo` is not in the range [0, 1], it will be clamped to the nearest number
+     * in that range. For example, `a.mix(b, -1)` is equivalent to `a.mix(b, 0)`.
+     *
+     * @returns a color `fractionTo` of the way from this color to `other`.
+     *
+     * @example
+     * ```ts
+     * Color4.ofRGB(1, 0, 0).mix(Color4.ofRGB(0, 1, 0), 0.1) // -> Color4(0.9, 0.1, 0)
+     * ```
+     */
+    mix(other: Color4, fractionTo: number): Color4;
+    /**
+     * @returns the component-wise average of `colors`, or `Color4.transparent` if `colors` is empty.
+     */
+    static average(colors: Color4[]): Color4;
+    private hexString;
+    /**
+     * @returns a hexadecimal color string representation of `this`, in the form `#rrggbbaa`.
+     *
+     * @example
+     * ```
+     * Color4.red.toHexString(); // -> #ff0000ff
+     * ```
+     */
+    toHexString(): string;
+    toString(): string;
+    static transparent: Color4;
+    static red: Color4;
+    static green: Color4;
+    static blue: Color4;
+    static purple: Color4;
+    static yellow: Color4;
+    static clay: Color4;
+    static black: Color4;
+    static gray: Color4;
+    static white: Color4;
+}
+export { Color4 };

package/dist/mjs/src/Color4.mjs

@@ -0,0 +1,193 @@
+export default class Color4 {
+    constructor(
+    /** Red component. Should be in the range [0, 1]. */
+    r, 
+    /** Green component. `g` ∈ [0, 1] */
+    g, 
+    /** Blue component. `b` ∈ [0, 1] */
+    b, 
+    /** Alpha/transparent component. `a` ∈ [0, 1]. 0 = transparent */
+    a) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+        this.hexString = null;
+    }
+    /**
+     * Create a color from red, green, blue components. The color is fully opaque (`a = 1.0`).
+     *
+     * Each component should be in the range [0, 1].
+     */
+    static ofRGB(red, green, blue) {
+        return Color4.ofRGBA(red, green, blue, 1.0);
+    }
+    static ofRGBA(red, green, blue, alpha) {
+        red = Math.max(0, Math.min(red, 1));
+        green = Math.max(0, Math.min(green, 1));
+        blue = Math.max(0, Math.min(blue, 1));
+        alpha = Math.max(0, Math.min(alpha, 1));
+        return new Color4(red, green, blue, alpha);
+    }
+    static fromHex(hexString) {
+        var _a;
+        // Remove starting '#' (if present)
+        hexString = ((_a = hexString.match(/^[#]?(.*)$/)) !== null && _a !== void 0 ? _a : [])[1];
+        hexString = hexString.toUpperCase();
+        if (!hexString.match(/^[0-9A-F]+$/)) {
+            throw new Error(`${hexString} is not in a valid format.`);
+        }
+        // RGBA or RGB
+        if (hexString.length === 3 || hexString.length === 4) {
+            // Each character is a component
+            const components = hexString.split('');
+            // Convert to RRGGBBAA or RRGGBB format
+            hexString = components.map(component => `${component}0`).join('');
+        }
+        if (hexString.length === 6) {
+            // Alpha component
+            hexString += 'FF';
+        }
+        const components = [];
+        for (let i = 2; i <= hexString.length; i += 2) {
+            const chunk = hexString.substring(i - 2, i);
+            components.push(parseInt(chunk, 16) / 255);
+        }
+        if (components.length !== 4) {
+            throw new Error(`Unable to parse ${hexString}: Wrong number of components.`);
+        }
+        return Color4.ofRGBA(components[0], components[1], components[2], components[3]);
+    }
+    /** Like fromHex, but can handle additional colors if an `HTMLCanvasElement` is available. */
+    static fromString(text) {
+        if (text.startsWith('#')) {
+            return Color4.fromHex(text);
+        }
+        if (text === 'none' || text === 'transparent') {
+            return Color4.transparent;
+        }
+        // rgba?: Match both rgb and rgba strings.
+        // ([,0-9.]+): Match any string of only numeric, '.' and ',' characters.
+        const rgbRegex = /^rgba?\(([,0-9.]+)\)$/i;
+        const rgbMatch = text.replace(/\s*/g, '').match(rgbRegex);
+        if (rgbMatch) {
+            const componentsListStr = rgbMatch[1];
+            const componentsList = JSON.parse(`[ ${componentsListStr} ]`);
+            if (componentsList.length === 3) {
+                return Color4.ofRGB(componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255);
+            }
+            else if (componentsList.length === 4) {
+                return Color4.ofRGBA(componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255, componentsList[3]);
+            }
+            else {
+                throw new Error(`RGB string, ${text}, has wrong number of components: ${componentsList.length}`);
+            }
+        }
+        // Otherwise, try to use an HTMLCanvasElement to determine the color.
+        // Note: We may be unable to create an HTMLCanvasElement if running as a unit test.
+        const canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = 1;
+        const ctx = canvas.getContext('2d');
+        ctx.fillStyle = text;
+        ctx.fillRect(0, 0, 1, 1);
+        const data = ctx.getImageData(0, 0, 1, 1);
+        const red = data.data[0] / 255;
+        const green = data.data[1] / 255;
+        const blue = data.data[2] / 255;
+        const alpha = data.data[3] / 255;
+        return Color4.ofRGBA(red, green, blue, alpha);
+    }
+    /** @returns true if `this` and `other` are approximately equal. */
+    eq(other) {
+        if (other == null) {
+            return false;
+        }
+        // If both completely transparent,
+        if (this.a === 0 && other.a === 0) {
+            return true;
+        }
+        return this.toHexString() === other.toHexString();
+    }
+    /**
+     * If `fractionTo` is not in the range [0, 1], it will be clamped to the nearest number
+     * in that range. For example, `a.mix(b, -1)` is equivalent to `a.mix(b, 0)`.
+     *
+     * @returns a color `fractionTo` of the way from this color to `other`.
+     *
+     * @example
+     * ```ts
+     * Color4.ofRGB(1, 0, 0).mix(Color4.ofRGB(0, 1, 0), 0.1) // -> Color4(0.9, 0.1, 0)
+     * ```
+     */
+    mix(other, fractionTo) {
+        fractionTo = Math.min(Math.max(fractionTo, 0), 1);
+        const fractionOfThis = 1 - fractionTo;
+        return new Color4(this.r * fractionOfThis + other.r * fractionTo, this.g * fractionOfThis + other.g * fractionTo, this.b * fractionOfThis + other.b * fractionTo, this.a * fractionOfThis + other.a * fractionTo);
+    }
+    /**
+     * @returns the component-wise average of `colors`, or `Color4.transparent` if `colors` is empty.
+     */
+    static average(colors) {
+        let averageA = 0;
+        let averageR = 0;
+        let averageG = 0;
+        let averageB = 0;
+        for (const color of colors) {
+            averageA += color.a;
+            averageR += color.r;
+            averageG += color.g;
+            averageB += color.b;
+        }
+        if (colors.length > 0) {
+            averageA /= colors.length;
+            averageR /= colors.length;
+            averageG /= colors.length;
+            averageB /= colors.length;
+        }
+        return new Color4(averageR, averageG, averageB, averageA);
+    }
+    /**
+     * @returns a hexadecimal color string representation of `this`, in the form `#rrggbbaa`.
+     *
+     * @example
+     * ```
+     * Color4.red.toHexString(); // -> #ff0000ff
+     * ```
+     */
+    toHexString() {
+        if (this.hexString) {
+            return this.hexString;
+        }
+        const componentToHex = (component) => {
+            const res = Math.round(255 * component).toString(16);
+            if (res.length === 1) {
+                return `0${res}`;
+            }
+            return res;
+        };
+        const alpha = componentToHex(this.a);
+        const red = componentToHex(this.r);
+        const green = componentToHex(this.g);
+        const blue = componentToHex(this.b);
+        if (alpha === 'ff') {
+            return `#${red}${green}${blue}`;
+        }
+        this.hexString = `#${red}${green}${blue}${alpha}`;
+        return this.hexString;
+    }
+    toString() {
+        return this.toHexString();
+    }
+}
+Color4.transparent = Color4.ofRGBA(0, 0, 0, 0);
+Color4.red = Color4.ofRGB(1.0, 0.0, 0.0);
+Color4.green = Color4.ofRGB(0.0, 1.0, 0.0);
+Color4.blue = Color4.ofRGB(0.0, 0.0, 1.0);
+Color4.purple = Color4.ofRGB(0.5, 0.2, 0.5);
+Color4.yellow = Color4.ofRGB(1, 1, 0.1);
+Color4.clay = Color4.ofRGB(0.8, 0.4, 0.2);
+Color4.black = Color4.ofRGB(0, 0, 0);
+Color4.gray = Color4.ofRGB(0.5, 0.5, 0.5);
+Color4.white = Color4.ofRGB(1, 1, 1);
+export { Color4 };