notations 0.0.43 → 0.0.46

package/README.md

@@ -0,0 +1,38 @@
+
+# Notations
+
+Notations is a Typescript library for rendering Carnatic music.  Notations comes with:
+
+1. An API for representing and rendering carnatic music.
+2. A DSL and an accompanying parser for representing music in a simpler and intuitive way.
+
+# Getting Started
+
+## Installation
+
+```
+# Install Typescript
+npm i typescript
+
+# Install the library (in a folder that already contains your package.json file).
+npm install --save notations
+
+```
+
+## Example
+
+```
+import { NotationView } from notations;
+
+const element = document.getElementById("mydiv");
+const notationView = new NotationView(element);
+notationView.add(new Note("Ga"), new Space(),
+                 new Note("Ga"), new Space(),
+                 new Note("Ri"), new Space(),
+                 new Note("Ri"), new Space(),
+                 new Note("Sa"), new Note("Sa"), 
+                 new Note("Ri"), new Note("Ri"), 
+                 new Note("Ga"), new Note("Ga"), 
+                 new Note("Ri"), new Note("Ri"));
+```
+

package/lib/cjs/beats.d.ts

@@ -0,0 +1,111 @@
+import * as TSU from "@panyam/tsutils";
+import { Line, Atom, Role } from "./";
+import { CycleIterator } from "./cycle";
+import { FlatAtom, WindowIterator } from "./iterators";
+import { LayoutParams } from "./layouts";
+declare type Fraction = TSU.Num.Fraction;
+interface BeatViewDelegate {
+    viewForBeat(beat: Beat): BeatView;
+}
+export interface BeatView {
+    readonly beat: Beat;
+    readonly needsLayout: boolean;
+    readonly minSize: TSU.Geom.Size;
+    readonly bbox: TSU.Geom.Rect;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    refreshLayout(): void;
+    setStyles(config: any): void;
+}
+export declare class Beat {
+    readonly index: number;
+    readonly role: Role;
+    readonly offset: Fraction;
+    readonly duration: Fraction;
+    readonly barIndex: number;
+    readonly beatIndex: number;
+    readonly instance: number;
+    readonly prevBeat: null | Beat;
+    nextBeat: null | Beat;
+    private static idCounter;
+    layoutLine: number;
+    layoutColumn: number;
+    readonly uuid: number;
+    atom: Atom;
+    protected atomIsPlaceholder: boolean;
+    constructor(index: number, role: Role, offset: Fraction, duration: Fraction, barIndex: number, beatIndex: number, instance: number, prevBeat: null | Beat, nextBeat: null | Beat);
+    debugValue(): any;
+    get endOffset(): Fraction;
+    get filled(): boolean;
+    get remaining(): Fraction;
+    add(atom: Atom): boolean;
+    ensureUniformSpaces(atoms: FlatAtom[], slotsPerBeat?: number): void;
+}
+export declare class BeatLayout {
+    readonly layoutParams: LayoutParams;
+    bcolNextList: Map<string, Set<string>>;
+    beatColumns: Map<string, BeatColumn>;
+    startingColumns: BeatColumn[];
+    columnForBeat: Map<number, BeatColumn>;
+    constructor(layoutParams: LayoutParams);
+    getBeatColumn(offset: Fraction, duration: Fraction): BeatColumn;
+    protected static keyFor(offset: Fraction, duration: Fraction): string;
+    protected addSuccessor(prev: BeatColumn, next: BeatColumn): void;
+    addBeat(beat: Beat): BeatColumn;
+    neighborsOf(beatColumn: BeatColumn): BeatColumn[];
+    readonly DEBUG = false;
+    evalColumnSizes(beatViewDelegate: BeatViewDelegate): void;
+    roleSpacing: number;
+    rowSpacing: number;
+    layoutBeatsForLine(line: Line, allRoleBeats: Beat[][], beatViewDelegate: BeatViewDelegate): void;
+}
+export declare class BeatRow {
+    readonly layoutLine: number;
+    rowIndex: number;
+    protected _y: number;
+    protected _maxHeight: number;
+    needsLayout: boolean;
+    rowSpacing: number;
+    beats: Beat[];
+    constructor(layoutLine: number, rowIndex: number);
+    get y(): number;
+    set y(val: number);
+    add(beat: Beat): void;
+}
+export declare class BeatColumn {
+    readonly offset: Fraction;
+    readonly duration: Fraction;
+    protected _x: number;
+    protected _maxWidth: number;
+    needsLayout: boolean;
+    atomSpacing: number;
+    paddingLeft: number;
+    paddingRight: number;
+    beats: Beat[];
+    constructor(offset: Fraction, duration: Fraction);
+    get x(): number;
+    setX(val: number, beatViewDelegate: BeatViewDelegate): void;
+    get maxWidth(): number;
+    setPadding(left: number, right: number): void;
+    evalMaxWidth(beatViewDelegate: BeatViewDelegate): number;
+    add(beat: Beat): void;
+}
+export declare class BeatsBuilder {
+    readonly role: Role;
+    readonly layoutParams: LayoutParams;
+    readonly startOffset: Fraction;
+    readonly beats: Beat[];
+    readonly startIndex: number;
+    readonly beatOffset: Fraction;
+    cycleIter: CycleIterator;
+    windowIter: WindowIterator;
+    onAtomAdded: (atom: Atom, beat: Beat) => void;
+    onBeatAdded: (beat: Beat) => void;
+    onBeatFilled: (beat: Beat) => void;
+    constructor(role: Role, layoutParams: LayoutParams, startOffset?: Fraction);
+    protected addBeat(): Beat;
+    addAtoms(...atoms: Atom[]): void;
+}
+export {};

