notations 0.0.40 → 0.0.45

package/lib/esm/core.js

@@ -24,44 +24,6 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-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;
@@ -87,132 +49,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+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.");
+};
 import * as TSU from "@panyam/tsutils";
+import { Entity, TimedEntity } from "./entity";
 var ZERO = TSU.Num.Fraction.ZERO;
 var ONE = TSU.Num.Fraction.ONE;
-var Entity = (function () {
-    function Entity(config) {
-        if (config === void 0) { config = null; }
-        this.uuid = Entity.counter++;
-        this.parent = null;
-        config = config || {};
-        this.metadata = config.metadata || {};
-    }
-    Entity.prototype.debugValue = function () {
-        if (Object.keys(this.metadata).length > 0)
-            return { metadata: this.metadata, type: this.type };
-        else
-            return { type: this.type };
-    };
-    Entity.prototype.children = function () {
-        return [];
-    };
-    Object.defineProperty(Entity.prototype, "childCount", {
-        get: function () {
-            return this.children().length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Entity.prototype.addChild = function (child, index) {
-        if (index === void 0) { index = -1; }
-        if (index < 0) {
-            this.children().push(child);
-        }
-        else {
-            this.children().splice(index, 0, child);
-        }
-        return this;
-    };
-    Entity.prototype.childAt = function (index) {
-        return this.children()[index];
-    };
-    Entity.prototype.indexOfChild = function (entity) {
-        var e_1, _a;
-        var i = 0;
-        try {
-            for (var _b = __values(this.children()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var child = _c.value;
-                if (child == entity)
-                    return i;
-                i++;
-            }
-        }
-        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 -1;
-    };
-    Entity.prototype.removeChildAt = function (index) {
-        var children = this.children();
-        var out = children[index];
-        children.splice(index, 1);
-        return out;
-    };
-    Entity.prototype.setChildAt = function (index, entity) {
-        this.children()[index] = entity;
-        return this;
-    };
-    Entity.prototype.setMetadata = function (key, value) {
-        this.metadata[key] = value;
-        return this;
-    };
-    Entity.prototype.getMetadata = function (key, recurse) {
-        if (recurse === void 0) { recurse = true; }
-        if (key in this.metadata) {
-            return this.metadata[key];
-        }
-        if (recurse && this.parent) {
-            return this.parent.getMetadata(key);
-        }
-        return null;
-    };
-    Object.defineProperty(Entity.prototype, "type", {
-        get: function () {
-            return this.constructor.name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Entity.prototype.toString = function () {
-        return "Entity(id = " + this.uuid + ")";
-    };
-    Entity.prototype.equals = function (another, expect) {
-        if (expect === void 0) { expect = false; }
-        if (this.type != another.type)
-            return false;
-        return true;
-    };
-    Entity.prototype.clone = function () {
-        var out = this.newInstance();
-        this.copyTo(out);
-        return out;
-    };
-    Entity.prototype.copyTo = function (another) {
-        another.metadata = __assign({}, this.metadata);
-    };
-    Entity.prototype.newInstance = function () {
-        return new this.constructor();
-    };
-    Entity.counter = 0;
-    return Entity;
-}());
-export { Entity };
-var TimedEntity = (function (_super) {
-    __extends(TimedEntity, _super);
-    function TimedEntity() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TimedEntity.prototype.equals = function (another) {
-        return _super.prototype.equals.call(this, another) && this.duration.equals(another.duration);
-    };
-    return TimedEntity;
-}(Entity));
-export { TimedEntity };
 export var AtomType;
 (function (AtomType) {
     AtomType["NOTE"] = "Note";
@@ -230,17 +81,24 @@ var Atom = (function (_super) {
         var _this = _super.call(this) || this;
         _this.nextSibling = null;
         _this.prevSibling = null;
+        _this.parentGroup = null;
+        _this.isContinuation = false;
         _this._duration = duration || ONE;
         return _this;
     }
     Atom.prototype.debugValue = function () {
-        return this.duration.isOne
-            ? _super.prototype.debugValue.call(this)
-            : __assign(__assign({}, _super.prototype.debugValue.call(this)), { duration: this.duration.factorized.toString() });
+        var out = _super.prototype.debugValue.call(this);
+        if (!this.duration.isOne) {
+            out.duration = this.duration.factorized.toString();
+        }
+        if (this.isContinuation) {
+            out.isContinuation = true;
+        }
+        return out;
     };
     Atom.prototype.copyTo = function (another) {
         _super.prototype.copyTo.call(this, another);
-        another.duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);
+        another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);
     };
     Object.defineProperty(Atom.prototype, "duration", {
         get: function () {
@@ -262,6 +120,18 @@ var LeafAtom = (function (_super) {
         _this.beforeRest = false;
         return _this;
     }
+    LeafAtom.prototype.splitAt = function (duration) {
+        if (this.duration.cmp(duration) > 0) {
+            var spillOver = this.createSpilloverSpace(this.duration.minus(duration));
+            spillOver.isContinuation = true;
+            this.duration = duration;
+            return spillOver;
+        }
+        return null;
+    };
+    LeafAtom.prototype.createSpilloverSpace = function (duration) {
+        return new Space(duration);
+    };
     LeafAtom.prototype.debugValue = function () {
         return this.beforeRest ? __assign(__assign({}, _super.prototype.debugValue.call(this)), { beforeRest: true }) : _super.prototype.debugValue.call(this);
     };
@@ -290,7 +160,7 @@ var Space = (function (_super) {
         return __assign(__assign({}, _super.prototype.debugValue.call(this)), { isSilent: this.isSilent });
     };
     Space.prototype.toString = function () {
-        return "Space(" + this.duration + "-" + this.isSilent + ")";
+        return "Space(".concat(this.duration, "-").concat(this.isSilent, ")");
     };
     Space.prototype.copyTo = function (another) {
         _super.prototype.copyTo.call(this, another);
@@ -299,6 +169,11 @@ var Space = (function (_super) {
     Space.prototype.equals = function (another) {
         return _super.prototype.equals.call(this, another) && this.isSilent == another.isSilent;
     };
+    Space.prototype.createSpilloverSpace = function (duration) {
+        var out = _super.prototype.createSpilloverSpace.call(this, duration);
+        out.isSilent = this.isSilent;
+        return out;
+    };
     return Space;
 }(LeafAtom));
 export { Space };
@@ -319,7 +194,7 @@ var Literal = (function (_super) {
         return out;
     };
     Literal.prototype.toString = function () {
-        return "Lit(" + this.duration + "-" + this.value + ")";
+        return "Lit(".concat(this.duration, "-").concat(this.value, ")");
     };
     Literal.prototype.equals = function (another) {
         return _super.prototype.equals.call(this, another) && this.value == another.value;
@@ -341,10 +216,11 @@ var Syllable = (function (_super) {
             return lit;
         var out = new Syllable(lit.value, lit.duration);
         out.embelishments = lit.embelishments;
+        out.beforeRest = lit.beforeRest;
         return out;
     };
     Syllable.prototype.toString = function () {
-        return "Syll(" + this.duration + "-" + this.value + ")";
+        return "Syll(".concat(this.duration, "-").concat(this.value, ")");
     };
     return Syllable;
 }(Literal));
@@ -367,6 +243,7 @@ var Note = (function (_super) {
             return lit;
         var out = new Note(lit.value, lit.duration);
         out.embelishments = lit.embelishments;
+        out.beforeRest = lit.beforeRest;
         return out;
     };
     Note.prototype.debugValue = function () {
@@ -378,7 +255,7 @@ var Note = (function (_super) {
         return out;
     };
     Note.prototype.toString = function () {
-        return "Note(" + this.duration + "-" + this.value + "-" + this.octave + ")";
+        return "Note(".concat(this.duration, "-").concat(this.value, "-").concat(this.octave, ")");
     };
     Note.prototype.equals = function (another) {
         return _super.prototype.equals.call(this, another) && this.octave == another.octave && this.shift == another.shift;
@@ -393,18 +270,28 @@ var Note = (function (_super) {
 export { Note };
 var Group = (function (_super) {
     __extends(Group, _super);
-    function Group(duration) {
-        if (duration === void 0) { duration = ONE; }
+    function Group() {
         var atoms = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            atoms[_i - 1] = arguments[_i];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            atoms[_i] = arguments[_i];
         }
-        var _this = _super.call(this, duration) || this;
+        var _this = _super.call(this, atoms.length == 0 ? ZERO : ONE) || this;
         _this.durationIsMultiplier = false;
         _this.atoms = new TSU.Lists.ValueList();
-        _this.addAtoms.apply(_this, __spreadArray([], __read(atoms), false));
+        _this.addAtoms.apply(_this, __spreadArray([false], __read(atoms), false));
         return _this;
     }
+    Group.prototype.equals = function (another, expect) {
+        if (expect === void 0) { expect = false; }
+        if (!_super.prototype.equals.call(this, another))
+            return false;
+        return this.atoms.equals(another.atoms, function (a1, a2) { return a1.equals(a2); });
+    };
+    Group.prototype.copyTo = function (another) {
+        _super.prototype.copyTo.call(this, another);
+        another.durationIsMultiplier = this.durationIsMultiplier;
+        this.atoms.forEach(function (atom) { return another.atoms.add(atom.clone()); });
+    };
     Object.defineProperty(Group.prototype, "duration", {
         get: function () {
             if (this.durationIsMultiplier) {
@@ -414,18 +301,72 @@ var Group = (function (_super) {
                 return this._duration;
             }
         },
-        set: function (d) {
-            this._duration = d;
-        },
         enumerable: false,
         configurable: true
     });
+    Group.prototype.setDurationAsMultiplier = function (asMultiplier) {
+        if (asMultiplier === void 0) { asMultiplier = true; }
+        this.durationIsMultiplier = asMultiplier;
+        return this;
+    };
+    Group.prototype.setDuration = function (d, asMultiplier) {
+        if (asMultiplier === void 0) { asMultiplier = false; }
+        this._duration = d;
+        this.durationIsMultiplier = asMultiplier;
+        return this;
+    };
     Group.prototype.debugValue = function () {
         var out = __assign(__assign({}, _super.prototype.debugValue.call(this)), { atoms: Array.from(this.atoms.values(), function (a) { return a.debugValue(); }) });
         if (this.durationIsMultiplier)
             out.durationIsMultiplier = true;
         return out;
     };
+    Group.prototype.splitAt = function (requiredDuration) {
+        if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {
+            return null;
+        }
+        var targetGroup = new Group();
+        if (this.durationIsMultiplier) {
+            targetGroup.durationIsMultiplier = true;
+            targetGroup._duration = this._duration;
+        }
+        var remainingDur = this.duration;
+        var totalChildDuration = this.totalChildDuration;
+        var durationFactor = this.durationIsMultiplier
+            ? ONE.divby(this._duration)
+            : this._duration.divby(totalChildDuration, true);
+        while (remainingDur.isGT(requiredDuration) && this.atoms.last) {
+            var lastChild = this.atoms.last;
+            var childDuration = lastChild.duration.times(durationFactor);
+            var newDuration = remainingDur.minus(childDuration);
+            if (newDuration.isGTE(requiredDuration)) {
+                this.removeAtoms(true, lastChild);
+                targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);
+                if (newDuration.equals(requiredDuration)) {
+                    return targetGroup;
+                }
+            }
+            else {
+                var newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);
+                var spillOver = lastChild.splitAt(newRequiredDur);
+                if (spillOver == null) {
+                    throw new Error("Spill over cannot be null here");
+                }
+                if (!this.durationIsMultiplier) {
+                    this._duration = requiredDuration;
+                }
+                else {
+                    if (this._duration.isZero)
+                        throw new Error("How can this be?");
+                }
+                spillOver.isContinuation = true;
+                targetGroup.insertAtomsAt(targetGroup.atoms.first, true, spillOver);
+                return targetGroup;
+            }
+            remainingDur = newDuration;
+        }
+        return targetGroup;
+    };
     Object.defineProperty(Group.prototype, "totalChildDuration", {
         get: function () {
             var out = ZERO;
@@ -435,25 +376,24 @@ var Group = (function (_super) {
         enumerable: false,
         configurable: true
     });
-    Group.prototype.equals = function (another, expect) {
-        if (expect === void 0) { expect = false; }
-        if (!_super.prototype.equals.call(this, another))
-            return false;
-        return this.atoms.equals(another.atoms, function (a1, a2) { return a1.equals(a2); });
-    };
-    Group.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
-        this.atoms.forEach(function (atom) { return another.atoms.add(atom.clone()); });
-    };
-    Group.prototype.addAtoms = function () {
-        var e_2, _a;
+    Group.prototype.insertAtomsAt = function (beforeAtom, adjustDuration) {
+        var e_1, _a;
+        if (adjustDuration === void 0) { adjustDuration = false; }
         var atoms = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            atoms[_i] = arguments[_i];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            atoms[_i - 2] = arguments[_i];
         }
+        adjustDuration = adjustDuration && !this.durationIsMultiplier;
+        var oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;
         try {
             for (var atoms_1 = __values(atoms), atoms_1_1 = atoms_1.next(); !atoms_1_1.done; atoms_1_1 = atoms_1.next()) {
                 var atom = atoms_1_1.value;
+                if (atom.parentGroup != null) {
+                    if (atom.parentGroup != this) {
+                        throw new Error("Atom belongs to another parent.  Remove it first");
+                    }
+                    atom.parentGroup.removeAtoms(false, atom);
+                }
                 if (atom.type == AtomType.REST) {
                     var last = this.atoms.last;
                     if (last && last.type != AtomType.GROUP && last.type != AtomType.LABEL) {
@@ -461,391 +401,83 @@ var Group = (function (_super) {
                     }
                 }
                 else {
-                    atom.parent = this;
-                    this.atoms.add(atom);
+                    atom.parentGroup = this;
+                    this.atoms.add(atom, beforeAtom);
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
         finally {
             try {
                 if (atoms_1_1 && !atoms_1_1.done && (_a = atoms_1.return)) _a.call(atoms_1);
             }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return this;
-    };
-    return Group;
-}(Atom));
-export { Group };
-var CycleCursor = (function () {
-    function CycleCursor(cycle, barIndex, beatIndex, instance) {
-        if (barIndex === void 0) { barIndex = 0; }
-        if (beatIndex === void 0) { beatIndex = 0; }
-        if (instance === void 0) { instance = 0; }
-        this.cycle = cycle;
-        this.barIndex = barIndex;
-        this.beatIndex = beatIndex;
-        this.instance = instance;
-    }
-    Object.defineProperty(CycleCursor.prototype, "next", {
-        get: function () {
-            var currBar = this.cycle.bars[this.barIndex];
-            var result = [
-                [this.barIndex, this.beatIndex, this.instance],
-                currBar.beatLengths[this.beatIndex],
-            ];
-            this.instance++;
-            if (!currBar.beatCounts[this.beatIndex] || this.instance >= currBar.beatCounts[this.beatIndex]) {
-                this.instance = 0;
-                this.beatIndex++;
-                if (this.beatIndex >= currBar.beatLengths.length) {
-                    this.beatIndex = 0;
-                    this.barIndex++;
-                    if (this.barIndex >= this.cycle.bars.length) {
-                        this.barIndex = 0;
-                    }
-                }
-            }
-            return result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(CycleCursor.prototype, "prev", {
-        get: function () {
-            var currBar = this.cycle.bars[this.barIndex];
-            var result = [
-                [this.barIndex, this.beatIndex, this.instance],
-                currBar.beatLengths[this.beatIndex],
-            ];
-            this.instance--;
-            if (this.instance < 0) {
-                this.beatIndex--;
-                if (this.beatIndex < 0) {
-                    this.barIndex--;
-                    if (this.barIndex < 0) {
-                        this.barIndex = this.cycle.bars.length - 1;
-                    }
-                    this.beatIndex = this.cycle.bars[this.barIndex].beatCount - 1;
-                }
-                this.instance = (this.cycle.bars[this.barIndex].beatCounts[this.beatIndex] || 1) - 1;
-            }
-            return result;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return CycleCursor;
-}());
-export { CycleCursor };
-var Bar = (function (_super) {
-    __extends(Bar, _super);
-    function Bar(config) {
-        var e_3, _a, e_4, _b;
-        if (config === void 0) { config = null; }
-        var _this = _super.call(this, (config = config || {})) || this;
-        _this.beatLengths = [];
-        _this.beatCounts = [];
-        _this.name = config.name || "";
-        try {
-            for (var _c = __values(config.beatLengths || []), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var bl = _d.value;
-                if (typeof bl === "number") {
-                    _this.beatLengths.push(TSU.Num.Frac(bl));
-                }
-                else {
-                    _this.beatLengths.push(bl);
-                }
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_3) throw e_3.error; }
+            finally { if (e_1) throw e_1.error; }
         }
-        try {
-            for (var _e = __values(config.beatCounts || []), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var bc = _f.value;
-                _this.beatCounts.push(bc);
+        if (adjustDuration) {
+            if (this._duration.isZero) {
+                if (this.durationIsMultiplier)
+                    throw new Error("How can this be?");
+                this._duration = this.totalChildDuration;
             }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            else {
+                var scaleFactor = this.totalChildDuration.divby(oldChildDuration);
+                this._duration = this._duration.times(scaleFactor, true);
             }
-            finally { if (e_4) throw e_4.error; }
-        }
-        while (_this.beatCounts.length < _this.beatLengths.length) {
-            _this.beatCounts.push(1);
-        }
-        return _this;
-    }
-    Bar.prototype.debugValue = function () {
-        return __assign(__assign({}, _super.prototype.debugValue.call(this)), { name: name, beatLengths: this.beatLengths });
-    };
-    Bar.prototype.equals = function (another) {
-        if (!_super.prototype.equals.call(this, another))
-            return false;
-        if (this.beatLengths.length != another.beatLengths.length)
-            return false;
-        if (this.beatCounts.length != another.beatCounts.length)
-            return false;
-        for (var i = 0; i < this.beatLengths.length; i++) {
-            if (!this.beatLengths[i].equals(another.beatLengths[i]))
-                return false;
         }
-        for (var i = 0; i < this.beatCounts.length; i++) {
-            if (this.beatCounts[i] != another.beatCounts[i])
-                return false;
-        }
-        return true;
-    };
-    Bar.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
-        another.name = this.name;
-        another.beatLengths = __spreadArray([], __read(this.beatLengths), false);
-        another.beatCounts = __spreadArray([], __read(this.beatCounts), false);
-    };
-    Object.defineProperty(Bar.prototype, "beatCount", {
-        get: function () {
-            return this.beatLengths.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Bar.prototype, "totalBeatCount", {
-        get: function () {
-            var out = 0;
-            for (var i = 0; i < this.beatLengths.length; i++) {
-                out += this.beatCounts[i] || 1;
-            }
-            return out;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Bar.prototype, "duration", {
-        get: function () {
-            var total = ZERO;
-            for (var i = 0; i < this.beatLengths.length; i++) {
-                total = total.plus(this.beatLengths[i].timesNum(this.beatCounts[i] || 1));
-            }
-            return total;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Bar;
-}(TimedEntity));
-export { Bar };
-var Cycle = (function (_super) {
-    __extends(Cycle, _super);
-    function Cycle(config) {
-        if (config === void 0) { config = null; }
-        var _this = _super.call(this, (config = config || {})) || this;
-        _this.name = config.name || "";
-        _this.bars = config.bars || [];
-        return _this;
-    }
-    Cycle.prototype.debugValue = function () {
-        return __assign(__assign({}, _super.prototype.debugValue.call(this)), { name: name, bars: this.bars.map(function (p) { return p.debugValue(); }) });
-    };
-    Cycle.prototype.children = function () {
-        return this.bars;
+        return this;
     };
-    Cycle.prototype.equals = function (another) {
-        if (!_super.prototype.equals.call(this, another)) {
-            return false;
-        }
-        if (this.bars.length != another.bars.length)
-            return false;
-        for (var i = 0; i < this.bars.length; i++) {
-            if (!this.bars[i].equals(another.bars[i]))
-                return false;
+    Group.prototype.addAtoms = function (adjustDuration) {
+        if (adjustDuration === void 0) { adjustDuration = false; }
+        var atoms = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            atoms[_i - 1] = arguments[_i];
         }
-        return true;
+        return this.insertAtomsAt.apply(this, __spreadArray([null, adjustDuration], __read(atoms), false));
     };
-    Cycle.prototype.getAtIndex = function (globalIndex) {
-        var cycle = 0;
-        while (globalIndex < 0) {
-            globalIndex += this.totalBeatCount;
-            cycle--;
-        }
-        if (globalIndex >= this.totalBeatCount) {
-            cycle = Math.floor(globalIndex / this.totalBeatCount);
+    Group.prototype.removeAtoms = function (adjustDuration) {
+        var e_2, _a;
+        if (adjustDuration === void 0) { adjustDuration = false; }
+        var atoms = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            atoms[_i - 1] = arguments[_i];
         }
-        globalIndex = globalIndex % this.totalBeatCount;
-        var offset = ZERO;
-        for (var barIndex = 0; barIndex < this.bars.length; barIndex++) {
-            var bar = this.bars[barIndex];
-            if (globalIndex >= bar.totalBeatCount) {
-                globalIndex -= bar.totalBeatCount;
-                offset = offset.plus(bar.duration);
-            }
-            else {
-                for (var beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {
-                    var beatLength = bar.beatLengths[beatIndex];
-                    var beatCount = bar.beatCounts[beatIndex] || 1;
-                    if (globalIndex >= beatCount) {
-                        globalIndex -= beatCount;
-                        offset = offset.plus(beatLength.timesNum(beatCount));
-                    }
-                    else {
-                        var instance = globalIndex;
-                        return [cycle, [barIndex, beatIndex, instance], offset.plus(beatLength.timesNum(instance))];
-                    }
+        adjustDuration = adjustDuration && !this.durationIsMultiplier;
+        var oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;
+        try {
+            for (var atoms_2 = __values(atoms), atoms_2_1 = atoms_2.next(); !atoms_2_1.done; atoms_2_1 = atoms_2.next()) {
+                var atom = atoms_2_1.value;
+                if (atom.parentGroup == this) {
+                    this.atoms.remove(atom);
+                    atom.parentGroup = null;
+                }
+                else if (atom.parentGroup != null) {
+                    throw new Error("Atom cannot be removed as it does not belong to this group");
                 }
             }
         }
-        throw new Error("Should not be here!");
-    };
-    Cycle.prototype.getPosition = function (globalOffset) {
-        var duration = this.duration;
-        var cycleNum = 0;
-        if (globalOffset.isLT(ZERO)) {
-            while (globalOffset.isLT(ZERO)) {
-                cycleNum--;
-                globalOffset = globalOffset.plus(duration);
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (atoms_2_1 && !atoms_2_1.done && (_a = atoms_2.return)) _a.call(atoms_2);
             }
+            finally { if (e_2) throw e_2.error; }
         }
-        else if (globalOffset.isGTE(duration)) {
-            var realOffset = globalOffset.mod(duration);
-            globalOffset = globalOffset.minus(realOffset).divby(duration);
-            TSU.assert(globalOffset.isWhole);
-            cycleNum = globalOffset.floor;
-            globalOffset = realOffset;
-        }
-        var globalIndex = 0;
-        for (var barIndex = 0; barIndex < this.bars.length; barIndex++) {
-            var bar = this.bars[barIndex];
-            var barDuration = bar.duration;
-            if (globalOffset.isGTE(barDuration)) {
-                globalOffset = globalOffset.minus(barDuration);
+        if (adjustDuration) {
+            if (this._duration.isZero) {
+                if (this.durationIsMultiplier)
+                    throw new Error("How can this be?");
+                this._duration = this.totalChildDuration;
             }
             else {
-                for (var beatIndex = 0; beatIndex < bar.beatCount; beatIndex++) {
-                    var beatLength = bar.beatLengths[beatIndex];
-                    var beatCount = bar.beatCounts[beatIndex] || 1;
-                    for (var instance = 0; instance < beatCount; instance++, globalIndex++) {
-                        if (globalOffset.isGTE(beatLength)) {
-                            globalOffset = globalOffset.minus(beatLength);
-                        }
-                        else {
-                            return [cycleNum, [barIndex, beatIndex, instance], globalOffset, globalIndex];
-                        }
-                    }
-                }
+                var scaleFactor = this.totalChildDuration.divby(oldChildDuration);
+                this._duration = this._duration.times(scaleFactor, true);
             }
-            globalIndex += bar.totalBeatCount;
         }
-        throw new Error("Should not be here!");
-    };
-    Cycle.prototype.iterateBeats = function (startBar, startBeat, startInstance) {
-        var barIndex, beatIndex, instanceIndex, currBar;
-        if (startBar === void 0) { startBar = 0; }
-        if (startBeat === void 0) { startBeat = 0; }
-        if (startInstance === void 0) { startInstance = 0; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    barIndex = startBar;
-                    beatIndex = startBeat;
-                    instanceIndex = startInstance;
-                    _a.label = 1;
-                case 1:
-                    if (!true) return [3, 3];
-                    currBar = this.bars[barIndex];
-                    return [4, [[barIndex, beatIndex, instanceIndex], currBar.beatLengths[beatIndex]]];
-                case 2:
-                    _a.sent();
-                    instanceIndex++;
-                    if (!currBar.beatCounts[beatIndex] || instanceIndex >= currBar.beatCounts[beatIndex]) {
-                        instanceIndex = 0;
-                        beatIndex++;
-                        if (beatIndex >= currBar.beatLengths.length) {
-                            beatIndex = 0;
-                            barIndex++;
-                            if (barIndex >= this.bars.length) {
-                                barIndex = 0;
-                            }
-                        }
-                    }
-                    return [3, 1];
-                case 3: return [2];
-            }
-        });
-    };
-    Cycle.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
-        another.name = this.name;
-        another.bars = this.bars.map(function (x) { return x.clone(); });
+        return this;
     };
-    Object.defineProperty(Cycle.prototype, "beatCount", {
-        get: function () {
-            var e_5, _a;
-            var out = 0;
-            try {
-                for (var _b = __values(this.bars), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var bar = _c.value;
-                    out += bar.beatCount;
-                }
-            }
-            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; }
-            }
-            return out;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Cycle.prototype, "totalBeatCount", {
-        get: function () {
-            var e_6, _a;
-            var out = 0;
-            try {
-                for (var _b = __values(this.bars), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var bar = _c.value;
-                    out += bar.totalBeatCount;
-                }
-            }
-            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 out;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Cycle.prototype, "duration", {
-        get: function () {
-            return this.bars.reduce(function (x, y) { return x.plus(y.duration); }, ZERO);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Cycle.DEFAULT = new Cycle({
-        name: "Adi Thalam",
-        bars: [
-            new Bar({ name: "Laghu", beatLengths: [1, 1, 1, 1] }),
-            new Bar({ name: "Dhrutam", beatLengths: [1, 1] }),
-            new Bar({ name: "Dhrutam", beatLengths: [1, 1] }),
-        ],
-    });
-    return Cycle;
-}(TimedEntity));
-export { Cycle };
+    return Group;
+}(Atom));
+export { Group };
 var Line = (function (_super) {
     __extends(Line, _super);
     function Line() {
@@ -857,7 +489,7 @@ var Line = (function (_super) {
     }
     Object.defineProperty(Line.prototype, "isEmpty", {
         get: function () {
-            var e_7, _a;
+            var e_3, _a;
             try {
                 for (var _b = __values(this.roles), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var r = _c.value;
@@ -865,12 +497,12 @@ var Line = (function (_super) {
                         return false;
                 }
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_7) throw e_7.error; }
+                finally { if (e_3) throw e_3.error; }
             }
             return true;
         },
@@ -909,7 +541,7 @@ var Line = (function (_super) {
     };
     Object.defineProperty(Line.prototype, "duration", {
         get: function () {
-            var e_8, _a;
+            var e_4, _a;
             var max = ZERO;
             try {
                 for (var _b = __values(this.roles), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -917,12 +549,12 @@ var Line = (function (_super) {
                     max = TSU.Num.Fraction.max(role.duration, max);
                 }
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_8) throw e_8.error; }
+                finally { if (e_4) throw e_4.error; }
             }
             return max;
         },
@@ -953,15 +585,15 @@ var Role = (function (_super) {
         return { name: this.name, atoms: this.atoms.map(function (a) { return a.debugValue(); }) };
     };
     Role.prototype.addAtoms = function () {
-        var e_9, _a;
+        var e_5, _a;
         var atoms = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             atoms[_i] = arguments[_i];
         }
         var last = null;
         try {
-            for (var atoms_2 = __values(atoms), atoms_2_1 = atoms_2.next(); !atoms_2_1.done; atoms_2_1 = atoms_2.next()) {
-                var atom = atoms_2_1.value;
+            for (var atoms_3 = __values(atoms), atoms_3_1 = atoms_3.next(); !atoms_3_1.done; atoms_3_1 = atoms_3.next()) {
+                var atom = atoms_3_1.value;
                 if (atom.type == AtomType.REST) {
                     if (last && last.type != AtomType.GROUP && last.type != AtomType.LABEL) {
                         last.beforeRest = true;
@@ -973,12 +605,12 @@ var Role = (function (_super) {
                 last = atom;
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
-                if (atoms_2_1 && !atoms_2_1.done && (_a = atoms_2.return)) _a.call(atoms_2);
+                if (atoms_3_1 && !atoms_3_1.done && (_a = atoms_3.return)) _a.call(atoms_3);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_5) throw e_5.error; }
         }
     };
     Role.prototype.copyTo = function (another) {