@opendaw/lib-fusion 0.0.6

package/README.md

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

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import './types';
+export * from "./live-stream/LiveStreamReceiver";
+export * from "./live-stream/LiveStreamBroadcaster";
+export * from "./peaks/Peaks";
+export * from "./peaks/PeakWorker";
+export * from "./peaks/PeakProtocol";
+export * from "./peaks/PeaksPainter";
+export * from "./opfs/OpfsWorker";
+export * from "./opfs/OpfsProtocol";
+//# 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,OAAO,SAAS,CAAA;AAEhB,cAAc,kCAAkC,CAAA;AAChD,cAAc,qCAAqC,CAAA;AACnD,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+const key = Symbol.for("@openDAW/lib-fusion");
+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");
+}
+import './types';
+export * from "./live-stream/LiveStreamReceiver";
+export * from "./live-stream/LiveStreamBroadcaster";
+export * from "./peaks/Peaks";
+export * from "./peaks/PeakWorker";
+export * from "./peaks/PeakProtocol";
+export * from "./peaks/PeaksPainter";
+export * from "./opfs/OpfsWorker";
+export * from "./opfs/OpfsProtocol";

package/dist/live-stream/Flags.d.ts

@@ -0,0 +1,6 @@
+export declare const enum Flags {
+    ID = 15793935,
+    START = 15790320,
+    END = 986895
+}
+//# sourceMappingURL=Flags.d.ts.map

package/dist/live-stream/Flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flags.d.ts","sourceRoot":"","sources":["../../src/live-stream/Flags.ts"],"names":[],"mappings":"AAAA,0BAAkB,KAAK;IACnB,EAAE,WAAW;IAAE,KAAK,WAAW;IAAE,GAAG,SAAW;CAClD"}

package/dist/live-stream/Flags.js

@@ -0,0 +1,6 @@
+export var Flags;
+(function (Flags) {
+    Flags[Flags["ID"] = 15793935] = "ID";
+    Flags[Flags["START"] = 15790320] = "START";
+    Flags[Flags["END"] = 986895] = "END";
+})(Flags || (Flags = {}));

package/dist/live-stream/LiveStreamBroadcaster.d.ts

@@ -0,0 +1,16 @@
+import { Exec, float, int, Provider, Terminable } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+import { Messenger } from "@opendaw/lib-runtime";
+export declare class LiveStreamBroadcaster {
+    #private;
+    static create(messenger: Messenger, name: string): LiveStreamBroadcaster;
+    private constructor();
+    flush(): void;
+    broadcastFloat(address: Address, provider: Provider<float>): Terminable;
+    broadcastInteger(address: Address, provider: Provider<int>): Terminable;
+    broadcastFloats(address: Address, values: Float32Array, update: Exec): Terminable;
+    broadcastIntegers(address: Address, values: Int32Array, update: Exec): Terminable;
+    broadcastByteArray(address: Address, values: Int8Array, update: Exec): Terminable;
+    terminate(): void;
+}
+//# sourceMappingURL=LiveStreamBroadcaster.d.ts.map

package/dist/live-stream/LiveStreamBroadcaster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveStreamBroadcaster.d.ts","sourceRoot":"","sources":["../../src/live-stream/LiveStreamBroadcaster.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,IAAI,EACJ,KAAK,EACL,GAAG,EAGH,QAAQ,EACR,UAAU,EACb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAC,MAAM,kBAAkB,CAAA;AACxC,OAAO,EAAe,SAAS,EAAC,MAAM,sBAAsB,CAAA;AAa5D,qBAAa,qBAAqB;;IAC9B,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,qBAAqB;IAkBxE,OAAO;IASP,KAAK,IAAI,IAAI;IA2Bb,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,UAAU;IASvE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,GAAG,UAAU;IASvE,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,GAAG,UAAU;IAajF,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,GAAG,UAAU;IAajF,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,GAAG,UAAU;IAmCjF,SAAS,IAAI,IAAI;CAgDpB"}

package/dist/live-stream/LiveStreamBroadcaster.js