package/lib/cjs/beats.js

@@ -0,0 +1,527 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeatsBuilder = exports.BeatColumn = exports.BeatRow = exports.BeatLayout = exports.Beat = void 0;
+var TSU = __importStar(require("@panyam/tsutils"));
+var _1 = require("./");
+var iterators_1 = require("./iterators");
+var ZERO = TSU.Num.Fraction.ZERO;
+var ONE = TSU.Num.Fraction.ONE;
+var Beat = (function () {
+    function Beat(index, role, offset, duration, barIndex, beatIndex, instance, prevBeat, nextBeat) {
+        this.index = index;
+        this.role = role;
+        this.offset = offset;
+        this.duration = duration;
+        this.barIndex = barIndex;
+        this.beatIndex = beatIndex;
+        this.instance = instance;
+        this.prevBeat = prevBeat;
+        this.nextBeat = nextBeat;
+        this.layoutLine = -1;
+        this.layoutColumn = -1;
+        this.uuid = Beat.idCounter++;
+        this.atomIsPlaceholder = false;
+    }
+    Beat.prototype.debugValue = function () {
+        return {
+            index: this.index,
+            role: this.role.name,
+            offset: this.offset.toString(),
+            duration: this.duration.toString(),
+            barIndex: this.barIndex,
+            beatIndex: this.beatIndex,
+            instance: this.instance,
+            atom: this.atom.debugValue(),
+        };
+    };
+    Object.defineProperty(Beat.prototype, "endOffset", {
+        get: function () {
+            return this.offset.plus(this.duration);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Beat.prototype, "filled", {
+        get: function () {
+            return this.remaining.isZero;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Beat.prototype, "remaining", {
+        get: function () {
+            return this.atom ? this.duration.minus(this.atom.duration, true) : this.duration;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Beat.prototype.add = function (atom) {
+        if (this.remaining.cmp(atom.duration) < 0) {
+            return false;
+        }
+        if (!this.atom) {
+            this.atom = atom;
+        }
+        else {
+            if (!this.atomIsPlaceholder) {
+                this.atomIsPlaceholder = true;
+                this.atom = new _1.Group(this.atom).setDuration(ONE, true);
+            }
+            this.atom.addAtoms(true, atom);
+        }
+        return true;
+    };
+    Beat.prototype.ensureUniformSpaces = function (atoms, slotsPerBeat) {
+        if (slotsPerBeat === void 0) { slotsPerBeat = 1; }
+        var lcm = 1;
+        var gcd = 0;
+        atoms.forEach(function (a, index) {
+            a.duration = a.duration.factorized;
+            var currDen = a.duration.den;
+            if (currDen != 1) {
+                lcm *= currDen;
+                if (gcd == 0) {
+                    gcd = a.duration.den;
+                }
+                else {
+                    gcd = TSU.Num.gcdof(gcd, currDen);
+                    lcm /= gcd;
+                }
+            }
+        });
+        var baseDur = new TSU.Num.Fraction(1, lcm);
+        var currOffset = this.offset;
+        for (var i = 0; i < atoms.length;) {
+            var fa = atoms[i];
+            var numSpaces = lcm == 1 ? fa.duration.num - 1 : lcm / fa.duration.den - 1;
+            fa.duration = baseDur;
+            currOffset = currOffset.plus(baseDur);
+            i++;
+            for (var j = 0; j < numSpaces; j++, i++) {
+                var space = new _1.Space(baseDur);
+                space.isContinuation = true;
+                atoms.splice(i, 0, new iterators_1.FlatAtom(space));
+                atoms.splice(i, 0, new iterators_1.FlatAtom(space));
+                currOffset = currOffset.plus(baseDur);
+            }
+        }
+    };
+    Beat.idCounter = 0;
+    return Beat;
+}());
+exports.Beat = Beat;
+var BeatLayout = (function () {
+    function BeatLayout(layoutParams) {
+        this.layoutParams = layoutParams;
+        this.bcolNextList = new Map();
+        this.beatColumns = new Map();
+        this.startingColumns = [];
+        this.columnForBeat = new Map();
+        this.DEBUG = false;
+        this.roleSpacing = 10;
+        this.rowSpacing = 15;
+    }
+    BeatLayout.prototype.getBeatColumn = function (offset, duration) {
+        var e_1, _a;
+        var key = BeatLayout.keyFor(offset, duration);
+        var bcol = this.beatColumns.get(key) || null;
+        if (!bcol) {
+            bcol = new BeatColumn(offset, duration);
+            this.beatColumns.set(key, bcol);
+            if (bcol.offset.isZero) {
+                this.startingColumns.push(bcol);
+            }
+            else {
+                var endOffset = offset.plus(duration);
+                try {
+                    for (var _b = __values(this.beatColumns.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var other = _c.value;
+                        if (other.offset.plus(other.duration).equals(offset)) {
+                            this.addSuccessor(other, bcol);
+                        }
+                        else if (other.offset.equals(endOffset)) {
+                            this.addSuccessor(bcol, other);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        }
+        return bcol;
+    };
+    BeatLayout.keyFor = function (offset, duration) {
+        return offset.factorized.toString() + ":" + duration.factorized.toString();
+    };
+    BeatLayout.prototype.addSuccessor = function (prev, next) {
+        TSU.assert(prev.offset.plus(prev.duration).equals(next.offset), "BeatColumns are not adjacent to each other");
+        var prevKey = BeatLayout.keyFor(prev.offset, prev.duration);
+        var nextKey = BeatLayout.keyFor(next.offset, next.duration);
+        var nextset = this.bcolNextList.get(prevKey) || null;
+        if (!nextset) {
+            nextset = new Set();
+            this.bcolNextList.set(prevKey, nextset);
+        }
+        nextset.add(nextKey);
+    };
+    BeatLayout.prototype.addBeat = function (beat) {
+        var lp = this.layoutParams;
+        var _a = __read(lp.getBeatLocation(beat), 3), layoutLine = _a[0], layoutColumn = _a[1], rowOffset = _a[2];
+        var bcol = this.getBeatColumn(rowOffset, beat.duration);
+        bcol.add(beat);
+        this.columnForBeat.set(beat.uuid, bcol);
+        beat.layoutLine = layoutLine;
+        beat.layoutColumn = layoutColumn;
+        return bcol;
+    };
+    BeatLayout.prototype.neighborsOf = function (beatColumn) {
+        var e_2, _a;
+        var out = [];
+        var endOffset = beatColumn.offset.plus(beatColumn.duration);
+        try {
+            for (var _b = __values(this.beatColumns.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var other = _c.value;
+                if (endOffset.equals(other.offset)) {
+                    out.push(other);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return out;
+    };
+    BeatLayout.prototype.evalColumnSizes = function (beatViewDelegate) {
+        var e_3, _a, e_4, _b;
+        var queue = __spreadArray([], __read(this.startingColumns), false);
+        var xForOffsets = {};
+        while (queue.length > 0) {
+            var nextQueue = [];
+            try {
+                for (var queue_1 = (e_3 = void 0, __values(queue)), queue_1_1 = queue_1.next(); !queue_1_1.done; queue_1_1 = queue_1.next()) {
+                    var bcol = queue_1_1.value;
+                    var offset = bcol.offset.factorized;
+                    var colWidth = bcol.evalMaxWidth(beatViewDelegate);
+                    var currX = 0;
+                    if (!bcol.offset.isZero) {
+                        TSU.assert(offset.toString() in xForOffsets, "Cannot find x for given offset");
+                        currX = xForOffsets[offset.toString()];
+                    }
+                    bcol.setX(currX, beatViewDelegate);
+                    var endOffset = offset.plus(bcol.duration, true);
+                    xForOffsets[endOffset.toString()] = Math.max(xForOffsets[endOffset.toString()] || 0, currX + colWidth + bcol.paddingLeft + bcol.paddingRight);
+                    try {
+                        for (var _c = (e_4 = void 0, __values(this.beatColumns.values())), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            var other = _d.value;
+                            if (endOffset.equals(other.offset)) {
+                                nextQueue.push(other);
+                            }
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (queue_1_1 && !queue_1_1.done && (_a = queue_1.return)) _a.call(queue_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            queue = nextQueue;
+        }
+    };
+    BeatLayout.prototype.layoutBeatsForLine = function (line, allRoleBeats, beatViewDelegate) {
+        var lp = this.layoutParams;
+        var currBeats = line.roles.map(function (l, index) { return allRoleBeats[index][0]; });
+        var currY = this.roleSpacing;
+        var numDone = 0;
+        do {
+            numDone = 0;
+            for (var currRole = 0; currRole < currBeats.length; currRole++) {
+                var currBeat = currBeats[currRole];
+                if (currBeat) {
+                    var temp = currBeat;
+                    var numBeatsInRow = lp.lineBreaks[currBeat.layoutLine];
+                    var maxHeight = 0;
+                    var currX = 15;
+                    for (var i = currBeat.layoutColumn; i < numBeatsInRow && currBeat; i++, currBeat = currBeat.nextBeat, numDone++) {
+                        var beatView = beatViewDelegate.viewForBeat(currBeat);
+                        beatView.y = currY;
+                        if (this.DEBUG) {
+                            beatView.x = currX;
+                            beatView.refreshLayout();
+                            currX += beatView.width;
+                        }
+                        maxHeight = Math.max(maxHeight, beatView.minSize.height);
+                    }
+                    currBeat = temp;
+                    for (var i = currBeat.layoutColumn; i < numBeatsInRow && currBeat; i++, currBeat = currBeat.nextBeat, numDone++) {
+                        var beatView = beatViewDelegate.viewForBeat(currBeat);
+                        beatView.height = maxHeight;
+                    }
+                    currY += maxHeight;
+                    currY += this.roleSpacing;
+                }
+                currBeats[currRole] = currBeat;
+            }
+            currY += this.rowSpacing;
+        } while (numDone > 0);
+    };
+    return BeatLayout;
+}());
+exports.BeatLayout = BeatLayout;
+var BeatRow = (function () {
+    function BeatRow(layoutLine, rowIndex) {
+        this.layoutLine = layoutLine;
+        this.rowIndex = rowIndex;
+        this._y = 0;
+        this._maxHeight = 0;
+        this.needsLayout = false;
+        this.rowSpacing = 5;
+        this.beats = [];
+    }
+    Object.defineProperty(BeatRow.prototype, "y", {
+        get: function () {
+            return this._y;
+        },
+        set: function (val) {
+            this._y = val;
+            this.needsLayout = true;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BeatRow.prototype.add = function (beat) {
+        this.beats.push(beat);
+        this.needsLayout = true;
+    };
+    return BeatRow;
+}());
+exports.BeatRow = BeatRow;
+var BeatColumn = (function () {
+    function BeatColumn(offset, duration) {
+        this.offset = offset;
+        this.duration = duration;
+        this._x = 0;
+        this._maxWidth = 0;
+        this.needsLayout = false;
+        this.atomSpacing = 5;
+        this.paddingLeft = 15;
+        this.paddingRight = 15;
+        this.beats = [];
+        offset = offset.factorized;
+        duration = duration.factorized;
+    }
+    Object.defineProperty(BeatColumn.prototype, "x", {
+        get: function () {
+            return this._x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BeatColumn.prototype.setX = function (val, beatViewDelegate) {
+        var e_5, _a;
+        this._x = val;
+        try {
+            for (var _b = __values(this.beats), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var beat = _c.value;
+                var beatView = beatViewDelegate.viewForBeat(beat);
+                beatView.x = val + this.paddingLeft;
+                beatView.width = this._maxWidth;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    Object.defineProperty(BeatColumn.prototype, "maxWidth", {
+        get: function () {
+            return this._maxWidth + this.paddingLeft + this.paddingRight;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BeatColumn.prototype.setPadding = function (left, right) {
+        if (left >= 0) {
+            this.paddingLeft = left;
+        }
+        if (right >= 0) {
+            this.paddingRight = right;
+        }
+    };
+    BeatColumn.prototype.evalMaxWidth = function (beatViewDelegate) {
+        var e_6, _a;
+        this._maxWidth = 0;
+        try {
+            for (var _b = __values(this.beats), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var beat = _c.value;
+                var beatView = beatViewDelegate.viewForBeat(beat);
+                var minSize = beatView.minSize;
+                if (minSize.width > this._maxWidth) {
+                    this._maxWidth = minSize.width;
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return this._maxWidth;
+    };
+    BeatColumn.prototype.add = function (beat) {
+        this.beats.push(beat);
+        this.needsLayout = true;
+    };
+    return BeatColumn;
+}());
+exports.BeatColumn = BeatColumn;
+var BeatsBuilder = (function () {
+    function BeatsBuilder(role, layoutParams, startOffset) {
+        if (startOffset === void 0) { startOffset = ZERO; }
+        this.role = role;
+        this.layoutParams = layoutParams;
+        this.startOffset = startOffset;
+        this.beats = [];
+        var _a = __read(layoutParams.cycle.getPosition(startOffset), 4), _b = __read(_a[1], 3), bar = _b[0], beat = _b[1], instance = _b[2], beatOffset = _a[2], index = _a[3];
+        this.cycleIter = layoutParams.cycle.iterateBeats(bar, beat, instance);
+        this.windowIter = new iterators_1.WindowIterator();
+        this.beatOffset = beatOffset;
+        this.startIndex = index;
+    }
+    BeatsBuilder.prototype.addBeat = function () {
+        var numBeats = this.beats.length;
+        var lastBeat = numBeats == 0 ? null : this.beats[numBeats - 1];
+        var nextCP = this.cycleIter.next().value;
+        var apb = this.layoutParams.beatDuration;
+        var newBeat = new Beat(lastBeat == null ? this.startIndex : lastBeat.index + 1, this.role, lastBeat == null ? this.startOffset.minus(this.beatOffset).timesNum(apb, true) : lastBeat.endOffset, nextCP[1].timesNum(apb), nextCP[0][0], nextCP[0][1], nextCP[0][2], lastBeat, null);
+        if (lastBeat == null && this.beatOffset.isGT(ZERO)) {
+            newBeat.add(new _1.Space(this.beatOffset.timesNum(apb)));
+        }
+        if (lastBeat)
+            lastBeat.nextBeat = newBeat;
+        this.beats.push(newBeat);
+        if (this.onBeatAdded)
+            this.onBeatAdded(newBeat);
+        return newBeat;
+    };
+    BeatsBuilder.prototype.addAtoms = function () {
+        var _a, e_7, _b;
+        var atoms = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            atoms[_i] = arguments[_i];
+        }
+        (_a = this.windowIter).push.apply(_a, __spreadArray([], __read(atoms), false));
+        while (this.windowIter.hasMore) {
+            var currBeat = this.beats[this.beats.length - 1];
+            if (this.beats.length == 0 || currBeat.filled) {
+                currBeat = this.addBeat();
+            }
+            var _c = __read(this.windowIter.get(currBeat.remaining), 2), remAtoms = _c[0], filled = _c[1];
+            TSU.assert(remAtoms.length > 0, "Atleast one element should have been available here");
+            try {
+                for (var remAtoms_1 = (e_7 = void 0, __values(remAtoms)), remAtoms_1_1 = remAtoms_1.next(); !remAtoms_1_1.done; remAtoms_1_1 = remAtoms_1.next()) {
+                    var atom = remAtoms_1_1.value;
+                    TSU.assert(currBeat.add(atom), "Should return true as we are already using a duration iterator here");
+                    if (this.onAtomAdded)
+                        this.onAtomAdded(atom, currBeat);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (remAtoms_1_1 && !remAtoms_1_1.done && (_b = remAtoms_1.return)) _b.call(remAtoms_1);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            if (currBeat.filled) {
+                if (this.onBeatFilled)
+                    this.onBeatFilled(currBeat);
+            }
+        }
+    };
+    return BeatsBuilder;
+}());
+exports.BeatsBuilder = BeatsBuilder;
+//# sourceMappingURL=beats.js.map