@opendaw/lib-dom 0.0.6

package/README.md

@@ -0,0 +1 @@
+This package is part of the openDAW SDK

package/dist/browser.d.ts

@@ -0,0 +1,10 @@
+export declare namespace Browser {
+    const isLocalHost: () => boolean;
+    const isMacOS: () => boolean;
+    const isWindows: () => boolean;
+    const isFirefox: () => boolean;
+    const isWeb: () => boolean;
+    const isTauriApp: () => boolean;
+    const userAgent: string;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAEA,yBAAiB,OAAO,CAAC;IAGd,MAAM,WAAW,eAA2D,CAAA;IAC5E,MAAM,OAAO,eAAiE,CAAA;IAC9E,MAAM,SAAS,eAAgE,CAAA;IAC/E,MAAM,SAAS,eAA8E,CAAA;IAC7F,MAAM,KAAK,eAAsB,CAAA;IACjC,MAAM,UAAU,eAA8B,CAAA;IAC9C,MAAM,SAAS,QAMH,CAAA;CACtB"}

package/dist/browser.js

@@ -0,0 +1,19 @@
+// noinspection PlatformDetectionJS
+export var Browser;
+(function (Browser) {
+    const hasLocation = typeof self !== "undefined" && "location" in self && typeof self.location !== undefined;
+    const hasNavigator = typeof self !== "undefined" && "navigator" in self && typeof self.navigator !== undefined;
+    Browser.isLocalHost = () => hasLocation && location.host.includes("localhost");
+    Browser.isMacOS = () => hasNavigator && navigator.userAgent.includes("Mac OS X");
+    Browser.isWindows = () => hasNavigator && navigator.userAgent.includes("Windows");
+    Browser.isFirefox = () => hasNavigator && navigator.userAgent.toLowerCase().includes("firefox");
+    Browser.isWeb = () => !Browser.isTauriApp();
+    Browser.isTauriApp = () => "__TAURI__" in window;
+    Browser.userAgent = hasNavigator ? navigator.userAgent
+        .replace(/^Mozilla\/[\d.]+\s*/, "")
+        .replace(/\bAppleWebKit\/[\d.]+\s*/g, "")
+        .replace(/\(KHTML, like Gecko\)\s*/g, "")
+        .replace(/\bSafari\/[\d.]+\s*/g, "")
+        .replace(/\s+/g, " ")
+        .trim() : "N/A";
+})(Browser || (Browser = {}));

package/dist/compression.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Compression {
+    const encode: (buffer: ArrayBuffer, format?: CompressionFormat) => Promise<ArrayBuffer>;
+    const decode: (buffer: ArrayBuffer, format?: CompressionFormat) => Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=compression.d.ts.map

package/dist/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../src/compression.ts"],"names":[],"mappings":"AAAA,yBAAiB,WAAW,CAAC;IAClB,MAAM,MAAM,GAAU,QAAQ,WAAW,EAAE,SAAQ,iBAA0B,KAAG,OAAO,CAAC,WAAW,CAMzG,CAAA;IAEM,MAAM,MAAM,GAAU,QAAQ,WAAW,EAAE,SAAQ,iBAA0B,KAAG,OAAO,CAAC,WAAW,CAMzG,CAAA;CACJ"}

package/dist/compression.js

@@ -0,0 +1,17 @@
+export var Compression;
+(function (Compression) {
+    Compression.encode = async (buffer, format = "gzip") => {
+        const stream = new CompressionStream(format);
+        const writer = stream.writable.getWriter();
+        writer.write(new Uint8Array(buffer));
+        writer.close();
+        return new Response(stream.readable).arrayBuffer();
+    };
+    Compression.decode = async (buffer, format = "gzip") => {
+        const stream = new DecompressionStream(format);
+        const writer = stream.writable.getWriter();
+        writer.write(new Uint8Array(buffer));
+        writer.close();
+        return new Response(stream.readable).arrayBuffer();
+    };
+})(Compression || (Compression = {}));

package/dist/console-commands.d.ts

@@ -0,0 +1,8 @@
+import { AnyFunc, ObservableValue, Procedure, Provider } from "@opendaw/lib-std";
+export type DotPath = string;
+export declare namespace ConsoleCommands {
+    const exportMethod: (path: DotPath, callback: AnyFunc) => void;
+    const exportBoolean: (path: DotPath, init?: boolean) => ObservableValue<boolean>;
+    const exportAccessor: (path: DotPath, getter: Provider<unknown>, setter?: Procedure<any>) => void;
+}
+//# sourceMappingURL=console-commands.d.ts.map

package/dist/console-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-commands.d.ts","sourceRoot":"","sources":["../src/console-commands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAA0C,eAAe,EAAE,SAAS,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AAEtH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAA;AAE5B,yBAAiB,eAAe,CAAC;IACtB,MAAM,YAAY,GAAI,MAAM,OAAO,EAAE,UAAU,OAAO,KAAG,IAC9B,CAAA;IAE3B,MAAM,aAAa,GAAI,MAAM,OAAO,EAAE,OAAM,OAAe,KAAG,eAAe,CAAC,OAAO,CAQ3F,CAAA;IAEM,MAAM,cAAc,GAAI,MAAM,OAAO,EAAE,QAAQ,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAQ,SAAS,CAAC,GAAG,CAAkB,KAAG,IAsB7G,CAAA;CAcT"}

package/dist/console-commands.js

@@ -0,0 +1,55 @@
+import { DefaultObservableValue, EmptyProcedure } from "@opendaw/lib-std";
+export var ConsoleCommands;
+(function (ConsoleCommands) {
+    ConsoleCommands.exportMethod = (path, callback) => store(path, { value: callback });
+    ConsoleCommands.exportBoolean = (path, init = false) => {
+        const observableValue = new DefaultObservableValue(init);
+        ConsoleCommands.exportAccessor(path, () => observableValue.getValue(), input => {
+            const value = Boolean(input);
+            console.debug(`set to ${value}`);
+            observableValue.setValue(value);
+        });
+        return observableValue;
+    };
+    ConsoleCommands.exportAccessor = (path, getter, setter = EmptyProcedure) => store(path, {
+        get: () => {
+            try {
+                console.debug(getter());
+                return 0;
+            }
+            catch (error) {
+                console.error(error);
+                return 1;
+            }
+        },
+        set: (value) => {
+            try {
+                setter(value);
+                return getter();
+            }
+            catch (error) {
+                console.error(error);
+                return 1;
+            }
+        },
+        enumerable: false,
+        configurable: false
+    });
+    const global = (() => { try {
+        return self;
+    }
+    catch (_) {
+        return {};
+    } })();
+    const scope = (global["opendaw"] ??= {});
+    const store = (path, attributes) => {
+        const levels = path.split(".");
+        const name = levels.splice(-1)[0];
+        let current = scope;
+        for (const level of levels) {
+            current = (current[level] ??= {});
+        }
+        Object.defineProperty(current, name, attributes);
+        console.debug(`Console command 'opendaw.${path}' exported`);
+    };
+})(ConsoleCommands || (ConsoleCommands = {}));

package/dist/context-2d.d.ts

@@ -0,0 +1,7 @@
+export declare namespace Context2d {
+    const truncateText: (context: CanvasRenderingContext2D, text: string, maxWidth: number) => {
+        text: string;
+        width: number;
+    };
+}
+//# sourceMappingURL=context-2d.d.ts.map

package/dist/context-2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-2d.d.ts","sourceRoot":"","sources":["../src/context-2d.ts"],"names":[],"mappings":"AAIA,yBAAiB,SAAS,CAAC;IAChB,MAAM,YAAY,GAAI,SAAS,wBAAwB,EAAE,MAAM,MAAM,EAAE,UAAU,MAAM,KAAG;QAC7F,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAA;KAoBhB,CAAA;CACJ"}

package/dist/context-2d.js

@@ -0,0 +1,31 @@
+const ellipsis = "…";
+export var Context2d;
+(function (Context2d) {
+    Context2d.truncateText = (context, text, maxWidth) => {
+        if (text.length === 0) {
+            return { text: "", width: 0 };
+        }
+        let width = context.measureText(text).width;
+        if (width <= maxWidth) {
+            return { text, width };
+        }
+        const ellipseWidth = context.measureText(ellipsis).width;
+        let l = 0 | 0;
+        let r = text.length | 0;
+        while (l < r) {
+            const mid = (r + l) >>> 1;
+            width = context.measureText(text.substring(0, mid + 1)).width + ellipseWidth;
+            if (width <= maxWidth) {
+                l = mid + 1;
+            }
+            else {
+                r = mid;
+            }
+        }
+        if (l === 0) {
+            return { text: "", width: 0 };
+        }
+        const result = text.substring(0, l);
+        return { text: result + ellipsis, width: context.measureText(result).width + ellipseWidth };
+    };
+})(Context2d || (Context2d = {}));

package/dist/css-utils.d.ts

@@ -0,0 +1,7 @@
+export declare namespace CssUtils {
+    const calc: (term: string, size: number, em: number) => number;
+    const registerCustomCursor: (identifier: number, data: string) => Map<number, string>;
+    const setCursor: (identifier: CssUtils.Cursor | number, doc?: Document) => void;
+    type Cursor = "alias" | "all-scroll" | "auto" | "cell" | "context-menu" | "col-resize" | "copy" | "crosshair" | "default" | "e-resize" | "ew-resize" | "grab" | "grabbing" | "help" | "move" | "n-resize" | "ne-resize" | "nesw-resize" | "ns-resize" | "nw-resize" | "nwse-resize" | "no-drop" | "none" | "not-allowed" | "pointer" | "progress" | "row-resize" | "s-resize" | "se-resize" | "sw-resize" | "text" | "url" | "w-resize" | "wait" | "zoom-in" | "zoom-out";
+}
+//# sourceMappingURL=css-utils.d.ts.map

package/dist/css-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-utils.d.ts","sourceRoot":"","sources":["../src/css-utils.ts"],"names":[],"mappings":"AAEA,yBAAiB,QAAQ,CAAC;IACf,MAAM,IAAI,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,EAAE,IAAI,MAAM,KAAG,MAmB7D,CAAA;IAIM,MAAM,oBAAoB,GAAI,YAAY,MAAM,EAAE,MAAM,MAAM,wBAAwC,CAAA;IAEtG,MAAM,SAAS,GAAI,YAAY,QAAQ,CAAC,MAAM,GAAG,MAAM,EAAE,MAAK,QAAmB,SAIvF,CAAA;IAED,KAAY,MAAM,GACZ,OAAO,GACP,YAAY,GACZ,MAAM,GACN,MAAM,GACN,cAAc,GACd,YAAY,GACZ,MAAM,GACN,WAAW,GACX,SAAS,GACT,UAAU,GACV,WAAW,GACX,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,GACN,UAAU,GACV,WAAW,GACX,aAAa,GACb,WAAW,GACX,WAAW,GACX,aAAa,GACb,SAAS,GACT,MAAM,GACN,aAAa,GACb,SAAS,GACT,UAAU,GACV,YAAY,GACZ,UAAU,GACV,WAAW,GACX,WAAW,GACX,MAAM,GACN,KAAK,GACL,UAAU,GACV,MAAM,GACN,SAAS,GACT,UAAU,CAAA;CACnB"}

package/dist/css-utils.js

@@ -0,0 +1,36 @@
+import { panic } from "@opendaw/lib-std";
+export var CssUtils;
+(function (CssUtils) {
+    CssUtils.calc = (term, size, em) => {
+        const regex = /([0-9]*\.?[0-9]+)([a-zA-Z%]*)/g;
+        let result = term;
+        result.split(/\+|(?<!\d)-/)
+            .flatMap(result => Array.from(result.matchAll(regex)))
+            .forEach(([replace, digits, unit]) => {
+            const number = parseFloat(digits);
+            if (isNaN(number)) {
+                return panic(`${replace} does not contain a number`);
+            }
+            if (unit === "em") {
+                result = result.replaceAll(replace, `${number * em}`);
+            }
+            else if (unit === "%") {
+                result = result.replaceAll(replace, `${number / 100.0 * size}`);
+            }
+            else if (unit === "px") {
+                result = result.replaceAll(replace, `${number}`);
+            }
+            else {
+                return panic(`Unknown unit '${unit}'`);
+            }
+        });
+        return Function(`return ${result}`)();
+    };
+    const customCursors = new Map();
+    CssUtils.registerCustomCursor = (identifier, data) => customCursors.set(identifier, data);
+    CssUtils.setCursor = (identifier, doc = document) => {
+        doc.documentElement.style.cursor = typeof identifier === "number"
+            ? customCursors.get(identifier) ?? "auto"
+            : identifier;
+    };
+})(CssUtils || (CssUtils = {}));

package/dist/dragging.d.ts

@@ -0,0 +1,25 @@
+import { Func, Option, Terminable } from "@opendaw/lib-std";
+import { PointerCaptureTarget } from "./events";
+export declare namespace Dragging {
+    interface Process {
+        update(event: Event): void;
+        cancel?(): void;
+        approve?(): void;
+        finally?(): void;
+        abortSignal?: AbortSignal;
+    }
+    interface Event {
+        readonly clientX: number;
+        readonly clientY: number;
+        readonly altKey: boolean;
+        readonly shiftKey: boolean;
+        readonly ctrlKey: boolean;
+    }
+    interface ProcessOptions {
+        multiTouch?: boolean;
+        immediate?: boolean;
+        permanentUpdates?: boolean;
+    }
+    const attach: <T extends PointerCaptureTarget>(target: T, factory: Func<PointerEvent, Option<Process>>, options?: ProcessOptions) => Terminable;
+}
+//# sourceMappingURL=dragging.d.ts.map

package/dist/dragging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dragging.d.ts","sourceRoot":"","sources":["../src/dragging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAA;AAGrE,OAAO,EAAS,oBAAoB,EAAC,MAAM,UAAU,CAAA;AAGrD,yBAAiB,QAAQ,CAAC;IACtB,UAAiB,OAAO;QACpB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;QAC1B,MAAM,CAAC,IAAI,IAAI,CAAA;QACf,OAAO,CAAC,IAAI,IAAI,CAAA;QAChB,OAAO,CAAC,IAAI,IAAI,CAAA;QAChB,WAAW,CAAC,EAAE,WAAW,CAAA;KAC5B;IAED,UAAiB,KAAK;QAClB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;QACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;QAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;KAC5B;IAED,UAAiB,cAAc;QAC3B,UAAU,CAAC,EAAE,OAAO,CAAA;QACpB,SAAS,CAAC,EAAE,OAAO,CAAA;QACnB,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAC7B;IAEM,MAAM,MAAM,GAAI,CAAC,SAAS,oBAAoB,EAAE,QAAQ,CAAC,EACT,SAAS,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,EAC5C,UAAU,cAAc,KAAG,UA0FjF,CAAA;CACJ"}

package/dist/dragging.js

@@ -0,0 +1,105 @@
+import { Terminable, Terminator } from "@opendaw/lib-std";
+import { Browser } from "./browser";
+import { AnimationFrame } from "./frames";
+import { Events } from "./events";
+import { Keyboard } from "./keyboard";
+export var Dragging;
+(function (Dragging) {
+    Dragging.attach = (target, factory, options) => {
+        const processCycle = new Terminator();
+        return Terminable.many(processCycle, Events.subscribe(target, "pointerdown", (event) => {
+            if (options?.multiTouch !== true && !event.isPrimary) {
+                return;
+            }
+            if (event.buttons !== 1 || (Browser.isMacOS() && event.ctrlKey)) {
+                return;
+            }
+            const option = factory(event);
+            if (option.isEmpty()) {
+                return;
+            }
+            const process = option.unwrap();
+            const pointerId = event.pointerId;
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+            target.setPointerCapture(pointerId);
+            const moveEvent = {
+                clientX: event.clientX,
+                clientY: event.clientY,
+                altKey: event.altKey,
+                shiftKey: event.shiftKey,
+                ctrlKey: Keyboard.isControlKey(event)
+            };
+            if (options?.immediate === true) {
+                process.update(moveEvent);
+            }
+            if (options?.permanentUpdates === true) {
+                processCycle.own(AnimationFrame.add(() => process.update(moveEvent)));
+                processCycle.own(Events.subscribe(target, "pointermove", (event) => {
+                    if (event.pointerId === pointerId) {
+                        moveEvent.clientX = event.clientX;
+                        moveEvent.clientY = event.clientY;
+                        moveEvent.altKey = event.altKey;
+                        moveEvent.shiftKey = event.shiftKey;
+                        moveEvent.ctrlKey = Keyboard.isControlKey(event);
+                    }
+                }));
+            }
+            else {
+                processCycle.own(Events.subscribe(target, "pointermove", (event) => {
+                    if (event.pointerId === pointerId) {
+                        moveEvent.clientX = event.clientX;
+                        moveEvent.clientY = event.clientY;
+                        moveEvent.altKey = event.altKey;
+                        moveEvent.shiftKey = event.shiftKey;
+                        moveEvent.ctrlKey = Keyboard.isControlKey(event);
+                        process.update(moveEvent);
+                    }
+                }));
+            }
+            const cancel = () => {
+                process.cancel?.call(process);
+                process.finally?.call(process);
+                processCycle.terminate();
+            };
+            processCycle.ownAll(Events.subscribe(target, "pointerup", (event) => {
+                if (event.pointerId === pointerId) {
+                    process.approve?.call(process);
+                    process.finally?.call(process);
+                    processCycle.terminate();
+                }
+            }, { capture: true }), Events.subscribe(target, "pointercancel", (event) => {
+                console.debug(event.type);
+                if (event.pointerId === pointerId) {
+                    target.releasePointerCapture(pointerId);
+                    cancel();
+                }
+            }, { capture: true }), Events.subscribe(self, "beforeunload", (_event) => {
+                // Workaround for Chrome (does not release or cancel pointer)
+                target.releasePointerCapture(pointerId);
+                cancel();
+            }, { capture: true }), Events.subscribe(window, "keydown", (event) => {
+                moveEvent.altKey = event.altKey;
+                moveEvent.shiftKey = event.shiftKey;
+                moveEvent.ctrlKey = Keyboard.isControlKey(event);
+                if (event.key === "Escape") {
+                    cancel();
+                }
+                else {
+                    process.update(moveEvent);
+                }
+            }), Events.subscribe(window, "keyup", (event) => {
+                moveEvent.altKey = event.altKey;
+                moveEvent.shiftKey = event.shiftKey;
+                moveEvent.ctrlKey = Keyboard.isControlKey(event);
+                process.update(moveEvent);
+            }));
+            if (process.abortSignal) {
+                processCycle.own(Events.subscribe(process.abortSignal, "abort", () => {
+                    target.releasePointerCapture(pointerId);
+                    cancel();
+                }));
+            }
+        }));
+    };
+})(Dragging || (Dragging = {}));

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Errors {
+    const AbortError: number | Readonly<DOMException>;
+    const isAbort: (error: unknown) => boolean;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,yBAAiB,MAAM,CAAC;IACb,MAAM,UAAU,iCACkC,CAAA;IAElD,MAAM,OAAO,GAAI,OAAO,OAAO,YACoD,CAAA;CAC7F"}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export var Errors;
+(function (Errors) {
+    Errors.AbortError = typeof DOMException === "undefined"
+        ? NaN : Object.freeze(new DOMException("AbortError"));
+    Errors.isAbort = (error) => error === Errors.AbortError || (error instanceof DOMException && error.name === "AbortError");
+})(Errors || (Errors = {}));

package/dist/events.d.ts

@@ -0,0 +1,15 @@
+import { Nullable, Procedure, Subscription } from "@opendaw/lib-std";
+export declare class Events {
+    static subscribe<K extends keyof WindowEventMap>(eventTarget: EventTarget, type: K, listener: (ev: WindowEventMap[K]) => void, options?: boolean | AddEventListenerOptions): Subscription;
+    static subscribeAny<E extends Event>(eventTarget: EventTarget, type: string, listener: (event: E) => void, options?: boolean | AddEventListenerOptions): Subscription;
+    static DOUBLE_DOWN_THRESHOLD: 200;
+    static subscribeDblDwn: (eventTarget: EventTarget, listener: (event: PointerEvent) => void) => Subscription;
+    static readonly PreventDefault: Procedure<Event>;
+    static readonly isTextInput: (target: Nullable<EventTarget>) => boolean;
+}
+export interface PointerCaptureTarget extends EventTarget {
+    setPointerCapture(pointerId: number): void;
+    releasePointerCapture(pointerId: number): void;
+    hasPointerCapture(pointerId: number): boolean;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAC,MAAM,kBAAkB,CAAA;AAE7E,qBAAa,MAAM;IACf,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,cAAc,EAAE,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,CAAC,EACP,QAAQ,EAAE,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,IAAI,EACzC,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAAG,YAAY;IAK3G,MAAM,CAAC,YAAY,CAAC,CAAC,SAAS,KAAK,EAAE,WAAW,EAAE,WAAW,EACxB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC5B,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAAG,YAAY;IAK/F,MAAM,CAAC,qBAAqB,EAAG,GAAG,CAAS;IAE3C,MAAM,CAAC,eAAe,GAAI,aAAa,WAAW,EAAE,UAAU,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAG,YAAY,CASzG;IAED,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,SAAS,CAAC,KAAK,CAAC,CAAkC;IAElF,MAAM,CAAC,QAAQ,CAAC,WAAW,GAAI,QAAQ,QAAQ,CAAC,WAAW,CAAC,KAAG,OAAO,CAEqB;CAC9F;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACrD,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1C,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9C,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;CAChD"}

package/dist/events.js

@@ -0,0 +1,26 @@
+import { isDefined } from "@opendaw/lib-std";
+export class Events {
+    static subscribe(eventTarget, type, listener, options) {
+        eventTarget.addEventListener(type, listener, options);
+        return { terminate: () => eventTarget.removeEventListener(type, listener, options) };
+    }
+    static subscribeAny(eventTarget, type, listener, options) {
+        eventTarget.addEventListener(type, listener, options);
+        return { terminate: () => eventTarget.removeEventListener(type, listener, options) };
+    }
+    static DOUBLE_DOWN_THRESHOLD = 200;
+    static subscribeDblDwn = (eventTarget, listener) => {
+        let lastDownTime = 0.0;
+        return this.subscribe(eventTarget, "pointerdown", event => {
+            const now = performance.now();
+            if (now - lastDownTime < this.DOUBLE_DOWN_THRESHOLD) {
+                listener(event);
+            }
+            lastDownTime = now;
+        }, { capture: true });
+    };
+    static PreventDefault = event => event.preventDefault();
+    static isTextInput = (target) => target instanceof HTMLInputElement
+        || target instanceof HTMLTextAreaElement
+        || (target instanceof HTMLElement && isDefined(target.getAttribute("contenteditable")));
+}

package/dist/files.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Files {
+    const save: (arrayBuffer: ArrayBuffer, options?: SaveFilePickerOptions) => Promise<string>;
+    const open: (options?: OpenFilePickerOptions) => Promise<ReadonlyArray<File>>;
+}
+//# sourceMappingURL=files.d.ts.map

package/dist/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../src/files.ts"],"names":[],"mappings":"AAGA,yBAAiB,KAAK,CAAC;IACZ,MAAM,IAAI,GAAU,aAAa,WAAW,EAAE,UAAU,qBAAqB,KAAG,OAAO,CAAC,MAAM,CAkBpG,CAAA;IAEM,MAAM,IAAI,GAAU,UAAU,qBAAqB,KAAG,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,CAgCvF,CAAA;CACJ"}

package/dist/files.js

@@ -0,0 +1,62 @@
+import { Arrays, asDefined, isDefined } from "@opendaw/lib-std";
+import { Promises } from "@opendaw/lib-runtime";
+export var Files;
+(function (Files) {
+    Files.save = async (arrayBuffer, options) => {
+        if (isDefined(window.showSaveFilePicker)) {
+            const handle = await window.showSaveFilePicker(options);
+            const writable = await handle.createWritable();
+            await writable.truncate(0);
+            await writable.write(arrayBuffer);
+            await writable.close();
+            return handle.name ?? "unknown";
+        }
+        else {
+            const blob = new Blob([arrayBuffer]);
+            const url = URL.createObjectURL(blob);
+            const anchor = document.createElement("a");
+            anchor.href = url;
+            anchor.download = options?.suggestedName ?? `unknown`;
+            anchor.click();
+            URL.revokeObjectURL(url);
+            return options?.suggestedName ?? "Unknown";
+        }
+    };
+    Files.open = async (options) => {
+        if (isDefined(window.showOpenFilePicker)) {
+            const { status, value: fileHandles, error } = await Promises.tryCatch(window.showOpenFilePicker(options));
+            if (status === "rejected") {
+                return Promise.reject(error);
+            }
+            return Promise.all(fileHandles.map(fileHandle => fileHandle.getFile()));
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                if (isDefined(options)) {
+                    console.warn("FileApi.showOpenFilePicker is emulated in this browser. OpenFilePickerOptions are ignored.");
+                }
+                const fileInput = document.createElement("input");
+                fileInput.type = "file";
+                fileInput.multiple = options?.multiple ?? false;
+                fileInput.style.display = "none";
+                fileInput.addEventListener("cancel", async () => {
+                    fileInput.remove();
+                    reject(new DOMException("cancel", "AbortError"));
+                });
+                fileInput.addEventListener("change", async (event) => {
+                    const target = event.target;
+                    const files = target.files;
+                    if (isDefined(files)) {
+                        resolve(Arrays.create(index => asDefined(files.item(index), `No file at index ${index}`), files.length));
+                    }
+                    else {
+                        reject(new DOMException("cancel", "AbortError"));
+                    }
+                    fileInput.remove();
+                });
+                document.body.appendChild(fileInput);
+                fileInput.click();
+            });
+        }
+    };
+})(Files || (Files = {}));

package/dist/fonts.d.ts

@@ -0,0 +1,8 @@
+export type FontFaceProperties = {
+    "font-family": string;
+    "font-style": "normal" | "italic" | "oblique";
+    "font-weight": 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 1000 | "normal" | "bold" | "bolder" | "lighter";
+    "src": string;
+};
+export declare const loadFont: (properties: FontFaceProperties) => Promise<void>;
+//# sourceMappingURL=fonts.d.ts.map

package/dist/fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../src/fonts.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC7B,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IAC7C,aAAa,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;IACpH,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAU,YAAY,kBAAkB,kBAe5D,CAAA"}

package/dist/fonts.js

@@ -0,0 +1,17 @@
+export const loadFont = async (properties) => {
+    try {
+        const response = await fetch(properties.src, { credentials: "omit" });
+        const fontData = await response.arrayBuffer();
+        const fontFace = new FontFace(properties["font-family"], fontData, {
+            display: "block",
+            weight: String(properties["font-weight"]),
+            style: properties["font-style"]
+        });
+        await fontFace.load();
+        document.fonts.add(fontFace);
+        console.debug(`font-family: '${fontFace.family}'`);
+    }
+    catch (error) {
+        console.error(error);
+    }
+};

package/dist/frames.d.ts

@@ -0,0 +1,17 @@
+import { Exec, Terminable } from "@opendaw/lib-std";
+export declare namespace AnimationFrame {
+    const add: (exec: Exec) => Terminable;
+    const once: (exec: Exec) => void;
+    const start: () => void;
+    const terminate: () => void;
+}
+export declare const deferNextFrame: (exec: Exec) => DeferExec;
+export declare class DeferExec implements Terminable {
+    #private;
+    constructor(exec: Exec);
+    readonly request: () => void;
+    readonly immediate: () => void;
+    cancel(): void;
+    terminate(): void;
+}
+//# sourceMappingURL=frames.d.ts.map

package/dist/frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frames.d.ts","sourceRoot":"","sources":["../src/frames.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAO,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAEtD,yBAAiB,cAAc,CAAC;IAOrB,MAAM,GAAG,GAAI,MAAM,IAAI,KAAG,UAGhC,CAAA;IAEM,MAAM,IAAI,GAAI,MAAM,IAAI,KAAG,IAAgC,CAAA;IAE3D,MAAM,KAAK,QAAO,IAaxB,CAAA;IAEM,MAAM,SAAS,QAAO,IAM5B,CAAA;CACJ;AAED,eAAO,MAAM,cAAc,GAAI,MAAM,IAAI,KAAG,SAAgC,CAAA;AAE5E,qBAAa,SAAU,YAAW,UAAU;;gBAM5B,IAAI,EAAE,IAAI;IAEtB,QAAQ,CAAC,OAAO,QAAO,IAAI,CAI1B;IAED,QAAQ,CAAC,SAAS,QAAO,IAAI,CAI5B;IAED,MAAM,IAAI,IAAI;IACd,SAAS,IAAI,IAAI;CAOpB"}

package/dist/frames.js

@@ -0,0 +1,63 @@
+export var AnimationFrame;
+(function (AnimationFrame) {
+    const nonrecurring = new Set();
+    const recurring = new Set();
+    const queue = new Array();
+    let id = -1;
+    AnimationFrame.add = (exec) => {
+        recurring.add(exec);
+        return { terminate: () => recurring.delete(exec) };
+    };
+    AnimationFrame.once = (exec) => { nonrecurring.add(exec); };
+    AnimationFrame.start = () => {
+        console.debug("AnimationFrame start");
+        const exe = () => {
+            if (recurring.size > 0 || nonrecurring.size > 0) {
+                recurring.forEach((exec) => queue.push(exec));
+                nonrecurring.forEach((exec) => queue.push(exec));
+                nonrecurring.clear();
+                queue.forEach((exec) => exec());
+                queue.length = 0;
+            }
+            id = requestAnimationFrame(exe);
+        };
+        id = requestAnimationFrame(exe);
+    };
+    AnimationFrame.terminate = () => {
+        console.debug("AnimationFrame terminate");
+        nonrecurring.clear();
+        recurring.clear();
+        queue.length = 0;
+        cancelAnimationFrame(id);
+    };
+})(AnimationFrame || (AnimationFrame = {}));
+export const deferNextFrame = (exec) => new DeferExec(exec);
+export class DeferExec {
+    #exec;
+    #requested = false;
+    #disabled = false;
+    constructor(exec) { this.#exec = exec; }
+    request = () => {
+        if (this.#requested || this.#disabled) {
+            return;
+        }
+        this.#requested = true;
+        AnimationFrame.once(this.#fire);
+    };
+    immediate = () => {
+        if (this.#disabled) {
+            return;
+        }
+        this.#requested = true;
+        this.#fire();
+    };
+    cancel() { this.#requested = false; }
+    terminate() { this.#disabled = true; }
+    #fire = () => {
+        if (this.#disabled || !this.#requested) {
+            return;
+        }
+        this.#requested = false;
+        this.#exec();
+    };
+}

package/dist/html.d.ts

@@ -0,0 +1,21 @@
+import { Color, int, Subscription } from "@opendaw/lib-std";
+export declare namespace Html {
+    const parse: (source: string) => HTMLOrSVGElement & Element;
+    const empty: (element: Element) => void;
+    const replace: (element: Element, ...elements: ReadonlyArray<string | Element>) => void;
+    const query: <E extends Element>(selectors: string, parent?: ParentNode) => E;
+    const queryAll: <E extends Element>(selectors: string, parent?: ParentNode) => ReadonlyArray<E>;
+    const nextID: () => string;
+    const adoptStyleSheet: (classDefinition: string, prefix?: string) => string;
+    const buildClassList: (...input: Array<string | false | undefined>) => string;
+    const readCssVarColor: (...cssValues: Array<string>) => Array<Color.RGBA>;
+    const watchResize: (target: Element, callback: (entry: ResizeObserverEntry, observer: ResizeObserver) => void, options?: ResizeObserverOptions) => Subscription;
+    const watchIntersection: (target: Element, callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => Subscription;
+    const secureBoundingBox: (element: Element) => DOMRect;
+    const unfocus: (owner?: Window) => void;
+    const selectContent: (element: HTMLElement) => void;
+    const unselectContent: (element: HTMLElement) => void;
+    const limitChars: <T extends HTMLElement, K extends keyof T & string>(element: T, property: K, limit: int) => undefined;
+    const EmptyGif: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+}
+//# sourceMappingURL=html.d.ts.map

package/dist/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../src/html.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,EAAE,GAAG,EAA0B,YAAY,EAAC,MAAM,kBAAkB,CAAA;AAEpG,yBAAiB,IAAI,CAAC;IACX,MAAM,KAAK,GAAI,QAAQ,MAAM,KAAG,gBAAgB,GAAG,OAUzD,CAAA;IAEM,MAAM,KAAK,GAAI,SAAS,OAAO,KAAG,IAA2E,CAAA;IAE7G,MAAM,OAAO,GAAI,SAAS,OAAO,EAAE,GAAG,UAAU,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,KAAG,IAGxF,CAAA;IAEM,MAAM,KAAK,GAAI,CAAC,SAAS,OAAO,EAAE,WAAW,MAAM,EAAE,SAAQ,UAAqB,KAAG,CACzC,CAAA;IAE5C,MAAM,QAAQ,GAAI,CAAC,SAAS,OAAO,EAAE,WAAW,MAAM,EAAE,SAAQ,UAAqB,KAAG,aAAa,CAAC,CAAC,CAC5D,CAAA;IAE3C,MAAM,MAAM,QAEJ,MACX,CAAA;IAEG,MAAM,eAAe,GAAI,iBAAiB,MAAM,EAAE,SAAS,MAAM,KAAG,MAU1E,CAAA;IAGM,MAAM,cAAc,GAAI,GAAG,OAAO,KAAK,CAAC,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC,WACX,CAAA;IAExD,MAAM,eAAe,GAAI,GAAG,WAAW,KAAK,CAAC,MAAM,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAS7E,CAAA;IAEM,MAAM,WAAW,GAAI,QAAQ,OAAO,EACf,UAAU,CAAC,KAAK,EAAE,mBAAmB,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,EACxE,UAAU,qBAAqB,KAAG,YAI7D,CAAA;IAEM,MAAM,iBAAiB,GAAI,QAAQ,OAAO,EACf,UAAU,4BAA4B,EACtC,UAAU,wBAAwB,KAAG,YAItE,CAAA;IAGM,MAAM,iBAAiB,GAAI,SAAS,OAAO,KAAG,OASpD,CAAA;IAEM,MAAM,OAAO,GAAI,QAAO,MAAa,SAK3C,CAAA;IAEM,MAAM,aAAa,GAAI,SAAS,WAAW,SAQjD,CAAA;IAEM,MAAM,eAAe,GAAI,SAAS,WAAW,SAMnD,CAAA;IAEM,MAAM,UAAU,GAAI,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,cAkBhH,CAAA;IAEM,MAAM,QAAQ,EAAG,oHAA6H,CAAA;CACxJ"}

package/dist/html.js

@@ -0,0 +1,121 @@
+import { asDefined, assert, Color, isDefined, panic, Rect } from "@opendaw/lib-std";
+export var Html;
+(function (Html) {
+    Html.parse = (source) => {
+        const template = document.createElement("div");
+        template.innerHTML = source;
+        if (template.childElementCount !== 1) {
+            return panic(`Source html has more than one root elements: '${source}'`);
+        }
+        const child = template.firstChild;
+        return child instanceof HTMLElement || child instanceof SVGSVGElement
+            ? child
+            : panic(`Cannot parse to HTMLOrSVGElement from '${source}'`);
+    };
+    Html.empty = (element) => { while (element.firstChild !== null) {
+        element.firstChild.remove();
+    } };
+    Html.replace = (element, ...elements) => {
+        Html.empty(element);
+        element.append(...elements);
+    };
+    Html.query = (selectors, parent = document) => asDefined(parent.querySelector(selectors));
+    Html.queryAll = (selectors, parent = document) => Array.from(parent.querySelectorAll(selectors));
+    Html.nextID = (() => {
+        let id = 0 | 0;
+        return () => (++id).toString(16).padStart(4, "0");
+    })();
+    Html.adoptStyleSheet = (classDefinition, prefix) => {
+        assert(classDefinition.includes("component"), `No 'component' found in: ${classDefinition}`);
+        const className = `${prefix ?? "C"}${Html.nextID()}`;
+        const sheet = new CSSStyleSheet();
+        sheet.replaceSync(classDefinition.replaceAll("component", `.${className}`));
+        if (sheet.cssRules.length === 0) {
+            return panic(`No cssRules found in: ${classDefinition}`);
+        }
+        document.adoptedStyleSheets.push(sheet);
+        return className;
+    };
+    // Allows conditional accumulation of classNames
+    Html.buildClassList = (...input) => input.filter(x => x !== false && x !== undefined).join(" ");
+    Html.readCssVarColor = (...cssValues) => {
+        const element = document.createElement("div");
+        document.body.appendChild(element);
+        const colors = cssValues.map(value => {
+            element.style.color = value;
+            return Color.parseCssRgbOrRgba(getComputedStyle(element).color);
+        });
+        element.remove();
+        return colors;
+    };
+    Html.watchResize = (target, callback, options) => {
+        const observer = new ResizeObserver(([first], observer) => callback(first, observer));
+        observer.observe(target, options);
+        return { terminate: () => observer.disconnect() };
+    };
+    Html.watchIntersection = (target, callback, options) => {
+        const observer = new IntersectionObserver(callback, options);
+        observer.observe(target);
+        return { terminate: () => observer.disconnect() };
+    };
+    // handles cases like 'display: contents', where the bounding box is always empty, although the children have dimensions
+    Html.secureBoundingBox = (element) => {
+        let elemRect = element.getBoundingClientRect();
+        if (!Rect.isEmpty(elemRect)) {
+            return elemRect;
+        }
+        for (const child of element.children) {
+            Rect.union(elemRect, Html.secureBoundingBox(child));
+        }
+        return elemRect;
+    };
+    Html.unfocus = (owner = self) => {
+        const element = owner.document.activeElement;
+        if (element !== null && "blur" in element && typeof element.blur === "function") {
+            element.blur();
+        }
+    };
+    Html.selectContent = (element) => {
+        const range = document.createRange();
+        const selection = window.getSelection();
+        if (isDefined(selection)) {
+            range.selectNodeContents(element);
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+    };
+    Html.unselectContent = (element) => {
+        const selection = window.getSelection();
+        if (!isDefined(selection) || selection.rangeCount === 0) {
+            return;
+        }
+        if (element.contains(selection.getRangeAt(0).commonAncestorContainer)) {
+            selection.removeAllRanges();
+        }
+    };
+    Html.limitChars = (element, property, limit) => {
+        if (!(property in element))
+            return panic(`${property} not found in ${element}`);
+        if (typeof element[property] !== "string")
+            return panic(`${property} in ${element} is not a string`);
+        if (element[property].length > limit) {
+            element[property] = element[property].substring(0, limit);
+            if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+                element.setSelectionRange(limit, limit);
+            }
+            else {
+                const document = element.ownerDocument;
+                const range = document.createRange();
+                const selection = document.defaultView?.getSelection();
+                if (!isDefined(selection)) {
+                    return;
+                }
+                range.selectNodeContents(element);
+                range.collapse(false);
+                selection.removeAllRanges();
+                selection.addRange(range);
+            }
+        }
+    };
+    Html.EmptyGif = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+})(Html || (Html = {}));

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./browser";
+export * from "./compression";
+export * from "./console-commands";
+export * from "./context-2d";
+export * from "./css-utils";
+export * from "./dragging";
+export * from "./events";
+export * from "./errors";
+export * from "./files";
+export * from "./fonts";
+export * from "./frames";
+export * from "./html";
+export * from "./keyboard";
+export * from "./modfier-keys";
+export * from "./stream";
+export * from "./svg";
+export * from "./terminable";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA;AACtB,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,cAAc,OAAO,CAAA;AACrB,cAAc,cAAc,CAAA"}

package/dist/index.js

@@ -0,0 +1,25 @@
+const key = Symbol.for("@openDAW/lib-dom");
+if (globalThis[key]) {
+    console.debug(`%c${key.description}%c is already available in ${globalThis.constructor.name}.`, "color: hsl(10, 83%, 60%)", "color: inherit");
+}
+else {
+    globalThis[key] = true;
+    console.debug(`%c${key.description}%c is now available in ${globalThis.constructor.name}.`, "color: hsl(200, 83%, 60%)", "color: inherit");
+}
+export * from "./browser";
+export * from "./compression";
+export * from "./console-commands";
+export * from "./context-2d";
+export * from "./css-utils";
+export * from "./dragging";
+export * from "./events";
+export * from "./errors";
+export * from "./files";
+export * from "./fonts";
+export * from "./frames";
+export * from "./html";
+export * from "./keyboard";
+export * from "./modfier-keys";
+export * from "./stream";
+export * from "./svg";
+export * from "./terminable";

package/dist/keyboard.d.ts

@@ -0,0 +1,15 @@
+export declare namespace Keyboard {
+    const isControlKey: ({ ctrlKey, metaKey }: {
+        ctrlKey: boolean;
+        metaKey: boolean;
+    }) => boolean;
+    const isCopyKey: ({ altKey }: {
+        altKey: boolean;
+    }) => boolean;
+    const GlobalShortcut: Readonly<{
+        isDelete: (event: KeyboardEvent) => boolean;
+        isSelectAll: (event: KeyboardEvent) => boolean;
+        isDeselectAll: (event: KeyboardEvent) => boolean;
+    }>;
+}
+//# sourceMappingURL=keyboard.d.ts.map

package/dist/keyboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.d.ts","sourceRoot":"","sources":["../src/keyboard.ts"],"names":[],"mappings":"AAGA,yBAAiB,QAAQ,CAAC;IACf,MAAM,YAAY,GAAI,sBAAoB;QAC7C,OAAO,EAAE,OAAO,CAAC;QACjB,OAAO,EAAE,OAAO,CAAA;KACnB,YAA0C,CAAA;IAEpC,MAAM,SAAS,GAAI,YAAU;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,YAAW,CAAA;IAE3D,MAAM,cAAc;0BACL,aAAa;6BACV,aAAa;+BACX,aAAa;MACtC,CAAA;CACL"}

package/dist/keyboard.js

@@ -0,0 +1,12 @@
+import { Browser } from "./browser";
+import { Events } from "./events";
+export var Keyboard;
+(function (Keyboard) {
+    Keyboard.isControlKey = ({ ctrlKey, metaKey }) => Browser.isMacOS() ? metaKey : ctrlKey;
+    Keyboard.isCopyKey = ({ altKey }) => altKey;
+    Keyboard.GlobalShortcut = Object.freeze({
+        isDelete: (event) => !Events.isTextInput(event.target) && (event.code === "Delete" || event.code === "Backspace"),
+        isSelectAll: (event) => Keyboard.isControlKey(event) && !event.shiftKey && event.code === "KeyA",
+        isDeselectAll: (event) => Keyboard.isControlKey(event) && event.shiftKey && event.code === "KeyA"
+    });
+})(Keyboard || (Keyboard = {}));

package/dist/modfier-keys.d.ts

@@ -0,0 +1,18 @@
+export declare const ModfierKeys: Readonly<{
+    Mac: {
+        Cmd: string;
+        Opt: string;
+        Shift: string;
+    };
+    Win: {
+        Cmd: string;
+        Opt: string;
+        Shift: string;
+    };
+    System: {
+        Cmd: string;
+        Opt: string;
+        Shift: string;
+    };
+}>;
+//# sourceMappingURL=modfier-keys.d.ts.map

package/dist/modfier-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modfier-keys.d.ts","sourceRoot":"","sources":["../src/modfier-keys.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;EAIpB,CAAA"}

package/dist/modfier-keys.js

@@ -0,0 +1,6 @@
+import { Browser } from "./browser";
+export const ModfierKeys = (() => {
+    const Mac = { Cmd: "⌘", Opt: "⌥", Shift: "⇧" };
+    const Win = { Cmd: "Ctrl", Opt: "Alt", Shift: "⇧" };
+    return Object.freeze({ Mac, Win, System: Browser.isMacOS() ? Mac : Win });
+})();

package/dist/stream.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Stream {
+    const read: (reader: ReadableStreamDefaultReader<Uint8Array>) => Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAEA,yBAAiB,MAAM,CAAC;IACb,MAAM,IAAI,GAAU,QAAQ,2BAA2B,CAAC,UAAU,CAAC,KAAG,OAAO,CAAC,WAAW,CAe/F,CAAA;CACJ"}

package/dist/stream.js

@@ -0,0 +1,21 @@
+export var Stream;
+(function (Stream) {
+    Stream.read = async (reader) => {
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            chunks.push(value);
+        }
+        const length = chunks.reduce((acc, val) => acc + val.length, 0);
+        const output = new Uint8Array(length);
+        let position = 0 | 0;
+        for (let chunk of chunks) {
+            output.set(chunk, position);
+            position += chunk.length;
+        }
+        return output.buffer;
+    };
+})(Stream || (Stream = {}));

package/dist/svg.d.ts

@@ -0,0 +1,15 @@
+export declare namespace Svg {
+    interface PathBuilder {
+        moveTo(x: number, y: number): this;
+        lineTo(x: number, y: number): this;
+        quadratic(x1: number, y1: number, x: number, y: number): this;
+        quadraticTo(x: number, y: number): this;
+        cubic(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this;
+        arc(rx: number, ry: number, deg: number, largeArc: boolean, sweep: boolean, x: number, y: number): this;
+        circleSegment(cx: number, cy: number, radius: number, a0: number, a1: number): this;
+        close(): this;
+        get(): string;
+    }
+    const pathBuilder: () => PathBuilder;
+}
+//# sourceMappingURL=svg.d.ts.map

package/dist/svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../src/svg.ts"],"names":[],"mappings":"AAAA,yBAAiB,GAAG,CAAC;IACjB,UAAiB,WAAW;QACxB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAClC,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC7D,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACvC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACjF,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QACvG,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;QACnF,KAAK,IAAI,IAAI,CAAA;QACb,GAAG,IAAI,MAAM,CAAA;KAChB;IAEM,MAAM,WAAW,QAAO,WAkD9B,CAAA;CACJ"}

package/dist/svg.js

@@ -0,0 +1,45 @@
+export var Svg;
+(function (Svg) {
+    Svg.pathBuilder = () => new class {
+        #d = "";
+        moveTo(x, y) {
+            this.#d += `M${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        lineTo(x, y) {
+            this.#d += `L${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        quadratic(x1, y1, x, y) {
+            this.#d += `Q${x1.toFixed(3)} ${y1.toFixed(3)} ${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        quadraticTo(x, y) {
+            this.#d += `T${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        cubic(x1, y1, x2, y2, x, y) {
+            this.#d += `Q${x1.toFixed(3)} ${y1.toFixed(3)} ${x2.toFixed(3)} ${y2.toFixed(3)} ${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        arc(rx, ry, deg, largeArc, sweep, x, y) {
+            this.#d += `A${rx} ${ry} ${deg} ${largeArc ? 1 : 0} ${sweep ? 1 : 0} ${x.toFixed(3)} ${y.toFixed(3)}`;
+            return this;
+        }
+        circleSegment(cx, cy, radius, a0, a1) {
+            const x0 = cx + Math.cos(a0) * radius;
+            const y0 = cy + Math.sin(a0) * radius;
+            const x1 = cx + Math.cos(a1) * radius;
+            const y1 = cy + Math.sin(a1) * radius;
+            let range = a1 - a0;
+            while (range < 0.0)
+                range += Math.PI * 2.0;
+            return this.moveTo(x0, y0).arc(radius, radius, 0, range > Math.PI, true, x1, y1);
+        }
+        close() {
+            this.#d += "Z";
+            return this;
+        }
+        get() { return this.#d; }
+    };
+})(Svg || (Svg = {}));

package/dist/terminable.d.ts

@@ -0,0 +1,13 @@
+import { Func, Terminable } from "@opendaw/lib-std";
+export declare namespace TerminatorUtils {
+    /**
+     * Terminates if the key is no longer referenced to.
+     * Make sure that the Terminable does not include other references
+     * that would prevent the key from being gc collected.
+     * That means the key must not appear in the Terminable!
+     * @param key WeakKey
+     * @param subscribe Sends a WeakRef to be able to be gc collected
+     */
+    const watchWeak: <K extends WeakKey>(key: K, subscribe: Func<WeakRef<K>, Terminable>) => K;
+}
+//# sourceMappingURL=terminable.d.ts.map

package/dist/terminable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminable.d.ts","sourceRoot":"","sources":["../src/terminable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAEjD,yBAAiB,eAAe,CAAC;IAE7B;;;;;;;OAOG;IACI,MAAM,SAAS,GAAI,CAAC,SAAS,OAAO,EAAE,KAAK,CAAC,EAAE,WAAW,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,KAAG,CAQ9F,CAAA;CAmBJ"}

package/dist/terminable.js

@@ -0,0 +1,38 @@
+export var TerminatorUtils;
+(function (TerminatorUtils) {
+    const weakRefs = new Array();
+    /**
+     * Terminates if the key is no longer referenced to.
+     * Make sure that the Terminable does not include other references
+     * that would prevent the key from being gc collected.
+     * That means the key must not appear in the Terminable!
+     * @param key WeakKey
+     * @param subscribe Sends a WeakRef to be able to be gc collected
+     */
+    TerminatorUtils.watchWeak = (key, subscribe) => {
+        const weakRef = new WeakRef(key);
+        const terminable = subscribe(weakRef);
+        weakRefs.push([weakRef, terminable]);
+        if (weakRefs.length === 1) {
+            startWatchWeak();
+        }
+        return key;
+    };
+    const startWatchWeak = () => {
+        console.debug("start weak watching");
+        const id = setInterval(() => {
+            let index = weakRefs.length;
+            while (--index >= 0) {
+                const entry = weakRefs[index];
+                if (entry[0].deref() === undefined) {
+                    entry[1].terminate();
+                    weakRefs.splice(index, 1);
+                    if (weakRefs.length === 0) {
+                        console.debug("stop weak watching");
+                        clearInterval(id);
+                    }
+                }
+            }
+        }, 1000);
+    };
+})(TerminatorUtils || (TerminatorUtils = {}));

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@opendaw/lib-dom",
+  "version": "0.0.6",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "LGPL-3.0-or-later",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint \"**/*.ts\"",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@opendaw/lib-runtime": "^0.0.6",
+    "@opendaw/lib-std": "^0.0.6",
+    "@types/wicg-file-system-access": "^2023.10.6"
+  },
+  "devDependencies": {
+    "@opendaw/eslint-config": "^0.0.6",
+    "@opendaw/typescript-config": "^0.0.6"
+  },
+  "gitHead": "04e5363a9851c7e116a306c2e933c5f410980fbe"
+}