@@ -0,0 +1,180 @@
+import { Arrays, assert, ByteArrayOutput, nextPowOf2, Option } from "@opendaw/lib-std";
+import { Communicator } from "@opendaw/lib-runtime";
+import { Lock } from "./Lock";
+import { PackageType } from "./PackageType";
+import { Flags } from "./Flags";
+export class LiveStreamBroadcaster {
+    static create(messenger, name) {
+        return new LiveStreamBroadcaster(messenger.channel(name));
+    }
+    #packages = [];
+    #lock = new SharedArrayBuffer(1);
+    #lockArray = new Int8Array(this.#lock);
+    #sender;
+    #output = ByteArrayOutput.create(0);
+    #sabOption = Option.None;
+    #availableUpdate = Option.None;
+    #version = -1;
+    #capacity = -1;
+    #invalid = false;
+    #lockShared = false;
+    constructor(messenger) {
+        this.#sender = Communicator.sender(messenger, ({ dispatchAndForget }) => new class {
+            sendShareLock(lock) { dispatchAndForget(this.sendShareLock, lock); }
+            sendUpdateData(buffer) { dispatchAndForget(this.sendUpdateData, buffer); }
+            sendUpdateStructure(buffer) { dispatchAndForget(this.sendUpdateStructure, buffer); }
+        });
+    }
+    flush() {
+        const update = this.#updateAvailable();
+        if (update.nonEmpty()) {
+            if (!this.#lockShared) {
+                this.#sender.sendShareLock(this.#lock);
+                this.#lockShared = true;
+            }
+            this.#sender.sendUpdateStructure(update.unwrap());
+            let capacity = this.#computeCapacity();
+            if (this.#output.remaining < capacity) {
+                const size = nextPowOf2(capacity);
+                const data = new SharedArrayBuffer(size);
+                this.#output = ByteArrayOutput.use(data);
+                this.#sabOption = Option.wrap(data);
+                this.#sender.sendUpdateData(data);
+            }
+        }
+        if (this.#sabOption.isEmpty()) {
+            return;
+        }
+        // If main-thread is not interested, no data will ever be sent again, since it will not set the lock to CAN_WRITE.
+        // No lock is necessary since the other side skips reading until we set the lock to CAN_READ.
+        if (Atomics.load(this.#lockArray, 0) === Lock.WRITE) {
+            this.#flushData(this.#output);
+            this.#output.position = 0;
+            Atomics.store(this.#lockArray, 0, Lock.READ);
+        }
+    }
+    broadcastFloat(address, provider) {
+        return this.#storeChunk(new class {
+            type = PackageType.Float;
+            address = address;
+            capacity = 8;
+            put(output) { output.writeFloat(provider()); }
+        });
+    }
+    broadcastInteger(address, provider) {
+        return this.#storeChunk(new class {
+            type = PackageType.Integer;
+            address = address;
+            capacity = 8;
+            put(output) { output.writeInt(provider()); }
+        });
+    }
+    broadcastFloats(address, values, update) {
+        return this.#storeChunk(new class {
+            type = PackageType.FloatArray;
+            address = address;
+            capacity = 4 + (values.byteLength << 2);
+            put(output) {
+                update();
+                output.writeInt(values.length);
+                for (const value of values) {
+                    output.writeFloat(value);
+                }
+            }
+        });
+    }
+    broadcastIntegers(address, values, update) {
+        return this.#storeChunk(new class {
+            type = PackageType.IntegerArray;
+            address = address;
+            capacity = 4 + (values.byteLength << 2);
+            put(output) {
+                update();
+                output.writeInt(values.length);
+                for (const value of values) {
+                    output.writeInt(value);
+                }
+            }
+        });
+    }
+    broadcastByteArray(address, values, update) {
+        return this.#storeChunk(new class {
+            type = PackageType.ByteArray;
+            address = address;
+            capacity = 4 + values.byteLength;
+            put(output) {
+                update();
+                output.writeInt(values.byteLength);
+                output.writeBytes(values);
+            }
+        });
+    }
+    #updateAvailable() {
+        if (this.#invalid) {
+            try {
+                this.#availableUpdate = Option.wrap(this.#compileStructure());
+            }
+            catch (reason) {
+                throw reason;
+            }
+            this.#invalid = false;
+        }
+        if (this.#availableUpdate.nonEmpty()) {
+            const option = this.#availableUpdate;
+            this.#availableUpdate = Option.None;
+            return option;
+        }
+        return Option.None;
+    }
+    #computeCapacity() {
+        if (-1 === this.#capacity) {
+            this.#capacity = this.#sumRequiredCapacity() + 12;
+        }
+        return this.#capacity;
+    }
+    terminate() {
+        Arrays.clear(this.#packages);
+        this.#availableUpdate = Option.None;
+        this.#invalid = false;
+        this.#capacity = 0;
+    }
+    #flushData(output) {
+        assert(!this.#invalid && this.#availableUpdate.isEmpty(), "Cannot flush while update is available");
+        let requiredCapacity = this.#computeCapacity();
+        assert(output.remaining >= requiredCapacity, "Insufficient data");
+        output.writeInt(this.#version);
+        output.writeInt(Flags.START);
+        for (const pack of this.#packages) {
+            pack.put(output);
+        }
+        output.writeInt(Flags.END);
+    }
+    #sumRequiredCapacity() {
+        return this.#packages.reduce((sum, pack) => sum + pack.capacity, 0);
+    }
+    #storeChunk(pack) {
+        this.#packages.push(pack);
+        this.#invalidate();
+        return {
+            terminate: () => {
+                Arrays.removeOpt(this.#packages, pack);
+                this.#invalidate();
+            }
+        };
+    }
+    #invalidate() {
+        this.#capacity = -1;
+        this.#invalid = true;
+    }
+    #compileStructure() {
+        const output = ByteArrayOutput.create();
+        output.writeInt(Flags.ID);
+        output.writeInt(++this.#version);
+        output.writeInt(this.#packages.length);
+        for (const { address, type } of this.#packages) {
+            address.write(output);
+            output.writeByte(type);
+        }
+        return output.toArrayBuffer();
+    }
+}

package/dist/live-stream/LiveStreamReceiver.d.ts

@@ -0,0 +1,16 @@
+import { float, int, Procedure, Subscription, Terminable } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+import { Messenger } from "@opendaw/lib-runtime";
+export declare class LiveStreamReceiver implements Terminable {
+    #private;
+    static ID: int;
+    constructor();
+    connect(messenger: Messenger): Terminable;
+    subscribeFloat(address: Address, procedure: Procedure<int>): Subscription;
+    subscribeInteger(address: Address, procedure: Procedure<float>): Subscription;
+    subscribeFloats(address: Address, procedure: Procedure<Float32Array>): Subscription;
+    subscribeIntegers(address: Address, procedure: Procedure<Int32Array>): Subscription;
+    subscribeByteArray(address: Address, procedure: Procedure<Int8Array>): Subscription;
+    terminate(): void;
+}
+//# sourceMappingURL=LiveStreamReceiver.d.ts.map

package/dist/live-stream/LiveStreamReceiver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveStreamReceiver.d.ts","sourceRoot":"","sources":["../../src/live-stream/LiveStreamReceiver.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,KAAK,EACL,GAAG,EAIH,SAAS,EAET,YAAY,EACZ,UAAU,EACb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAC,OAAO,EAAC,MAAM,kBAAkB,CAAA;AAExC,OAAO,EAAe,SAAS,EAAC,MAAM,sBAAsB,CAAA;AAmG5D,qBAAa,kBAAmB,YAAW,UAAU;;IACjD,MAAM,CAAC,EAAE,EAAE,GAAG,CAAQ;;IA0BtB,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,UAAU;IA2BzC,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,YAAY;IAIzE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,KAAK,CAAC,GAAG,YAAY;IAI7E,eAAe,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,YAAY,CAAC,GAAG,YAAY;IAInF,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,YAAY;IAInF,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,GAAG,YAAY;IAInF,SAAS,IAAI,IAAI;CA4CpB"}

