notations 0.0.46 → 0.0.49

package/lib/esm/core.js

@@ -1,69 +1,7 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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));
-};
-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;
+const ZERO = TSU.Num.Fraction.ZERO;
+const ONE = TSU.Num.Fraction.ONE;
 export var AtomType;
 (function (AtomType) {
     AtomType["NOTE"] = "Note";
@@ -73,272 +11,239 @@ export var AtomType;
     AtomType["GROUP"] = "Group";
     AtomType["LABEL"] = "Label";
     AtomType["REST"] = "Rest";
+    AtomType["MARKER"] = "Marker";
 })(AtomType || (AtomType = {}));
-var Atom = (function (_super) {
-    __extends(Atom, _super);
-    function Atom(duration) {
-        if (duration === void 0) { duration = ONE; }
-        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 () {
-        var out = _super.prototype.debugValue.call(this);
+export class Atom extends TimedEntity {
+    constructor(duration = ONE) {
+        super();
+        this.nextSibling = null;
+        this.prevSibling = null;
+        this.parentGroup = null;
+        this.isContinuation = false;
+        this._duration = duration || ONE;
+    }
+    debugValue() {
+        const out = super.debugValue();
         if (!this.duration.isOne) {
             out.duration = this.duration.factorized.toString();
         }
         if (this.isContinuation) {
             out.isContinuation = true;
         }
+        if ((this.markersBefore || []).length > 0) {
+            out.mbef = this.markersBefore.map((m) => m.debugValue());
+        }
+        if ((this.markersAfter || []).length > 0) {
+            out.maft = this.markersAfter.map((m) => m.debugValue());
+        }
         return out;
-    };
-    Atom.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
+    }
+    copyTo(another) {
+        super.copyTo(another);
         another._duration = new TSU.Num.Fraction(this.duration.num, this.duration.den);
-    };
-    Object.defineProperty(Atom.prototype, "duration", {
-        get: function () {
-            return this._duration;
-        },
-        set: function (d) {
-            this._duration = d;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Atom;
-}(TimedEntity));
-export { Atom };
-var LeafAtom = (function (_super) {
-    __extends(LeafAtom, _super);
-    function LeafAtom() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.beforeRest = false;
-        return _this;
-    }
-    LeafAtom.prototype.splitAt = function (duration) {
+    }
+    get duration() {
+        return this._duration;
+    }
+    set duration(d) {
+        this._duration = d;
+    }
+}
+export class LeafAtom extends Atom {
+    constructor() {
+        super(...arguments);
+        this.beforeRest = false;
+    }
+    splitAt(duration) {
         if (this.duration.cmp(duration) > 0) {
-            var spillOver = this.createSpilloverSpace(this.duration.minus(duration));
+            const spillOver = this.createSpilloverSpace(this.duration.minus(duration));
             spillOver.isContinuation = true;
             this.duration = duration;
             return spillOver;
         }
         return null;
-    };
-    LeafAtom.prototype.createSpilloverSpace = function (duration) {
+    }
+    createSpilloverSpace(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);
-    };
-    return LeafAtom;
-}(Atom));
-export { LeafAtom };
-var Rest = (function (_super) {
-    __extends(Rest, _super);
-    function Rest() {
-        return _super.call(this, ZERO) || this;
-    }
-    return Rest;
-}(LeafAtom));
-export { Rest };
-var Space = (function (_super) {
-    __extends(Space, _super);
-    function Space(duration, isSilent) {
-        if (duration === void 0) { duration = ONE; }
-        if (isSilent === void 0) { isSilent = false; }
-        var _this = _super.call(this, duration) || this;
-        _this.isSilent = false;
-        _this.isSilent = isSilent;
-        return _this;
-    }
-    Space.prototype.debugValue = function () {
-        return __assign(__assign({}, _super.prototype.debugValue.call(this)), { isSilent: this.isSilent });
-    };
-    Space.prototype.toString = function () {
-        return "Space(".concat(this.duration, "-").concat(this.isSilent, ")");
-    };
-    Space.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
+    }
+    debugValue() {
+        return this.beforeRest ? Object.assign(Object.assign({}, super.debugValue()), { beforeRest: true }) : super.debugValue();
+    }
+}
+export class Marker extends Entity {
+    constructor(text, isBefore = true) {
+        super();
+        this.text = text;
+        this.isBefore = isBefore;
+    }
+    debugValue() {
+        return Object.assign(Object.assign({}, super.debugValue()), { text: this.text, before: this.isBefore });
+    }
+    toString() {
+        return `Marker(${this.text}-${this.isBefore})`;
+    }
+}
+export class Rest extends LeafAtom {
+    constructor() {
+        super(ZERO);
+    }
+}
+export class Space extends LeafAtom {
+    constructor(duration = ONE, isSilent = false) {
+        super(duration);
+        this.isSilent = false;
+        this.isSilent = isSilent;
+    }
+    debugValue() {
+        return Object.assign(Object.assign({}, super.debugValue()), { isSilent: this.isSilent });
+    }
+    toString() {
+        return `Space(${this.duration}-${this.isSilent})`;
+    }
+    copyTo(another) {
+        super.copyTo(another);
         another.isSilent = this.isSilent;
-    };
-    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);
+    }
+    equals(another) {
+        return super.equals(another) && this.isSilent == another.isSilent;
+    }
+    createSpilloverSpace(duration) {
+        const out = super.createSpilloverSpace(duration);
         out.isSilent = this.isSilent;
         return out;
-    };
-    return Space;
-}(LeafAtom));
-export { Space };
-var Literal = (function (_super) {
-    __extends(Literal, _super);
-    function Literal(value, duration) {
-        if (duration === void 0) { duration = ONE; }
-        var _this = _super.call(this, duration) || this;
-        _this.value = value;
-        _this.embelishments = [];
-        return _this;
-    }
-    Literal.prototype.debugValue = function () {
-        var out = __assign(__assign({}, _super.prototype.debugValue.call(this)), { value: this.value });
+    }
+}
+export class Literal extends LeafAtom {
+    constructor(value, duration = ONE) {
+        super(duration);
+        this.value = value;
+        this.embelishments = [];
+    }
+    debugValue() {
+        const out = Object.assign(Object.assign({}, super.debugValue()), { value: this.value });
         if (this.embelishments.length > 0) {
-            out.embs = this.embelishments.map(function (e) { return ("debugValue" in e ? e.debugValue() : e); });
+            out.embs = this.embelishments.map((e) => ("debugValue" in e ? e.debugValue() : e));
         }
         return out;
-    };
-    Literal.prototype.toString = function () {
-        return "Lit(".concat(this.duration, "-").concat(this.value, ")");
-    };
-    Literal.prototype.equals = function (another) {
-        return _super.prototype.equals.call(this, another) && this.value == another.value;
-    };
-    Literal.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
+    }
+    toString() {
+        return `Lit(${this.duration}-${this.value})`;
+    }
+    equals(another) {
+        return super.equals(another) && this.value == another.value;
+    }
+    copyTo(another) {
+        super.copyTo(another);
         another.value = this.value;
-    };
-    return Literal;
-}(LeafAtom));
-export { Literal };
-var Syllable = (function (_super) {
-    __extends(Syllable, _super);
-    function Syllable() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    Syllable.fromLit = function (lit) {
+    }
+}
+export class Syllable extends Literal {
+    static fromLit(lit) {
         if (lit.type == AtomType.SYLLABLE)
             return lit;
-        var out = new Syllable(lit.value, lit.duration);
+        const out = new Syllable(lit.value, lit.duration);
         out.embelishments = lit.embelishments;
         out.beforeRest = lit.beforeRest;
         return out;
-    };
-    Syllable.prototype.toString = function () {
-        return "Syll(".concat(this.duration, "-").concat(this.value, ")");
-    };
-    return Syllable;
-}(Literal));
-export { Syllable };
-var Note = (function (_super) {
-    __extends(Note, _super);
-    function Note(value, duration, octave, shift) {
-        if (duration === void 0) { duration = ONE; }
-        if (octave === void 0) { octave = 0; }
-        if (shift === void 0) { shift = 0; }
-        var _this = _super.call(this, value, duration) || this;
-        _this.octave = 0;
-        _this.shift = 0;
-        _this.octave = octave;
-        _this.shift = shift;
-        return _this;
-    }
-    Note.fromLit = function (lit) {
+    }
+    toString() {
+        return `Syll(${this.duration}-${this.value})`;
+    }
+}
+export class Note extends Literal {
+    constructor(value, duration = ONE, octave = 0, shift = 0) {
+        super(value, duration);
+        this.octave = 0;
+        this.shift = 0;
+        this.octave = octave;
+        this.shift = shift;
+    }
+    static fromLit(lit) {
         if (lit.type == AtomType.NOTE)
             return lit;
-        var out = new Note(lit.value, lit.duration);
+        const out = new Note(lit.value, lit.duration);
         out.embelishments = lit.embelishments;
         out.beforeRest = lit.beforeRest;
         return out;
-    };
-    Note.prototype.debugValue = function () {
-        var out = __assign({}, _super.prototype.debugValue.call(this));
+    }
+    debugValue() {
+        const out = Object.assign({}, super.debugValue());
         if (this.octave != 0)
             out.octave = this.octave;
         if (this.shift != 0)
             out.shift = this.shift;
         return out;
-    };
-    Note.prototype.toString = function () {
-        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;
-    };
-    Note.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
+    }
+    toString() {
+        return `Note(${this.duration}-${this.value}-${this.octave})`;
+    }
+    equals(another) {
+        return super.equals(another) && this.octave == another.octave && this.shift == another.shift;
+    }
+    copyTo(another) {
+        super.copyTo(another);
         another.octave = this.octave;
         another.shift = this.shift;
-    };
-    return Note;
-}(Literal));
-export { Note };
-var Group = (function (_super) {
-    __extends(Group, _super);
-    function Group() {
-        var atoms = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            atoms[_i] = arguments[_i];
-        }
-        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([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))
+    }
+}
+export class Group extends Atom {
+    constructor(...atoms) {
+        super(atoms.length == 0 ? ZERO : ONE);
+        this.durationIsMultiplier = false;
+        this.atoms = new TSU.Lists.ValueList();
+        this.addAtoms(false, ...atoms);
+    }
+    equals(another, expect = false) {
+        if (!super.equals(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);
+        return this.atoms.equals(another.atoms, (a1, a2) => a1.equals(a2));
+    }
+    copyTo(another) {
+        super.copyTo(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) {
-                return this.totalChildDuration.divby(this._duration);
-            }
-            else {
-                return this._duration;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Group.prototype.setDurationAsMultiplier = function (asMultiplier) {
-        if (asMultiplier === void 0) { asMultiplier = true; }
+        this.atoms.forEach((atom) => another.atoms.add(atom.clone()));
+    }
+    get duration() {
+        if (this.durationIsMultiplier) {
+            return this.totalChildDuration.divby(this._duration);
+        }
+        else {
+            return this._duration;
+        }
+    }
+    setDurationAsMultiplier(asMultiplier = true) {
         this.durationIsMultiplier = asMultiplier;
         return this;
-    };
-    Group.prototype.setDuration = function (d, asMultiplier) {
-        if (asMultiplier === void 0) { asMultiplier = false; }
+    }
+    setDuration(d, 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(); }) });
+    }
+    debugValue() {
+        const out = Object.assign(Object.assign({}, super.debugValue()), { atoms: Array.from(this.atoms.values(), (a) => a.debugValue()) });
         if (this.durationIsMultiplier)
             out.durationIsMultiplier = true;
         return out;
-    };
-    Group.prototype.splitAt = function (requiredDuration) {
+    }
+    splitAt(requiredDuration) {
         if (this.duration.isLTE(requiredDuration) || requiredDuration.isLTE(ZERO)) {
             return null;
         }
-        var targetGroup = new Group();
+        const 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
+        let remainingDur = this.duration;
+        const totalChildDuration = this.totalChildDuration;
+        const 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);
+            const lastChild = this.atoms.last;
+            const childDuration = lastChild.duration.times(durationFactor);
+            const newDuration = remainingDur.minus(childDuration);
             if (newDuration.isGTE(requiredDuration)) {
                 this.removeAtoms(true, lastChild);
                 targetGroup.insertAtomsAt(targetGroup.atoms.first, true, lastChild);
@@ -347,8 +252,8 @@ var Group = (function (_super) {
                 }
             }
             else {
-                var newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);
-                var spillOver = lastChild.splitAt(newRequiredDur);
+                const newRequiredDur = requiredDuration.minus(newDuration, true).divby(durationFactor, true);
+                const spillOver = lastChild.splitAt(newRequiredDur);
                 if (spillOver == null) {
                     throw new Error("Spill over cannot be null here");
                 }
@@ -366,52 +271,32 @@ var Group = (function (_super) {
             remainingDur = newDuration;
         }
         return targetGroup;
-    };
-    Object.defineProperty(Group.prototype, "totalChildDuration", {
-        get: function () {
-            var out = ZERO;
-            this.atoms.forEach(function (atom) { return (out = out.plus(atom.duration)); });
-            return out;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Group.prototype.insertAtomsAt = function (beforeAtom, adjustDuration) {
-        var e_1, _a;
-        if (adjustDuration === void 0) { adjustDuration = false; }
-        var atoms = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            atoms[_i - 2] = arguments[_i];
-        }
+    }
+    get totalChildDuration() {
+        let out = ZERO;
+        this.atoms.forEach((atom) => (out = out.plus(atom.duration)));
+        return out;
+    }
+    insertAtomsAt(beforeAtom, adjustDuration = false, ...atoms) {
         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) {
-                        last.beforeRest = true;
-                    }
+        const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;
+        for (const atom of atoms) {
+            if (atom.parentGroup != null) {
+                if (atom.parentGroup != this) {
+                    throw new Error("Atom belongs to another parent.  Remove it first");
                 }
-                else {
-                    atom.parentGroup = this;
-                    this.atoms.add(atom, beforeAtom);
+                atom.parentGroup.removeAtoms(false, atom);
+            }
+            if (atom.type == AtomType.REST) {
+                const last = this.atoms.last;
+                if (last && last.type != AtomType.GROUP && last.type != AtomType.LABEL) {
+                    last.beforeRest = true;
                 }
             }
-        }
-        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);
+            else {
+                atom.parentGroup = this;
+                this.atoms.add(atom, beforeAtom);
             }
-            finally { if (e_1) throw e_1.error; }
         }
         if (adjustDuration) {
             if (this._duration.isZero) {
@@ -420,47 +305,26 @@ var Group = (function (_super) {
                 this._duration = this.totalChildDuration;
             }
             else {
-                var scaleFactor = this.totalChildDuration.divby(oldChildDuration);
+                const scaleFactor = this.totalChildDuration.divby(oldChildDuration);
                 this._duration = this._duration.times(scaleFactor, true);
             }
         }
         return this;
-    };
-    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 this.insertAtomsAt.apply(this, __spreadArray([null, adjustDuration], __read(atoms), false));
-    };
-    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];
-        }
+    }
+    addAtoms(adjustDuration = false, ...atoms) {
+        return this.insertAtomsAt(null, adjustDuration, ...atoms);
+    }
+    removeAtoms(adjustDuration = false, ...atoms) {
         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");
-                }
+        const oldChildDuration = adjustDuration ? this.totalChildDuration : ONE;
+        for (const atom of atoms) {
+            if (atom.parentGroup == this) {
+                this.atoms.remove(atom);
+                atom.parentGroup = null;
             }
-        }
-        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);
+            else if (atom.parentGroup != null) {
+                throw new Error("Atom cannot be removed as it does not belong to this group");
             }