package/dist/live-stream/LiveStreamReceiver.js

@@ -0,0 +1,191 @@
+import { Arrays, assert, ByteArrayInput, isDefined, Option, panic, Terminable } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+import { AnimationFrame } from "@opendaw/lib-dom";
+import { Communicator } from "@opendaw/lib-runtime";
+import { PackageType } from "./PackageType";
+import { Subscribers } from "./Subscribers";
+import { Lock } from "./Lock";
+import { Flags } from "./Flags";
+class FloatPackage {
+    subscribers = new Subscribers();
+    dispatch(address, input) {
+        const value = input.readFloat();
+        this.subscribers.getOrNull(address)?.forEach(procedure => procedure(value));
+    }
+    subscribe(address, procedure) {
+        return this.subscribers.subscribe(address, procedure);
+    }
+    terminate() { this.subscribers.terminate(); }
+}
+class IntegerPackage {
+    subscribers = new Subscribers();
+    dispatch(address, input) {
+        const value = input.readInt();
+        this.subscribers.getOrNull(address)?.forEach(procedure => procedure(value));
+    }
+    subscribe(address, procedure) {
+        return this.subscribers.subscribe(address, procedure);
+    }
+    terminate() { this.subscribers.terminate(); }
+}
+class ArrayPackage {
+    subscribers = new Subscribers();
+    #arrays = Address.newSet(entry => entry.address);
+    dispatch(address, input) {
+        const length = input.readInt();
+        const entry = this.#arrays.getOrNull(address);
+        let array;
+        if (isDefined(entry)) {
+            array = entry.array;
+        }
+        else {
+            array = this.create(length);
+            this.#arrays.add({ address, array });
+        }
+        this.read(input, array, length);
+        this.subscribers.getOrNull(address)?.forEach(procedure => procedure(array));
+    }
+    subscribe(address, procedure) {
+        const subscription = this.subscribers.subscribe(address, procedure);
+        return {
+            terminate: () => {
+                subscription.terminate();
+                if (this.subscribers.isEmpty(address) && this.#arrays.hasKey(address)) {
+                    this.#arrays.removeByKey(address);
+                }
+            }
+        };
+    }
+    terminate() { this.subscribers.terminate(); }
+}
+class FloatArrayPackage extends ArrayPackage {
+    create(length) { return new Float32Array(length); }
+    read(input, array, length) {
+        for (let i = 0; i < length; i++) {
+            array[i] = input.readFloat();
+        }
+    }
+}
+class IntegerArrayPackage extends ArrayPackage {
+    create(length) { return new Int32Array(length); }
+    read(input, array, length) {
+        for (let i = 0; i < length; i++) {
+            array[i] = input.readInt();
+        }
+    }
+}
+class ByteArrayPackage extends ArrayPackage {
+    create(length) { return new Int8Array(length); }
+    read(input, array, _length) {
+        input.readBytes(array);
+    }
+}
+export class LiveStreamReceiver {
+    static ID = 0 | 0;
+    #float = new FloatPackage();
+    #integer = new IntegerPackage();
+    #floats = new FloatArrayPackage();
+    #integers = new IntegerArrayPackage();
+    #bytes = new ByteArrayPackage();
+    #packages = [];
+    #procedures = [];
+    #id;
+    #optLock = Option.None;
+    #memory = Option.None;
+    #structureVersion = -1;
+    #connected = false;
+    constructor() {
+        this.#id = LiveStreamReceiver.ID++;
+        this.#packages[PackageType.Float] = this.#float;
+        this.#packages[PackageType.FloatArray] = this.#floats;
+        this.#packages[PackageType.Integer] = this.#integer;
+        this.#packages[PackageType.IntegerArray] = this.#integers;
+        this.#packages[PackageType.ByteArray] = this.#bytes;
+    }
+    connect(messenger) {
+        assert(!this.#connected, "Already connected");
+        this.#connected = true;
+        return Terminable.many({ terminate: () => { this.#disconnect(); } }, Communicator.executor(messenger, {
+            sendShareLock: (lock) => this.#optLock = Option.wrap(new Int8Array(lock)),
+            sendUpdateData: (data) => this.#memory = Option.wrap(new ByteArrayInput(data)),
+            sendUpdateStructure: (structure) => this.#updateStructure(new ByteArrayInput(structure))
+        }), AnimationFrame.add(() => this.#dispatch()));
+    }
+    #disconnect() {
+        this.#memory = Option.None;
+        this.#optLock = Option.None;
+        this.#structureVersion = -1;
+        this.#connected = false;
+        Arrays.clear(this.#procedures);
+        this.#float.terminate();
+        this.#floats.terminate();
+        this.#integer.terminate();
+        this.#integers.terminate();
+        this.#bytes.terminate();
+    }
+    subscribeFloat(address, procedure) {
+        return this.#float.subscribe(address, procedure);
+    }
+    subscribeInteger(address, procedure) {
+        return this.#integer.subscribe(address, procedure);
+    }
+    subscribeFloats(address, procedure) {
+        return this.#floats.subscribe(address, procedure);
+    }
+    subscribeIntegers(address, procedure) {
+        return this.#integers.subscribe(address, procedure);
+    }
+    subscribeByteArray(address, procedure) {
+        return this.#bytes.subscribe(address, procedure);
+    }
+    terminate() { this.#disconnect(); }
+    #dispatch() {
+        if (this.#optLock.isEmpty() || this.#memory.isEmpty()) {
+            return;
+        }
+        const lock = this.#optLock.unwrap();
+        if (Atomics.load(lock, 0) === Lock.READ) {
+            const byteArrayInput = this.#memory.unwrap();
+            this.#dispatchData(byteArrayInput);
+            byteArrayInput.position = 0;
+            Atomics.store(lock, 0, Lock.WRITE);
+        }
+    }
+    #updateStructure(input) {
+        Arrays.clear(this.#procedures);
+        this.#parseStructure(input);
+    }
+    #dispatchData(input) {
+        let version = input.readInt();
+        if (version !== this.#structureVersion) {
+            // we simply skip and await the latest version soon enough
+            return false;
+        }
+        if (input.readInt() !== Flags.START) {
+            throw new Error("stream is broken (no start flag)");
+        }
+        for (const procedure of this.#procedures) {
+            procedure(input);
+        }
+        if (input.readInt() !== Flags.END) {
+            throw new Error("stream is broken (no end flag)");
+        }
+        return true;
+    }
+    #parseStructure(input) {
+        if (input.readInt() !== Flags.ID) {
+            throw new Error("no valid id");
+        }
+        const version = input.readInt();
+        if (version <= this.#structureVersion) {
+            return panic("Invalid version. new: " + version + `, was: ${this.#structureVersion}, id: ${this.#id}`);
+        }
+        this.#structureVersion = version;
+        const n = input.readInt();
+        for (let i = 0; i < n; i++) {
+            const address = Address.read(input);
+            const chunk = this.#packages[input.readByte()];
+            this.#procedures.push(input => chunk.dispatch(address, input));
+        }
+    }
+}

package/dist/live-stream/Lock.d.ts

@@ -0,0 +1,5 @@
+export declare enum Lock {
+    WRITE = 0,
+    READ = 1
+}
+//# sourceMappingURL=Lock.d.ts.map

package/dist/live-stream/Lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lock.d.ts","sourceRoot":"","sources":["../../src/live-stream/Lock.ts"],"names":[],"mappings":"AAAA,oBAAY,IAAI;IAAE,KAAK,IAAI;IAAE,IAAI,IAAI;CAAC"}

package/dist/live-stream/Lock.js

@@ -0,0 +1,5 @@
+export var Lock;
+(function (Lock) {
+    Lock[Lock["WRITE"] = 0] = "WRITE";
+    Lock[Lock["READ"] = 1] = "READ";
+})(Lock || (Lock = {}));

package/dist/live-stream/PackageType.d.ts

@@ -0,0 +1,8 @@
+export declare enum PackageType {
+    Float = 0,
+    FloatArray = 1,
+    Integer = 2,
+    IntegerArray = 3,
+    ByteArray = 4
+}
+//# sourceMappingURL=PackageType.d.ts.map

package/dist/live-stream/PackageType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackageType.d.ts","sourceRoot":"","sources":["../../src/live-stream/PackageType.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IAAE,KAAK,IAAA;IAAE,UAAU,IAAA;IAAE,OAAO,IAAA;IAAE,YAAY,IAAA;IAAE,SAAS,IAAA;CAAC"}

package/dist/live-stream/PackageType.js

@@ -0,0 +1,8 @@
+export var PackageType;
+(function (PackageType) {
+    PackageType[PackageType["Float"] = 0] = "Float";
+    PackageType[PackageType["FloatArray"] = 1] = "FloatArray";
+    PackageType[PackageType["Integer"] = 2] = "Integer";
+    PackageType[PackageType["IntegerArray"] = 3] = "IntegerArray";
+    PackageType[PackageType["ByteArray"] = 4] = "ByteArray";
+})(PackageType || (PackageType = {}));

package/dist/live-stream/Protocol.d.ts

@@ -0,0 +1,6 @@
+export interface Protocol {
+    sendShareLock(lock: SharedArrayBuffer): void;
+    sendUpdateData(data: ArrayBufferLike): void;
+    sendUpdateStructure(structure: ArrayBufferLike): void;
+}
+//# sourceMappingURL=Protocol.d.ts.map

package/dist/live-stream/Protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Protocol.d.ts","sourceRoot":"","sources":["../../src/live-stream/Protocol.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACrB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAC5C,cAAc,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAAA;IAC3C,mBAAmB,CAAC,SAAS,EAAE,eAAe,GAAG,IAAI,CAAA;CACxD"}

package/dist/live-stream/Protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/live-stream/Subscribers.d.ts

@@ -0,0 +1,11 @@
+import { Nullish, Subscription, Terminable } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+export declare class Subscribers<T> implements Terminable {
+    #private;
+    constructor();
+    getOrNull(address: Address): Nullish<ReadonlyArray<T>>;
+    isEmpty(address: Address): boolean;
+    subscribe(address: Address, listener: T): Subscription;
+    terminate(): void;
+}
+//# sourceMappingURL=Subscribers.d.ts.map

package/dist/live-stream/Subscribers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Subscribers.d.ts","sourceRoot":"","sources":["../../src/live-stream/Subscribers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,OAAO,EAAa,YAAY,EAAE,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAChG,OAAO,EAAC,OAAO,EAAC,MAAM,kBAAkB,CAAA;AAIxC,qBAAa,WAAW,CAAC,CAAC,CAAE,YAAW,UAAU;;;IAK7C,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAEtD,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAElC,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY;IAmBtD,SAAS,IAAI,IAAI;CACpB"}

package/dist/live-stream/Subscribers.js

@@ -0,0 +1,28 @@
+import { Arrays, isDefined } from "@opendaw/lib-std";
+import { Address } from "@opendaw/lib-box";
+export class Subscribers {
+    #subscribers;
+    constructor() { this.#subscribers = Address.newSet(entry => entry.address); }
+    getOrNull(address) { return this.#subscribers.getOrNull(address)?.listeners; }
+    isEmpty(address) { return !this.#subscribers.hasKey(address); }
+    subscribe(address, listener) {
+        const entry = this.#subscribers.getOrNull(address);
+        if (isDefined(entry)) {
+            entry.listeners.push(listener);
+        }
+        else {
+            this.#subscribers.add({ address, listeners: [listener] });
+        }
+        return {
+            terminate: () => {
+                this.#subscribers.opt(address).ifSome(entry => {
+                    Arrays.remove(entry.listeners, listener);
+                    if (entry.listeners.length === 0) {
+                        this.#subscribers.removeByKey(address);
+                    }
+                });
+            }
+        };
+    }
+    terminate() { this.#subscribers.clear(); }
+}

package/dist/opfs/OpfsProtocol.d.ts

@@ -0,0 +1,12 @@
+export type Kind = "file" | "directory";
+export type Entry = {
+    name: string;
+    kind: Kind;
+};
+export interface OpfsProtocol {
+    write(path: string, data: Uint8Array): Promise<void>;
+    read(path: string): Promise<Uint8Array>;
+    delete(path: string): Promise<void>;
+    list(path: string): Promise<ReadonlyArray<Entry>>;
+}
+//# sourceMappingURL=OpfsProtocol.d.ts.map

package/dist/opfs/OpfsProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpfsProtocol.d.ts","sourceRoot":"","sources":["../../src/opfs/OpfsProtocol.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,WAAW,CAAA;AACvC,MAAM,MAAM,KAAK,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,CAAA;AAEhD,MAAM,WAAW,YAAY;IACzB,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;IACvC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAA;CACpD"}

package/dist/opfs/OpfsProtocol.js

@@ -0,0 +1 @@
+export {};

package/dist/opfs/OpfsWorker.d.ts

@@ -0,0 +1,14 @@
+import { Communicator, Messenger } from "@opendaw/lib-runtime";
+import { Entry } from "./OpfsProtocol";
+import "../types";
+export declare namespace OpfsWorker {
+    const init: (messenger: Messenger) => Communicator.Executor<{
+        write(path: string, data: Uint8Array): Promise<void>;
+        read(path: string): Promise<Uint8Array>;
+        delete(path: string): Promise<void>;
+        list(path: string): Promise<ReadonlyArray<Entry>>;
+        "__#49@#resolveFile"(path: string, options?: FileSystemGetDirectoryOptions): Promise<FileSystemSyncAccessHandle>;
+        "__#49@#resolveFolder"(segments: ReadonlyArray<string>, options?: FileSystemGetDirectoryOptions): Promise<FileSystemDirectoryHandle>;
+    }>;
+}
+//# sourceMappingURL=OpfsWorker.d.ts.map

package/dist/opfs/OpfsWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpfsWorker.d.ts","sourceRoot":"","sources":["../../src/opfs/OpfsWorker.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,YAAY,EAAE,SAAS,EAAW,MAAM,sBAAsB,CAAA;AACtE,OAAO,EAAC,KAAK,EAAe,MAAM,gBAAgB,CAAA;AAClD,OAAO,UAAU,CAAA;AAEjB,yBAAiB,UAAU,CAAC;IAKjB,MAAM,IAAI,GAAI,WAAW,SAAS;oBAEf,MAAM,QAAQ,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;mBAWzC,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;qBAY1B,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;mBAMxB,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;mCAW9B,MAAM,YAAY,6BAA6B,GAAG,OAAO,CAAC,0BAA0B,CAAC;yCAO/E,aAAa,CAAC,MAAM,CAAC,YACrB,6BAA6B,GAAG,OAAO,CAAC,yBAAyB,CAAC;MAKnG,CAAA;CAMT"}

package/dist/opfs/OpfsWorker.js

@@ -0,0 +1,70 @@
+import { Arrays, asDefined } from "@opendaw/lib-std";
+import { Communicator, Promises } from "@opendaw/lib-runtime";
+import "../types";
+export var OpfsWorker;
+(function (OpfsWorker) {
+    const DEBUG = false;
+    const readLimiter = new Promises.Limit(1);
+    const writeLimiter = new Promises.Limit(1);
+    OpfsWorker.init = (messenger) => Communicator.executor(messenger.channel("opfs"), new class {
+        async write(path, data) {
+            if (DEBUG) {
+                console.debug(`write ${data.length}b to ${path}`);
+            }
+            return writeLimiter.add(() => this.#resolveFile(path, { create: true })
+                .then(handle => {
+                handle.truncate(data.length);
+                handle.write(data, { at: 0 });
+                handle.flush();
+                handle.close();
+            }));
+        }
+        async read(path) {
+            if (DEBUG) {
+                console.debug(`read ${path}`);
+            }
+            return readLimiter.add(() => this.#resolveFile(path)
+                .then(handle => {
+                const size = handle.getSize();
+                const buffer = new Uint8Array(size);
+                handle.read(buffer);
+                handle.close();
+                return buffer;
+            }));
+        }
+        async delete(path) {
+            const segments = pathToSegments(path);
+            return this.#resolveFolder(segments.slice(0, -1))
+                .then(folder => folder.removeEntry(asDefined(segments.at(-1)), { recursive: true }));
+        }
+        async list(path) {
+            const segments = pathToSegments(path);
+            const { status, value: folder } = await Promises.tryCatch(this.#resolveFolder(segments));
+            if (status === "rejected") {
+                return Arrays.empty();
+            }
+            const result = [];
+            for await (const { name, kind } of folder.values()) {
+                result.push({ name, kind });
+            }
+            return result;
+        }
+        async #resolveFile(path, options) {
+            const segments = pathToSegments(path);
+            return this.#resolveFolder(segments.slice(0, -1), options)
+                .then((folder) => folder.getFileHandle(asDefined(segments.at(-1)), options)
+                .then(handle => handle.createSyncAccessHandle()));
+        }
+        async #resolveFolder(segments, options) {
+            let folder = await navigator.storage.getDirectory();
+            for (const segment of segments) {
+                folder = await folder.getDirectoryHandle(segment, options);
+            }
+            return folder;
+        }
+    });
+    const pathToSegments = (path) => {
+        const noSlashes = path.replace(/^\/+|\/+$/g, "");
+        return noSlashes === "" ? [] : noSlashes.split("/");
+    };
+})(OpfsWorker || (OpfsWorker = {}));

package/dist/peaks/PeakProtocol.d.ts

@@ -0,0 +1,5 @@
+import { FloatArray, int, Procedure } from "@opendaw/lib-std";
+export interface PeakProtocol {
+    generateAsync(progress: Procedure<number>, shifts: Uint8Array, frames: ReadonlyArray<FloatArray>, numFrames: int, numChannels: int): Promise<ArrayBufferLike>;
+}
+//# sourceMappingURL=PeakProtocol.d.ts.map

package/dist/peaks/PeakProtocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeakProtocol.d.ts","sourceRoot":"","sources":["../../src/peaks/PeakProtocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,GAAG,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAA;AAE3D,MAAM,WAAW,YAAY;IACzB,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,EAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,EACjC,SAAS,EAAE,GAAG,EACd,WAAW,EAAE,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAAA;CAC5D"}

package/dist/peaks/PeakProtocol.js

@@ -0,0 +1 @@
+export {};

package/dist/peaks/PeakWorker.d.ts

@@ -0,0 +1,8 @@
+import { FloatArray, int, Procedure } from "@opendaw/lib-std";
+import { Communicator, Messenger } from "@opendaw/lib-runtime";
+export declare namespace PeakWorker {
+    const install: (messenger: Messenger) => Communicator.Executor<{
+        generateAsync(progress: Procedure<number>, shifts: Uint8Array, frames: FloatArray[], numFrames: int, numChannels: int): Promise<ArrayBufferLike>;
+    }>;
+}
+//# sourceMappingURL=PeakWorker.d.ts.map

package/dist/peaks/PeakWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeakWorker.d.ts","sourceRoot":"","sources":["../../src/peaks/PeakWorker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,UAAU,EAAE,GAAG,EAAS,SAAS,EAAC,MAAM,kBAAkB,CAAA;AAC1F,OAAO,EAAC,YAAY,EAAE,SAAS,EAAY,MAAM,sBAAsB,CAAA;AAIvE,yBAAiB,UAAU,CAAC;IACjB,MAAM,OAAO,GAAI,WAAW,SAAS;gCAEN,SAAS,CAAC,MAAM,CAAC,UACnB,UAAU,UACV,UAAU,EAAE,aACT,GAAG,eACD,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC;MAGjE,CAAA;CA6ET"}

package/dist/peaks/PeakWorker.js

@@ -0,0 +1,78 @@
+import { Arrays, Float16, panic } from "@opendaw/lib-std";
+import { Communicator, stopwatch } from "@opendaw/lib-runtime";
+import { Peaks } from "./Peaks";
+export var PeakWorker;
+(function (PeakWorker) {
+    PeakWorker.install = (messenger) => Communicator.executor(messenger.channel("peaks"), new class {
+        async generateAsync(progress, shifts, frames, numFrames, numChannels) {
+            return generatePeaks(progress, shifts, frames, numFrames, numChannels).toArrayBuffer();
+        }
+    });
+    const generatePeaks = (progress, shifts, frames, numFrames, numChannels) => {
+        if (frames.length !== numChannels) {
+            return panic(`Invalid numberOfChannels. Expected: ${numChannels}. Got ${frames.length}`);
+        }
+        class State {
+            min = Number.POSITIVE_INFINITY;
+            max = Number.NEGATIVE_INFINITY;
+            index = 0;
+        }
+        const time = stopwatch();
+        const numShifts = shifts.length;
+        const [stages, dataOffset] = initStages(shifts, numFrames);
+        const data = Arrays.create(() => new Int32Array(dataOffset), numChannels);
+        const minMask = stages[0].mask;
+        const total = numChannels * numFrames;
+        let count = 0;
+        for (let channel = 0; channel < numChannels; ++channel) {
+            const channelData = data[channel];
+            const channelFrames = frames[channel];
+            const states = Arrays.create(() => new State(), numShifts);
+            let min = Number.POSITIVE_INFINITY;
+            let max = Number.NEGATIVE_INFINITY;
+            let position = 0;
+            for (let i = 0; i < numFrames; ++i) {
+                const frame = channelFrames[i];
+                min = Math.min(frame, min);
+                max = Math.max(frame, max);
+                if ((++position & minMask) === 0) {
+                    for (let j = 0; j < numShifts; ++j) {
+                        const stage = stages[j];
+                        const state = states[j];
+                        state.min = Math.min(state.min, min);
+                        state.max = Math.max(state.max, max);
+                        if ((stage.mask & position) === 0) {
+                            channelData[stage.dataOffset + state.index++] = pack(state.min, state.max);
+                            state.min = Number.POSITIVE_INFINITY;
+                            state.max = Number.NEGATIVE_INFINITY;
+                        }
+                    }
+                    min = Number.POSITIVE_INFINITY;
+                    max = Number.NEGATIVE_INFINITY;
+                }
+                if ((++count & 0xFFFF) === 0) {
+                    progress(count / total);
+                }
+            }
+        }
+        progress(1.0);
+        time.lab(`Peak-Gen '${self.constructor.name}'`);
+        return new Peaks(stages, data, numFrames, numChannels);
+    };
+    const initStages = (shifts, numFrames) => {
+        let dataOffset = 0;
+        const stages = Arrays.create((index) => {
+            const shift = shifts[index];
+            const numPeaks = Math.ceil(numFrames / (1 << shift));
+            const stage = new Peaks.Stage((1 << shift) - 1, shift, numPeaks, dataOffset);
+            dataOffset += numPeaks;
+            return stage;
+        }, shifts.length);
+        return [stages, dataOffset];
+    };
+    const pack = (f0, f1) => {
+        const bits0 = Float16.floatToIntBits(f0);
+        const bits1 = Float16.floatToIntBits(f1);
+        return bits0 | (bits1 << 16);
+    };
+})(PeakWorker || (PeakWorker = {}));

package/dist/peaks/Peaks.d.ts

@@ -0,0 +1,26 @@
+import { ByteArrayInput, float, int } from "@opendaw/lib-std";
+export declare class Peaks {
+    readonly stages: ReadonlyArray<Peaks.Stage>;
+    readonly data: ReadonlyArray<Int32Array>;
+    readonly numFrames: int;
+    readonly numChannels: int;
+    static from(input: ByteArrayInput): Peaks;
+    static readonly None: Peaks;
+    constructor(stages: ReadonlyArray<Peaks.Stage>, data: ReadonlyArray<Int32Array>, numFrames: int, numChannels: int);
+    nearest(unitsPerPixel: number): Peaks.Stage | null;
+    toArrayBuffer(): ArrayBufferLike;
+    toString(): string;
+}
+export declare namespace Peaks {
+    const findBestFit: (numFrames: int, width?: int) => Uint8Array;
+    class Stage {
+        readonly mask: int;
+        readonly shift: int;
+        readonly numPeaks: int;
+        readonly dataOffset: int;
+        constructor(mask: int, shift: int, numPeaks: int, dataOffset: int);
+        unitsEachPeak(): int;
+    }
+    const unpack: (bits: int, index: 0 | 1) => float;
+}
+//# sourceMappingURL=Peaks.d.ts.map

package/dist/peaks/Peaks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Peaks.d.ts","sourceRoot":"","sources":["../../src/peaks/Peaks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,cAAc,EAAmB,KAAK,EAAW,GAAG,EAAY,MAAM,kBAAkB,CAAA;AAEhH,qBAAa,KAAK;IA0BF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC;IACxC,QAAQ,CAAC,SAAS,EAAE,GAAG;IACvB,QAAQ,CAAC,WAAW,EAAE,GAAG;IA5BrC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK;IAuBzC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAA0B;gBAEzB,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,CAAC,EAClC,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,EAC/B,SAAS,EAAE,GAAG,EACd,WAAW,EAAE,GAAG;IAErC,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,KAAK,CAAC,KAAK,GAAG,IAAI;IAYlD,aAAa,IAAI,eAAe;IAsBhC,QAAQ,IAAI,MAAM;CACrB;AAED,yBAAiB,KAAK,CAAC;IACZ,MAAM,WAAW,GAAI,WAAW,GAAG,EAAE,QAAO,GAAU,KAAG,UAS/D,CAAA;IAED,MAAa,KAAK;QACF,QAAQ,CAAC,IAAI,EAAE,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,GAAG;QAAE,QAAQ,CAAC,QAAQ,EAAE,GAAG;QAAE,QAAQ,CAAC,UAAU,EAAE,GAAG;oBAAhF,IAAI,EAAE,GAAG,EAAW,KAAK,EAAE,GAAG,EAAW,QAAQ,EAAE,GAAG,EAAW,UAAU,EAAE,GAAG;QACrG,aAAa,IAAI,GAAG;KACvB;IAEM,MAAM,MAAM,GAAI,MAAM,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,KAAG,KAShD,CAAA;CACJ"}

package/dist/peaks/Peaks.js

@@ -0,0 +1,107 @@
+import { Arrays, assert, ByteArrayOutput, Float16, Unhandled } from "@opendaw/lib-std";
+export class Peaks {
+    stages;
+    data;
+    numFrames;
+    numChannels;
+    static from(input) {
+        assert(input.readString() === "PEAKS", "Wrong header");
+        const numStages = input.readInt();
+        const stages = [];
+        for (let i = 0; i < numStages; i++) {
+            const dataOffset = input.readInt();
+            const numPeaks = input.readInt();
+            const shift = input.readInt();
+            const mask = input.readInt();
+            stages[i] = new Peaks.Stage(mask, shift, numPeaks, dataOffset);
+        }
+        const numData = input.readInt();
+        const data = [];
+        for (let i = 0; i < numData; i++) {
+            const array = new Int8Array(input.readInt());
+            input.readBytes(array);
+            data[i] = new Int32Array(array.buffer);
+        }
+        const numFrames = input.readInt();
+        const numChannels = input.readInt();
+        return new Peaks(stages, data, numFrames, numChannels);
+    }
+    static None = new Peaks([], [], 0, 0);
+    constructor(stages, data, numFrames, numChannels) {
+        this.stages = stages;
+        this.data = data;
+        this.numFrames = numFrames;
+        this.numChannels = numChannels;
+    }
+    nearest(unitsPerPixel) {
+        if (this.stages.length === 0) {
+            return null;
+        }
+        const shift = Math.floor(Math.log(Math.abs(unitsPerPixel)) / Math.LN2);
+        let i = this.stages.length;
+        while (--i > -1) {
+            if (shift >= this.stages[i].shift) {
+                return this.stages[i];
+            }
+        }
+        return this.stages[0];
+    }
+    toArrayBuffer() {
+        const output = ByteArrayOutput.create();
+        output.writeString("PEAKS");
+        output.writeInt(this.stages.length);
+        for (let i = 0; i < this.stages.length; i++) {
+            const { dataOffset, numPeaks, shift, mask } = this.stages[i];
+            output.writeInt(dataOffset);
+            output.writeInt(numPeaks);
+            output.writeInt(shift);
+            output.writeInt(mask);
+        }
+        output.writeInt(this.data.length);
+        for (let i = 0; i < this.data.length; i++) {
+            const array = new Int8Array(this.data[i].buffer);
+            output.writeInt(array.length);
+            output.writeBytes(array);
+        }
+        output.writeInt(this.numFrames);
+        output.writeInt(this.numChannels);
+        return output.toArrayBuffer();
+    }
+    toString() { return `{Peaks num-stages: ${this.stages.length}}`; }
+}
+(function (Peaks) {
+    Peaks.findBestFit = (numFrames, width = 1200) => {
+        const ratio = numFrames / width;
+        if (ratio <= 1.0) {
+            return new Uint8Array(0);
+        }
+        const ShiftPadding = 3;
+        const maxShift = Math.floor(Math.log(ratio) / Math.LN2);
+        const numStages = Math.max(1, Math.floor(maxShift / ShiftPadding));
+        return new Uint8Array(Arrays.create(index => ShiftPadding * (index + 1), numStages));
+    };
+    class Stage {
+        mask;
+        shift;
+        numPeaks;
+        dataOffset;
+        constructor(mask, shift, numPeaks, dataOffset) {
+            this.mask = mask;
+            this.shift = shift;
+            this.numPeaks = numPeaks;
+            this.dataOffset = dataOffset;
+        }
+        unitsEachPeak() { return 1 << this.shift; }
+    }
+    Peaks.Stage = Stage;
+    Peaks.unpack = (bits, index) => {
+        switch (index) {
+            case 0:
+                return Float16.intBitsToFloat(bits);
+            case 1:
+                return Float16.intBitsToFloat(bits >> 16);
+            default:
+                return Unhandled(index);
+        }
+    };
+})(Peaks || (Peaks = {}));

package/dist/peaks/PeaksPainter.d.ts

@@ -0,0 +1,16 @@
+import { int } from "@opendaw/lib-std";
+import { Peaks } from "./Peaks";
+export declare namespace PeaksPainter {
+    interface Layout {
+        x0: number;
+        x1: number;
+        u0: number;
+        u1: number;
+        y0: number;
+        y1: number;
+        v0: number;
+        v1: number;
+    }
+    const renderBlocks: (path: CanvasRenderingContext2D, peaks: Peaks, channelIndex: int, { u0, u1, v0, v1, x0, x1, y0, y1 }: Layout) => void;
+}
+//# sourceMappingURL=PeaksPainter.d.ts.map

package/dist/peaks/PeaksPainter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeaksPainter.d.ts","sourceRoot":"","sources":["../../src/peaks/PeaksPainter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAC,MAAM,kBAAkB,CAAA;AACpC,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAA;AAE7B,yBAAiB,YAAY,CAAC;IAC1B,UAAiB,MAAM;QACnB,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAA;QACV,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,EAAE,EAAE,MAAM,CAAA;KACb;IAEM,MAAM,YAAY,GAAI,MAAM,wBAAwB,EAC9B,OAAO,KAAK,EACZ,cAAc,GAAG,EACjB,oCAAkC,MAAM,KAAG,IAoCvE,CAAA;CACJ"}

package/dist/peaks/PeaksPainter.js

@@ -0,0 +1,43 @@
+import { Peaks } from "./Peaks";
+export var PeaksPainter;
+(function (PeaksPainter) {
+    PeaksPainter.renderBlocks = (path, peaks, channelIndex, { u0, u1, v0, v1, x0, x1, y0, y1 }) => {
+        const unitsEachPixel = (u1 - u0) / (x1 - x0);
+        const stage = peaks.nearest(unitsEachPixel);
+        if (stage === null) {
+            return;
+        }
+        const scale = (y1 - y0 - 1.0) / (v1 - v0);
+        const unitsEachPeak = stage.unitsEachPeak();
+        const pixelOverFlow = x0 - Math.floor(x0);
+        const peaksEachPixel = unitsEachPixel / unitsEachPeak;
+        let from = (u0 - pixelOverFlow * unitsEachPixel) / unitsEachPixel * peaksEachPixel;
+        let indexFrom = Math.floor(from);
+        let min = 0.0;
+        let max = 0.0;
+        const data = peaks.data[channelIndex];
+        for (let x = Math.floor(x0); x < Math.floor(x1); x++) {
+            const to = from + peaksEachPixel;
+            const indexTo = Math.floor(to);
+            let swap = false;
+            while (indexFrom < indexTo) {
+                const bits = data[stage.dataOffset + indexFrom++];
+                min = Math.min(Peaks.unpack(bits, 0), min);
+                max = Math.max(Peaks.unpack(bits, 1), max);
+                swap = true;
+            }
+            const yMin = y0 + Math.floor((min - v0) * scale);
+            const yMax = y0 + Math.floor((max - v0) * scale);
+            const ry0 = Math.max(y0, Math.min(yMin, yMax));
+            const ry1 = Math.min(y1, Math.max(yMin, yMax));
+            path.fillRect(x, ry0, 1, ry1 === ry0 ? 1 : ry1 - ry0);
+            if (swap) {
+                const tmp = max;
+                max = min;
+                min = tmp;
+            }
+            from = to;
+            indexFrom = indexTo;
+        }
+    };
+})(PeaksPainter || (PeaksPainter = {}));

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+declare global {
+    interface FileSystemFileHandle {
+        createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
+    }
+    interface FileSystemSyncAccessHandle {
+        write(buffer: BufferSource, options?: {
+            at?: number;
+        }): number;
+        read(buffer: BufferSource, options?: {
+            at?: number;
+        }): number;
+        getSize(): number;
+        truncate(newSize: number): void;
+        flush(): void;
+        close(): void;
+    }
+    interface Navigator {
+        readonly storage: StorageManager;
+    }
+    interface StorageManager {
+        getDirectory(): Promise<FileSystemDirectoryHandle>;
+    }
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,oBAAoB;QAC1B,sBAAsB,IAAI,OAAO,CAAC,0BAA0B,CAAC,CAAA;KAChE;IAED,UAAU,0BAA0B;QAChC,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;YAAE,EAAE,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,MAAM,CAAA;QAC9D,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;YAAE,EAAE,CAAC,EAAE,MAAM,CAAA;SAAE,GAAG,MAAM,CAAA;QAC7D,OAAO,IAAI,MAAM,CAAA;QACjB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;QAC/B,KAAK,IAAI,IAAI,CAAA;QACb,KAAK,IAAI,IAAI,CAAA;KAChB;IAED,UAAU,SAAS;QACf,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;KACnC;IAED,UAAU,cAAc;QACpB,YAAY,IAAI,OAAO,CAAC,yBAAyB,CAAC,CAAA;KACrD;CACJ;AAED,OAAO,EAAE,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@opendaw/lib-fusion",
+  "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": "echo \"No tests to run\""
+  },
+  "dependencies": {
+    "@opendaw/lib-box": "^0.0.6",
+    "@opendaw/lib-runtime": "^0.0.6",
+    "@opendaw/lib-std": "^0.0.6"
+  },
+  "devDependencies": {
+    "@opendaw/eslint-config": "^0.0.6",
+    "@opendaw/typescript-config": "^0.0.6"
+  },
+  "gitHead": "04e5363a9851c7e116a306c2e933c5f410980fbe"
+}