-            finally { if (e_2) throw e_2.error; }
         }
         if (adjustDuration) {
             if (this._duration.isZero) {
@@ -469,161 +333,100 @@ var Group = (function (_super) {
                 this._duration = this.totalChildDuration;
             }
             else {
-                var scaleFactor = this.totalChildDuration.divby(oldChildDuration);
+                const scaleFactor = this.totalChildDuration.divby(oldChildDuration);
                 this._duration = this._duration.times(scaleFactor, true);
             }
         }
         return this;
-    };
-    return Group;
-}(Atom));
-export { Group };
-var Line = (function (_super) {
-    __extends(Line, _super);
-    function Line() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.offset = ZERO;
-        _this.roles = [];
-        _this.marginText = "";
-        return _this;
-    }
-    Object.defineProperty(Line.prototype, "isEmpty", {
-        get: function () {
-            var e_3, _a;
-            try {
-                for (var _b = __values(this.roles), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var r = _c.value;
-                    if (!r.isEmpty)
-                        return false;
-                }
-            }
-            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_3) throw e_3.error; }
-            }
-            return true;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Line.prototype.debugValue = function () {
-        var out = __assign(__assign({}, _super.prototype.debugValue.call(this)), { roles: this.roles.map(function (r) { return r.debugValue(); }) });
+    }
+}
+export class Line extends Entity {
+    constructor() {
+        super(...arguments);
+        this.offset = ZERO;
+        this.roles = [];
+        this.marginText = "";
+    }
+    indexOfRole(name) {
+        for (let i = 0; i < this.roles.length; i++) {
+            if (this.roles[i].name == name)
+                return i;
+        }
+        return -1;
+    }
+    get isEmpty() {
+        for (const r of this.roles)
+            if (!r.isEmpty)
+                return false;
+        return true;
+    }
+    debugValue() {
+        const out = Object.assign(Object.assign({}, super.debugValue()), { roles: this.roles.map((r) => r.debugValue()) });
         if (!this.offset.isZero) {
             out.offset = this.offset.toString();
         }
         return out;
-    };
-    Line.prototype.copyTo = function (another) {
-        _super.prototype.copyTo.call(this, another);
-        another.roles = this.roles.map(function (r) { return r.clone(); });
-    };
-    Line.prototype.addAtoms = function (roleName, defaultToNotes) {
-        var atoms = [];
-        for (var _i = 2; _i < arguments.length; _i++) {
-            atoms[_i - 2] = arguments[_i];
-        }
-        var role = this.ensureRole(roleName, defaultToNotes);
-        role.addAtoms.apply(role, __spreadArray([], __read(atoms), false));
+    }
+    copyTo(another) {
+        super.copyTo(another);
+        another.roles = this.roles.map((r) => r.clone());
+    }
+    addAtoms(roleName, defaultToNotes, ...atoms) {
+        const role = this.ensureRole(roleName, defaultToNotes);
+        role.addAtoms(...atoms);
         return this;
-    };
-    Line.prototype.ensureRole = function (roleName, defaultToNotes) {
-        var ri = this.roles.findIndex(function (r) { return r.name == roleName; });
+    }
+    ensureRole(roleName, defaultToNotes) {
+        let ri = this.roles.findIndex((r) => r.name == roleName);
         if (ri < 0) {
             ri = this.roles.length;
-            var role = new Role(this, roleName);
+            const role = new Role(this, roleName);
             role.defaultToNotes = defaultToNotes;
             this.roles.push(role);
         }
         return this.roles[ri];
-    };
-    Object.defineProperty(Line.prototype, "duration", {
-        get: function () {
-            var e_4, _a;
-            var max = ZERO;
-            try {
-                for (var _b = __values(this.roles), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var role = _c.value;
-                    max = TSU.Num.Fraction.max(role.duration, max);
-                }
-            }
-            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_4) throw e_4.error; }
-            }
-            return max;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Line;
-}(Entity));
-export { Line };
-var Role = (function (_super) {
-    __extends(Role, _super);
-    function Role(line, name) {
-        var _this = _super.call(this) || this;
-        _this.line = line;
-        _this.name = name;
-        _this.defaultToNotes = true;
-        _this.atoms = [];
-        return _this;
-    }
-    Object.defineProperty(Role.prototype, "isEmpty", {
-        get: function () {
-            return this.atoms.length == 0;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Role.prototype.debugValue = function () {
-        return { name: this.name, atoms: this.atoms.map(function (a) { return a.debugValue(); }) };
-    };
-    Role.prototype.addAtoms = function () {
-        var e_5, _a;
-        var atoms = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            atoms[_i] = arguments[_i];
+    }
+    get duration() {
+        let max = ZERO;
+        for (const role of this.roles) {
+            max = TSU.Num.Fraction.max(role.duration, max);
         }
-        var last = null;
-        try {
-            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;
-                    }
-                }
-                else {
-                    this.atoms.push(atom);
+        return max;
+    }
+}
+export class Role extends Entity {
+    constructor(line, name) {
+        super();
+        this.line = line;
+        this.name = name;
+        this.defaultToNotes = true;
+        this.atoms = [];
+    }
+    get isEmpty() {
+        return this.atoms.length == 0;
+    }
+    debugValue() {
+        return { name: this.name, atoms: this.atoms.map((a) => a.debugValue()) };
+    }
+    addAtoms(...atoms) {
+        let last = null;
+        for (const atom of atoms) {
+            if (atom.type == AtomType.REST) {
+                if (last && last.type != AtomType.GROUP && last.type != AtomType.LABEL) {
+                    last.beforeRest = true;
                 }
-                last = atom;
             }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (atoms_3_1 && !atoms_3_1.done && (_a = atoms_3.return)) _a.call(atoms_3);
+            else {
+                this.atoms.push(atom);
             }
-            finally { if (e_5) throw e_5.error; }
+            last = atom;
         }
-    };
-    Role.prototype.copyTo = function (another) {
-        another.addAtoms.apply(another, __spreadArray([], __read(this.atoms), false));
-    };
-    Object.defineProperty(Role.prototype, "duration", {
-        get: function () {
-            return this.atoms.reduce(function (a, b) { return a.plus(b.duration); }, ZERO);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Role;
-}(Entity));
-export { Role };
+    }
+    copyTo(another) {
+        another.addAtoms(...this.atoms);
+    }
+    get duration() {
+        return this.atoms.reduce((a, b) => a.plus(b.duration), ZERO);
+    }
+}
 //# sourceMappingURL=core.js.map