Fixing types & imports pt.4

src/Common/DataObjects/fraction.ts

@@ -242,9 +242,9 @@ export class Fraction /*implements IComparable, IComparer<Fraction> */{
     //public static get MaxAllowedDenominator(): number {
     //    return Fraction.maximumAllowedNumber;
     //}
-    //public ToString(): string {
-    //    return this.numerator.ToString() + "/" + this.denominator.ToString();
-    //}
+    public ToString(): string {
+        return this.numerator + "/" + this.denominator;
+    }
     //public ToFloatingString(): string {
     //    return this.RealValue.ToString();
     //}

src/MusicalScore/MusicParts/MusicPartManagerIterator.ts

@@ -10,6 +10,7 @@ import {SourceStaffEntry} from "../VoiceData/SourceStaffEntry";
 import {VerticalSourceStaffEntryContainer} from "../VoiceData/VerticalSourceStaffEntryContainer";
 import {RhythmInstruction} from "../VoiceData/Instructions/RhythmInstruction";
 import {AbstractNotationInstruction} from "../VoiceData/Instructions/AbstractNotationInstruction";
+import {RepetitionInstruction} from "../VoiceData/Instructions/RepetitionInstruction";
 
 // FIXME:
 type ContinuousDynamicExpression = AbstractExpression;
@@ -24,8 +25,8 @@ export class MusicPartManagerIterator {
             this.manager = manager;
             this.currentVoiceEntries = undefined;
             this.frontReached = false;
-            for (let rep of manager.MusicSheet.Repetitions.length) {
-                this.repetitionIterationCountDict[rep] = 1;
+            for (let rep of manager.MusicSheet.Repetitions) {
+                this.setRepetitionIterationCount(rep, 1);
             }
             this.activeDynamicExpressions = new Array(manager.MusicSheet.getCompleteNumberOfStaves());
             this.currentMeasure = this.manager.MusicSheet.SourceMeasures[0];
@@ -67,7 +68,9 @@ export class MusicPartManagerIterator {
     private currentVoiceEntries: VoiceEntry[];
     private currentDynamicChangingExpressions: DynamicsContainer[] = new Array();
     private currentTempoChangingExpression: MultiTempoExpression;
-    private repetitionIterationCountDict: { [rep: Repetition] : number; } = {};
+    // FIXME: replace these two with a real Dictionary!
+    private repetitionIterationCountDictKeys: Repetition[];
+    private repetitionIterationCountDictValues: number[];
     private currentRepetition: Repetition = undefined;
     private endReached: boolean = false;
     private frontReached: boolean = false;
@@ -91,13 +94,13 @@ export class MusicPartManagerIterator {
     }
     public get CurrentRepetitionIteration(): number {
         if (this.CurrentRepetition !== undefined) {
-            return this.repetitionIterationCountDict[this.CurrentRepetition];
+            return this.getRepetitionIterationCount(this.CurrentRepetition)
         }
         return 0;
     }
     public get CurrentJumpResponsibleRepetitionIterationBeforeJump(): number {
         if (this.jumpResponsibleRepetition !== undefined) {
-            return this.repetitionIterationCountDict[this.jumpResponsibleRepetition] - 1;
+            return this.getRepetitionIterationCount(this.jumpResponsibleRepetition) - 1;
         }
         return 0;
     }
@@ -108,7 +111,7 @@ export class MusicPartManagerIterator {
         return this.currentMeasureIndex;
     }
     public get CurrentEnrolledTimestamp(): Fraction {
-        return this.currentEnrolledMeasureTimestamp + this.currentVerticalContainerInMeasureTimestamp;
+        return Fraction.plus(this.currentEnrolledMeasureTimestamp, this.currentVerticalContainerInMeasureTimestamp);
     }
     public get CurrentSourceTimestamp(): Fraction {
         return this.currentTimeStamp;
@@ -138,81 +141,71 @@ export class MusicPartManagerIterator {
         ret.frontReached = this.frontReached;
         return ret;
     }
-    public CurrentVisibleVoiceEntries(instrument: Instrument): VoiceEntry[] {
-        let ret: VoiceEntry[] = new Array();
+
+    public CurrentVisibleVoiceEntries(instrument?: Instrument): VoiceEntry[] {
+        let voiceEntries: VoiceEntry[] = new Array();
         if (this.currentVoiceEntries === undefined) {
-            return ret;
+            return voiceEntries;
         }
-        for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-            let entry: VoiceEntry = this.currentVoiceEntries[idx];
-            if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
-                this.getVisibleEntries(entry, ret);
-                return ret;
+        if (instrument !== undefined) {
+            for (let entry of this.currentVoiceEntries) {
+                if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
+                    this.getVisibleEntries(entry, voiceEntries);
+                    return voiceEntries;
+                }
             }
-        }
-        return ret;
-    }
-    public CurrentVisibleVoiceEntries(): VoiceEntry[] {
-        let voiceEntries: VoiceEntry[] = new Array();
-        if (this.currentVoiceEntries !== undefined) {
-            for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-                let entry: VoiceEntry = this.currentVoiceEntries[idx];
+        } else {
+            for (let entry of this.currentVoiceEntries) {
                 this.getVisibleEntries(entry, voiceEntries);
             }
         }
         return voiceEntries;
     }
-    public CurrentAudibleVoiceEntries(instrument: Instrument): VoiceEntry[] {
-        let ret: VoiceEntry[] = new Array();
+
+    public CurrentAudibleVoiceEntries(instrument?: Instrument): VoiceEntry[] {
+        let voiceEntries: VoiceEntry[] = new Array();
         if (this.currentVoiceEntries === undefined) {
-            return ret;
+            return voiceEntries;
         }
-        for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-            let entry: VoiceEntry = this.currentVoiceEntries[idx];
-            if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
-                this.getAudibleEntries(entry, ret);
-                return ret;
+        if (instrument !== undefined) {
+            for (let entry of this.currentVoiceEntries) {
+                if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
+                    this.getAudibleEntries(entry, voiceEntries);
+                    return voiceEntries;
+                }
             }
-        }
-        return ret;
-    }
-    public CurrentAudibleVoiceEntries(): VoiceEntry[] {
-        let voiceEntries: VoiceEntry[] = new Array();
-        if (this.currentVoiceEntries !== undefined) {
-            for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-                let entry: VoiceEntry = this.currentVoiceEntries[idx];
+        } else {
+            for (let entry of this.currentVoiceEntries) {
                 this.getAudibleEntries(entry, voiceEntries);
             }
         }
         return voiceEntries;
     }
+
     public getCurrentDynamicChangingExpressions(): DynamicsContainer[] {
         return this.currentDynamicChangingExpressions;
     }
-    public CurrentScoreFollowingVoiceEntries(instrument: Instrument): VoiceEntry[] {
-        let ret: VoiceEntry[] = new Array();
+
+    public CurrentScoreFollowingVoiceEntries(instrument?: Instrument): VoiceEntry[] {
+        let voiceEntries: VoiceEntry[] = new Array();
         if (this.currentVoiceEntries === undefined) {
-            return ret;
+            return voiceEntries;
         }
-        for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-            let entry: VoiceEntry = this.currentVoiceEntries[idx];
-            if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
-                this.getScoreFollowingEntries(entry, ret);
-                return ret;
+        if (instrument !== undefined) {
+            for (let entry of this.currentVoiceEntries) {
+                if (entry.ParentVoice.Parent.IdString === instrument.IdString) {
+                    this.getScoreFollowingEntries(entry, voiceEntries);
+                    return voiceEntries;
+                }
             }
-        }
-        return ret;
-    }
-    public CurrentScoreFollowingVoiceEntries(): VoiceEntry[] {
-        let voiceEntries: VoiceEntry[] = new Array();
-        if (this.currentVoiceEntries !== undefined) {
-            for (let idx: number = 0, len: number = this.currentVoiceEntries.length; idx < len; ++idx) {
-                let entry: VoiceEntry = this.currentVoiceEntries[idx];
+        } else {
+            for (let entry of this.currentVoiceEntries) {
                 this.getScoreFollowingEntries(entry, voiceEntries);
             }
         }
         return voiceEntries;
     }
+
     //public currentPlaybackSettings(): PlaybackSettings {
     //    return this.manager.MusicSheet.SheetPlaybackSetting;
     //}
@@ -238,17 +231,27 @@ export class MusicPartManagerIterator {
         return 1;
     }
     private incrementRepetitionIterationCount(repetition: Repetition): number {
-        if (this.repetitionIterationCountDict[repetition] !== undefined) {
-            let newIteration: number = this.repetitionIterationCountDict[repetition] + 1;
-            this.repetitionIterationCountDict[repetition] = newIteration;
-            return newIteration;
+        if (this.repetitionIterationCountDictKeys.indexOf(repetition) === -1) {
+            return this.setRepetitionIterationCount(repetition, 1);
         } else {
-            this.repetitionIterationCountDict[repetition] = 1;
-            return 1;
+            return this.setRepetitionIterationCount(repetition, this.getRepetitionIterationCount(repetition) + 1);
         }
     }
-    private setRepetitionIterationCount(repetition: Repetition, iterationCount: number): void {
-        this.repetitionIterationCountDict[repetition] = iterationCount;
+    private setRepetitionIterationCount(repetition: Repetition, iterationCount: number): number {
+        let i: number = this.repetitionIterationCountDictKeys.indexOf(repetition);
+        if (i == -1) {
+            this.repetitionIterationCountDictKeys.push(repetition);
+            this.repetitionIterationCountDictValues.push(iterationCount);
+        } else {
+            this.repetitionIterationCountDictValues[i] = iterationCount;
+        }
+        return iterationCount;
+    }
+    private getRepetitionIterationCount(rep: Repetition): number {
+        let i: number = this.repetitionIterationCountDictKeys.indexOf(rep);
+        if (i != -1) {
+            return this.repetitionIterationCountDictValues[i];
+        }
     }
 /*    private moveTempoIndexToTimestamp(measureNumber: number): void {
         for (let index: number = 0; index < this.manager.MusicSheet.TimestampSortedTempoExpressionsList.length; index++) {
@@ -293,6 +296,7 @@ export class MusicPartManagerIterator {
         }
         return this.manager.MusicSheet.TimestampSortedDynamicExpressionsList[this.currentDynamicEntryIndex + 1].parMultiExpression().AbsoluteTimestamp;
     }
+    */
     private handleRepetitionsAtMeasureBegin(): void {
         for (let idx: number = 0, len: number = this.currentMeasure.FirstRepetitionInstructions.length; idx < len; ++idx) {
             let repetitionInstruction: RepetitionInstruction = this.currentMeasure.FirstRepetitionInstructions[idx];
@@ -312,14 +316,14 @@ export class MusicPartManagerIterator {
             }
         }
     }
-*/
+
     private handleRepetitionsAtMeasureEnd(): void {
         for (let idx: number = 0, len: number = this.currentMeasure.LastRepetitionInstructions.length; idx < len; ++idx) {
             let repetitionInstruction: RepetitionInstruction = this.currentMeasure.LastRepetitionInstructions[idx];
             let currentRepetition: Repetition = repetitionInstruction.ParentRepetition;
             if (currentRepetition === undefined) { continue; }
-            if (currentRepetition.BackwardJumpInstructions[repetitionInstruction] !== undefined) {
-                if (this.repetitionIterationCountDict[currentRepetition] < currentRepetition.UserNumberOfRepetitions) {
+            if (currentRepetition.BackwardJumpInstructions.indexOf(repetitionInstruction) > -1) {
+                if (this.getRepetitionIterationCount(currentRepetition) < currentRepetition.UserNumberOfRepetitions) {
                     this.doBackJump(currentRepetition);
                     this.BackJumpOccurred = true;
                     return;
@@ -336,7 +340,7 @@ export class MusicPartManagerIterator {
                 }
 
                 let forwardJumpTargetMeasureIndex: number = currentRepetition.getForwardJumpTargetForIteration(
-                  this.repetitionIterationCountDict[currentRepetition]
+                  this.getRepetitionIterationCount(currentRepetition)
                 );
                 if (forwardJumpTargetMeasureIndex >= 0) {
                     this.currentMeasureIndex = forwardJumpTargetMeasureIndex;
@@ -409,12 +413,12 @@ export class MusicPartManagerIterator {
             }
             this.currentDynamicEntryIndex++;
         }
-        this.currentDynamicChangingExpressions.Clear();
+        this.currentDynamicChangingExpressions = [];
         for (let staffIndex: number = 0; staffIndex < this.activeDynamicExpressions.length; staffIndex++) {
             if (this.activeDynamicExpressions[staffIndex] !== undefined) {
                 let startTime: Fraction;
                 let endTime: Fraction;
-                if (this.activeDynamicExpressions[staffIndex] instanceof ContinuousDynamicExpression) {
+                /*if (this.activeDynamicExpressions[staffIndex] instanceof ContinuousDynamicExpression) {
                     let continuousDynamic: ContinuousDynamicExpression = <ContinuousDynamicExpression>this.activeDynamicExpressions[staffIndex];
                     startTime = continuousDynamic.StartMultiExpression.AbsoluteTimestamp;
                     endTime = continuousDynamic.EndMultiExpression.AbsoluteTimestamp;
@@ -426,7 +430,7 @@ export class MusicPartManagerIterator {
                     if (this.CurrentSourceTimestamp === instantaniousDynamic.ParentMultiExpression.AbsoluteTimestamp) {
                         this.currentDynamicChangingExpressions.push(new DynamicsContainer(instantaniousDynamic, staffIndex));
                     }
-                }
+                }*/ // FIXME COMMENTED OUT, missing classes
             }
         }
         let timeSortedTempoExpressions: MultiTempoExpression[] = this.manager.MusicSheet.TimestampSortedTempoExpressionsList;
@@ -458,8 +462,7 @@ export class MusicPartManagerIterator {
             if (this.activeTempoExpression.ContinuousTempo !== undefined) {
                 endTime = this.activeTempoExpression.ContinuousTempo.AbsoluteEndTimestamp;
             }
-            if (
-                   this.CurrentSourceTimestamp >= this.activeTempoExpression.AbsoluteTimestamp
+            if (   this.CurrentSourceTimestamp >= this.activeTempoExpression.AbsoluteTimestamp
                 || this.CurrentSourceTimestamp <= endTime
             ) {
                 this.currentTempoChangingExpression = this.activeTempoExpression;
@@ -476,7 +479,7 @@ export class MusicPartManagerIterator {
             let currentContainer: VerticalSourceStaffEntryContainer = this.currentMeasure.VerticalSourceStaffEntryContainers[this.currentVoiceEntryIndex];
             this.currentVoiceEntries = this.getVoiceEntries(currentContainer);
             this.currentVerticalContainerInMeasureTimestamp = currentContainer.Timestamp;
-            this.currentTimeStamp = new Fraction(this.currentMeasure.AbsoluteTimestamp + this.currentVerticalContainerInMeasureTimestamp);
+            this.currentTimeStamp = Fraction.plus(this.currentMeasure.AbsoluteTimestamp, this.currentVerticalContainerInMeasureTimestamp);
             if (this.currentTimeStamp >= this.manager.MusicSheet.SelectionEnd) {
                 this.endReached = true;
             }
@@ -487,7 +490,7 @@ export class MusicPartManagerIterator {
         this.handleRepetitionsAtMeasureEnd();
         if (this.currentMeasureIndex >= 0 && this.currentMeasureIndex < this.manager.MusicSheet.SourceMeasures.length) {
             this.currentMeasure = this.manager.MusicSheet.SourceMeasures[this.currentMeasureIndex];
-            this.currentTimeStamp = new Fraction(this.currentMeasure.AbsoluteTimestamp + this.currentVerticalContainerInMeasureTimestamp);
+            this.currentTimeStamp = Fraction.plus(this.currentMeasure.AbsoluteTimestamp, this.currentVerticalContainerInMeasureTimestamp);
             this.currentVoiceEntryIndex = -1;
             this.recursiveMove();
             return;
@@ -525,12 +528,14 @@ export class MusicPartManagerIterator {
     }
     private getVoiceEntries(container: VerticalSourceStaffEntryContainer): VoiceEntry[] {
         let entries: VoiceEntry[] = new Array();
-        for (let sourceStaffEntry: SourceStaffEntry of container.StaffEntries) {
+        for (let sourceStaffEntry of container.StaffEntries) {
             if (sourceStaffEntry === undefined) { continue; }
-            for (let voiceEntry: VoiceEntry of sourceStaffEntry.VoiceEntries) {
+            for (let voiceEntry of sourceStaffEntry.VoiceEntries) {
                 entries.push(voiceEntry);
             }
         }
         return entries;
     }
+
+
 }

src/MusicalScore/MusicSheet.ts

@@ -1,4 +1,18 @@
-export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet> {
+import {Fraction} from "../Common/DataObjects/fraction";
+import {MusicPartManager} from "./MusicParts/MusicPartManager";
+import {SourceMeasure} from "./VoiceData/SourceMeasure";
+import {Repetition} from "./MusicSource/Repetition";
+import {DynamicsContainer} from "./VoiceData/HelperObjects/DynamicsContainer";
+import {InstrumentalGroup} from "./InstrumentalGroup";
+import {Instrument} from "./Instrument";
+import {Label} from "./Label";
+import {Staff} from "./VoiceData/Staff";
+import {Note} from "./VoiceData/Note";
+import {VoiceEntry} from "./VoiceData/VoiceEntry";
+import {MusicPartManagerIterator} from "./MusicParts/MusicPartManagerIterator";
+import {PartListEntry} from "./MusicSource/PartListEntry";
+import {VerticalSourceStaffEntryContainer} from "./VoiceData/VerticalSourceStaffEntryContainer";
+export class MusicSheet /*implements ISettableMusicSheet, IComparable<MusicSheet>*/ {
     constructor() {
         try {
             this.Rules = EngravingRules.Rules;
@@ -15,24 +29,24 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     public PageWidth: number;
 
     private idString: string = "kjgdfuilhsda�oihfsvjh";
-    private sourceMeasures: List<SourceMeasure> = new List<SourceMeasure>();
-    private repetitions: List<Repetition> = new List<Repetition>();
-    private dynListStaves: List<List<DynamicsContainer>> = new List<List<DynamicsContainer>>();
-    private timestampSortedDynamicExpressionsList: List<DynamicsContainer> = new List<DynamicsContainer>();
-    private timestampSortedTempoExpressionsList: List<MultiTempoExpression> = new List<MultiTempoExpression>();
-    private instrumentalGroups: List<InstrumentalGroup> = new List<InstrumentalGroup>();
-    private instruments: List<Instrument> = new List<Instrument>();
+    private sourceMeasures: SourceMeasure[] = new Array();
+    private repetitions: Repetition[] = new Array();
+    private dynListStaves: DynamicsContainer[][] = new Array();
+    private timestampSortedDynamicExpressionsList: DynamicsContainer[] = new Array();
+    private timestampSortedTempoExpressionsList: MultiTempoExpression[] = new Array();
+    private instrumentalGroups: InstrumentalGroup[] = new Array();
+    private instruments: Instrument[] = new Array();
     private playbackSettings: PlaybackSettings;
     private path: string;
     private title: Label;
     private subtitle: Label;
     private composer: Label;
     private lyricist: Label;
-    // private languages: List<Language> = new List<Language>();
+    // private languages: Language[] = new Array();
     // private activeLanguage: Language;
     private musicPartManager: MusicPartManager = undefined;
     private musicSheetErrors: MusicSheetErrors = new MusicSheetErrors();
-    private staves: List<Staff> = new List<Staff>();
+    private staves: Staff[] = new Array();
     private selectionStart: Fraction;
     private selectionEnd: Fraction;
     private transpose: number = 0;
@@ -51,31 +65,31 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     public set PhonicScoreInterface(value: IPhonicScoreInterface) {
         this.phonicScoreInterface = value;
     }
-    public get SourceMeasures(): List<SourceMeasure> {
+    public get SourceMeasures(): SourceMeasure[] {
         return this.sourceMeasures;
     }
-    public set SourceMeasures(value: List<SourceMeasure>) {
+    public set SourceMeasures(value: SourceMeasure[]) {
         this.sourceMeasures = value;
     }
-    public get Repetitions(): List<Repetition> {
+    public get Repetitions(): Repetition[] {
         return this.repetitions;
     }
-    public set Repetitions(value: List<Repetition>) {
+    public set Repetitions(value: Repetition[]) {
         this.repetitions = value;
     }
-    public get DynListStaves(): List<List<DynamicsContainer>> {
+    public get DynListStaves(): DynamicsContainer[][] {
         return this.dynListStaves;
     }
-    public get TimestampSortedTempoExpressionsList(): List<MultiTempoExpression> {
+    public get TimestampSortedTempoExpressionsList(): MultiTempoExpression[] {
         return this.timestampSortedTempoExpressionsList;
     }
-    public get TimestampSortedDynamicExpressionsList(): List<DynamicsContainer> {
+    public get TimestampSortedDynamicExpressionsList(): DynamicsContainer[] {
         return this.timestampSortedDynamicExpressionsList;
     }
-    public get InstrumentalGroups(): List<InstrumentalGroup> {
+    public get InstrumentalGroups(): InstrumentalGroup[] {
         return this.instrumentalGroups;
     }
-    public get Instruments(): List<Instrument> {
+    public get Instruments(): Instrument[] {
         return this.instruments;
     }
     public get SheetPlaybackSetting(): PlaybackSettings {
@@ -113,35 +127,35 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     public set Path(value: string) {
         this.path = value;
     }
-    public get Staves(): List<Staff> {
+    public get Staves(): Staff[] {
         return this.staves;
     }
     public get TitleString(): string {
         if (this.title !== undefined) {
             return this.title.Text;
         } else {
-            return string.Empty;
+            return "";
         }
     }
     public get SubtitleString(): string {
         if (this.subtitle !== undefined) {
             return this.subtitle.Text;
         } else {
-            return string.Empty;
+            return "";
         }
     }
     public get ComposerString(): string {
         if (this.composer !== undefined) {
             return this.composer.Text;
         } else {
-            return string.Empty;
+            return "";
         }
     }
     public get LyricistString(): string {
         if (this.lyricist !== undefined) {
             return this.lyricist.Text;
         } else {
-            return string.Empty;
+            return "";
         }
     }
     public get Title(): Label {
@@ -182,7 +196,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     }
     public set SelectionStart(value: Fraction) {
         this.selectionStart = value;
-        this.currentEnrolledPosition = new Fraction(this.selectionStart);
+        this.currentEnrolledPosition = Fraction.CreateFractionFromFraction(this.selectionStart);
     }
     public get SelectionEnd(): Fraction {
         return this.selectionEnd;
@@ -199,20 +213,20 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         this.Composer = new Label(this.musicSheetParameterObject.Composer);
     }
     public addMeasure(measure: SourceMeasure): void {
-        this.SourceMeasures.Add(measure);
-        measure.MeasureListIndex = this.SourceMeasures.Count - 1;
+        this.SourceMeasures.push(measure);
+        measure.MeasureListIndex = this.SourceMeasures.length - 1;
     }
     public checkForInstrumentWithNoVoice(): void {
-        for (let idx: number = 0, len: number = this.instruments.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.instruments.length; idx < len; ++idx) {
             let instrument: Instrument = this.instruments[idx];
-            if (instrument.Voices.Count === 0) {
+            if (instrument.Voices.length === 0) {
                 let voice: Voice = new Voice(instrument, 1);
-                instrument.Voices.Add(voice);
+                instrument.Voices.push(voice);
             }
         }
     }
     public getStaffFromIndex(staffIndexInMusicSheet: number): Staff {
-        if (this.staves.Count > staffIndexInMusicSheet) {
+        if (this.staves.length > staffIndexInMusicSheet) {
             return this.staves[staffIndexInMusicSheet];
         } else {
             return undefined;
@@ -223,12 +237,12 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     }
     public fillStaffList(): void {
         let i: number = 0;
-        for (let idx: number = 0, len: number = this.instruments.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.instruments.length; idx < len; ++idx) {
             let instrument: Instrument = this.instruments[idx];
-            for (let idx2: number = 0, len2: number = instrument.Staves.Count; idx2 < len2; ++idx2) {
+            for (let idx2: number = 0, len2: number = instrument.Staves.length; idx2 < len2; ++idx2) {
                 let staff: Staff = instrument.Staves[idx2];
                 staff.IdInMusicSheet = i;
-                this.staves.Add(staff);
+                this.staves.push(staff);
                 i++;
             }
         }
@@ -241,22 +255,22 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     }
     public getCompleteNumberOfStaves(): number {
         let number: number = 0;
-        for (let idx: number = 0, len: number = this.instruments.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.instruments.length; idx < len; ++idx) {
             let instrument: Instrument = this.instruments[idx];
-            number += instrument.Staves.Count;
+            number += instrument.Staves.length;
         }
         return number;
     }
-    public getListOfMeasuresFromIndeces(start: number, end: number): List<SourceMeasure> {
-        let measures: List<SourceMeasure> = new List<SourceMeasure>();
+    public getListOfMeasuresFromIndeces(start: number, end: number): SourceMeasure[] {
+        let measures: SourceMeasure[] = new Array();
         for (let i: number = start; i <= end; i++) {
-            measures.Add(this.sourceMeasures[i]);
+            measures.push(this.sourceMeasures[i]);
         }
         return measures;
     }
     public getNextSourceMeasure(measure: SourceMeasure): SourceMeasure {
         let index: number = this.sourceMeasures.IndexOf(measure);
-        if (index === this.sourceMeasures.Count - 1) {
+        if (index === this.sourceMeasures.length - 1) {
             return measure;
         }
         return this.sourceMeasures[index + 1];
@@ -265,14 +279,14 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         return this.sourceMeasures[0];
     }
     public getLastSourceMeasure(): SourceMeasure {
-        return this.sourceMeasures[this.sourceMeasures.Count - 1];
+        return this.sourceMeasures[this.sourceMeasures.length - 1];
     }
     public resetAllNoteStates(): void {
         let iterator: MusicPartManagerIterator = this.MusicPartManager.getIterator();
         while (!iterator.EndReached && iterator.CurrentVoiceEntries !== undefined) {
-            for (let idx: number = 0, len: number = iterator.CurrentVoiceEntries.Count; idx < len; ++idx) {
+            for (let idx: number = 0, len: number = iterator.CurrentVoiceEntries.length; idx < len; ++idx) {
                 let voiceEntry: VoiceEntry = iterator.CurrentVoiceEntries[idx];
-                for (let idx2: number = 0, len2: number = voiceEntry.Notes.Count; idx2 < len2; ++idx2) {
+                for (let idx2: number = 0, len2: number = voiceEntry.Notes.length; idx2 < len2; ++idx2) {
                     let note: Note = voiceEntry.Notes[idx2];
                     note.State = NoteState.Normal;
                 }
@@ -281,19 +295,19 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         }
     }
     public getMusicSheetInstrumentIndex(instrument: Instrument): number {
-        return this.Instruments.IndexOf(instrument);
+        return this.Instruments.indexOf(instrument);
     }
     public getGlobalStaffIndexOfFirstStaff(instrument: Instrument): number {
         let instrumentIndex: number = this.getMusicSheetInstrumentIndex(instrument);
         let staffLineIndex: number = 0;
         for (let i: number = 0; i < instrumentIndex; i++) {
-            staffLineIndex += this.Instruments[i].Staves.Count;
+            staffLineIndex += this.Instruments[i].Staves.length;
         }
         return staffLineIndex;
     }
     public setRepetitionNewUserNumberOfRepetitions(index: number, value: number): void {
         let repIndex: number = 0;
-        for (let i: number = 0; i < this.repetitions.Count; i++) {
+        for (let i: number = 0; i < this.repetitions.length; i++) {
             if (this.repetitions[i] instanceof Repetition) {
                 if (index === repIndex) {
                     (<Repetition>this.repetitions[i]).UserNumberOfRepetitions = value;
@@ -306,7 +320,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     }
     public getRepetitionByIndex(index: number): Repetition {
         let repIndex: number = 0;
-        for (let i: number = 0; i < this.repetitions.Count; i++) {
+        for (let i: number = 0; i < this.repetitions.length; i++) {
             if (this.repetitions[i] instanceof Repetition) {
                 if (index === repIndex) {
                     return <Repetition>this.repetitions[i];
@@ -317,42 +331,43 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         return undefined;
     }
     public CompareTo(other: MusicSheet): number {
-        return this.Title.Text.CompareTo(other.Title.Text);
+        return this.Title.Text.localeCompare(other.Title.Text);
     }
-    public get IInstruments(): List<IInstrument> {
-        let list: List<IInstrument> = new List<IInstrument>();
-        for (let idx: number = 0, len: number = this.instruments.Count; idx < len; ++idx) {
+    public get IInstruments(): IInstrument[] {
+        let list: IInstrument[] = new Array();
+        for (let idx: number = 0, len: number = this.instruments.length; idx < len; ++idx) {
             let instr: Instrument = this.instruments[idx];
-            list.Add(instr);
+            list.push(instr);
         }
         return list;
     }
-    public get IInitializableInstruments(): List<ISettableInstrument> {
-        let list: List<ISettableInstrument> = new List<ISettableInstrument>();
-        for (let idx: number = 0, len: number = this.instruments.Count; idx < len; ++idx) {
+    public get IInitializableInstruments(): ISettableInstrument[] {
+        let list: ISettableInstrument[] = new Array();
+        for (let idx: number = 0, len: number = this.instruments.length; idx < len; ++idx) {
             let instr: Instrument = this.instruments[idx];
-            list.Add(instr);
+            list.push(instr);
         }
         return list;
     }
-    public get IRepetitions(): List<IRepetition> {
+    public get IRepetitions(): IRepetition[] {
         try {
-            let repetitions: List<IRepetition> = new List<IRepetition>();
-            for (let idx: number = 0, len: number = this.repetitions.Count; idx < len; ++idx) {
+            let repetitions: IRepetition[] = new Array();
+            for (let idx: number = 0, len: number = this.repetitions.length; idx < len; ++idx) {
                 let partListEntry: PartListEntry = this.repetitions[idx];
                 if (partListEntry instanceof Repetition) {
-                    repetitions.Add(<Repetition>partListEntry);
+                    repetitions.push(<Repetition>partListEntry);
                 }
             }
             return repetitions;
         } catch (ex) {
-            Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.IRepetitions get: ", ex);
+            //Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.IRepetitions get: ", ex);
+            // FIXME logger
             return undefined;
         }
 
     }
     public GetExpressionsStartTempoInBPM(): number {
-        if (this.TimestampSortedTempoExpressionsList.Count > 0) {
+        if (this.TimestampSortedTempoExpressionsList.length > 0) {
             let me: MultiTempoExpression = this.TimestampSortedTempoExpressionsList[0];
             if (me.InstantaniousTempo !== undefined) {
                 return me.InstantaniousTempo.TempoInBpm;
@@ -362,11 +377,11 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         }
         return this.UserStartTempoInBPM;
     }
-    public get Errors(): Dictionary<number, List<string>> {
+    public get Errors(): Dictionary<number, string[]> {
         try {
             return this.musicSheetErrors.MeasureErrors;
         } catch (ex) {
-            Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.Errors get: ", ex);
+            // FIXME Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.Errors get: ", ex);
             return undefined;
         }
 
@@ -375,7 +390,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         try {
             return this.getFirstSourceMeasure().MeasureNumber;
         } catch (ex) {
-            Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.FirstMeasureNumber: ", ex);
+            // Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.FirstMeasureNumber: ", ex); // FIXME
             return 0;
         }
 
@@ -384,7 +399,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         try {
             return this.getLastSourceMeasure().MeasureNumber;
         } catch (ex) {
-            Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.LastMeasureNumber: ", ex);
+            // Logger.DefaultLogger.LogError(LogLevel.NORMAL, "MusicSheet.LastMeasureNumber: ", ex); // FIXME
             return 0;
         }
 
@@ -393,7 +408,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         return this.currentEnrolledPosition;
     }
     public set CurrentEnrolledPosition(value: Fraction) {
-        this.currentEnrolledPosition = new Fraction(value);
+        this.currentEnrolledPosition = Fraction.CreateFractionFromFraction(value);
     }
     public get Transpose(): number {
         return this.transpose;
@@ -418,7 +433,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
                 oldValue = value;
             }
             if (this.MusicSheetParameterChanged !== undefined) {
-                MusicSheetParameterChanged(undefined, parameter, value, oldValue);
+                this.MusicSheetParameterChanged(undefined, parameter, value, oldValue);
             }
         }
     }
@@ -439,23 +454,23 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
     }
     public Dispose(): void {
         this.MusicSheetParameterChanged = undefined;
-        for (let idx: number = 0, len: number = this.IInstruments.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.IInstruments.length; idx < len; ++idx) {
             let instrument: IInstrument = this.IInstruments[idx];
             instrument.Dispose();
         }
     }
     public getEnrolledSelectionStartTimeStampWorkaround(): Fraction {
         let iter: MusicPartManagerIterator = this.MusicPartManager.getIterator(this.SelectionStart);
-        return new Fraction(iter.CurrentEnrolledTimestamp);
+        return Fraction.CreateFractionFromFraction(iter.CurrentEnrolledTimestamp);
     }
     public get SheetEndTimestamp(): Fraction {
         let lastMeasure: SourceMeasure = this.getLastSourceMeasure();
         return lastMeasure.AbsoluteTimestamp + lastMeasure.Duration;
     }
     public getSourceMeasureFromTimeStamp(timeStamp: Fraction): SourceMeasure {
-        for (let idx: number = 0, len: number = this.SourceMeasures.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.SourceMeasures.length; idx < len; ++idx) {
             let sm: SourceMeasure = this.SourceMeasures[idx];
-            for (let idx2: number = 0, len2: number = sm.VerticalSourceStaffEntryContainers.Count; idx2 < len2; ++idx2) {
+            for (let idx2: number = 0, len2: number = sm.VerticalSourceStaffEntryContainers.length; idx2 < len2; ++idx2) {
                 let vssec: VerticalSourceStaffEntryContainer = sm.VerticalSourceStaffEntryContainers[idx2];
                 if (timeStamp === vssec.getAbsoluteTimestamp()) {
                     return sm;
@@ -465,7 +480,7 @@ export class MusicSheet implements ISettableMusicSheet, IComparable<MusicSheet>
         return this.findSourceMeasureFromTimeStamp(timeStamp);
     }
     public findSourceMeasureFromTimeStamp(timeStamp: Fraction): SourceMeasure {
-        for (let idx: number = 0, len: number = this.SourceMeasures.Count; idx < len; ++idx) {
+        for (let idx: number = 0, len: number = this.SourceMeasures.length; idx < len; ++idx) {
             let sm: SourceMeasure = this.SourceMeasures[idx];
             if (sm.AbsoluteTimestamp >= timeStamp && timeStamp < sm.AbsoluteTimestamp + sm.Duration) {
                 return sm;

src/MusicalScore/MusicSource/PartListEntry.ts

@@ -1,3 +1,7 @@
+import {MusicSheet} from "../MusicSheet";
+import {Fraction} from "../../Common/DataObjects/fraction";
+import {SourceMeasure} from "../VoiceData/SourceMeasure";
+
 export class PartListEntry {
     constructor(musicSheet: MusicSheet) {
         this.musicSheet = musicSheet;
@@ -7,7 +11,7 @@ export class PartListEntry {
     public StartIndex: number;
     public EndIndex: number;
 
-    protected enrolledTimestamps: List<Fraction> = new List<Fraction>();
+    protected enrolledTimestamps: Fraction[] = new Array();
     protected visible: boolean = true;
 
     private musicSheet: MusicSheet;

src/MusicalScore/MusicSource/Repetition.ts

@@ -10,7 +10,7 @@ import {PartListEntry} from "./PartListEntry";
 export class Repetition extends PartListEntry /*implements IRepetition*/ {
     constructor(musicSheet: MusicSheet, virtualOverallRepetition: boolean) {
         super(musicSheet);
-        this.musicSheet = musicSheet;
+        this.musicSheet2 = musicSheet;
         this.virtualOverallRepetition = virtualOverallRepetition;
     }
 
@@ -24,7 +24,7 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
     private userNumberOfRepetitions: number = 0;
     private visibles: boolean[] = new Array();
     private fromWords: boolean = false;
-    private musicSheet: MusicSheet;
+    private musicSheet2: MusicSheet;
     private repetitonIterationOrder: number[] = new Array();
     private numberOfEndings: number = 1;
     private virtualOverallRepetition: boolean;
@@ -47,7 +47,7 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
     public get DefaultNumberOfRepetitions(): number {
         let defaultNumber: number = 2;
         if (this.virtualOverallRepetition) { defaultNumber = 1; }
-        return Math.Max(Math.Max(defaultNumber, this.endingIndexDict.length), this.checkRepetitionForMultipleLyricVerses());
+        return Math.max(defaultNumber, Object.keys(this.endingIndexDict).length, this.checkRepetitionForMultipleLyricVerses());
     }
     public get UserNumberOfRepetitions(): number {
         return this.userNumberOfRepetitions;
@@ -75,7 +75,7 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
         return this.StartMarker.MeasureIndex;
     }
     public SetEndingStartIndex(endingNumbers: number[], startIndex: number): void {
-        let part: RepetitionEndingPart = new RepetitionEndingPart(new SourceMusicPart(this.musicSheet, startIndex, startIndex));
+        let part: RepetitionEndingPart = new RepetitionEndingPart(new SourceMusicPart(this.musicSheet2, startIndex, startIndex));
         this.endingParts.push(part);
         for (let idx: number = 0, len: number = endingNumbers.length; idx < len; ++idx) {
             let endingNumber: number = endingNumbers[idx];
@@ -92,7 +92,7 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
         }
     }
     public SetEndingStartIndex(endingNumber: number, startIndex: number): void {
-        let part: RepetitionEndingPart = new RepetitionEndingPart(new SourceMusicPart(this.musicSheet, startIndex, startIndex));
+        let part: RepetitionEndingPart = new RepetitionEndingPart(new SourceMusicPart(this.musicSheet2, startIndex, startIndex));
         this.endingParts.push(part);
         this.endingIndexDict[endingNumber] = part;
         part.endingIndices.push(endingNumber);
@@ -115,7 +115,7 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
         this.fromWords = value;
     }
     public get AbsoluteTimestamp(): Fraction {
-        return new Fraction(this.musicSheet.SourceMeasures[this.StartMarker.MeasureIndex].AbsoluteTimestamp);
+        return Fraction.CreateFractionFromFraction(this.musicSheet2.SourceMeasures[this.StartMarker.MeasureIndex].AbsoluteTimestamp);
     }
     public get StartIndex(): number {
         return this.StartMarker.MeasureIndex;
@@ -135,15 +135,14 @@ export class Repetition extends PartListEntry /*implements IRepetition*/ {
         let start: number = this.StartIndex;
         let end: number = this.EndIndex;
         for (let measureIndex: number = start; measureIndex <= end; measureIndex++) {
-            let sourceMeasure: SourceMeasure = this.musicSheet.SourceMeasures[measureIndex];
+            let sourceMeasure: SourceMeasure = this.musicSheet2.SourceMeasures[measureIndex];
             for (let i: number = 0; i < sourceMeasure.CompleteNumberOfStaves; i++) {
-                for (let j: number = 0; j < sourceMeasure.VerticalSourceStaffEntryContainers.length; j++) {
-                    if (sourceMeasure.VerticalSourceStaffEntryContainers[j][i] !== undefined) {
-                        let sourceStaffEntry: SourceStaffEntry = sourceMeasure.VerticalSourceStaffEntryContainers[j][i];
+                for (let sourceStaffEntries: SourceStaffEntry[] of sourceMeasure.VerticalSourceStaffEntryContainers) {
+                    if (sourceStaffEntries[i] !== undefined) {
+                        let sourceStaffEntry: SourceStaffEntry = sourceStaffEntries[i];
                         let verses: number = 0;
-                        for (let idx: number = 0, len: number = sourceStaffEntry.VoiceEntries.length; idx < len; ++idx) {
-                            let voiceEntry: VoiceEntry = sourceStaffEntry.VoiceEntries[idx];
-                            verses += voiceEntry.LyricsEntries.length;
+                        for (let voiceEntry: VoiceEntry of sourceStaffEntry.VoiceEntries) {
+                            verses += Object.keys(voiceEntry.LyricsEntries).length;
                         }
                         lyricVerses = Math.max(lyricVerses, verses);
                     }

src/MusicalScore/VoiceData/Instructions/RhythmInstruction.ts

@@ -1,3 +1,6 @@
+import {AbstractNotationInstruction} from "./AbstractNotationInstruction";
+import {Fraction} from "../../../Common/DataObjects/fraction";
+
 export class RhythmInstruction extends AbstractNotationInstruction {
     constructor(rhythm: Fraction, numerator: number, denominator: number, rhythmSymbolEnum: RhythmSymbolEnum) {
         super();
@@ -31,7 +34,7 @@ export class RhythmInstruction extends AbstractNotationInstruction {
     }
     public OperatorEquals(rhythm2: RhythmInstruction): boolean {
         let rhythm1: RhythmInstruction = this;
-        if (ReferenceEquals(rhythm1, rhythm2)) {
+        if (rhythm1 === rhythm2) {
             return true;
         }
         if ((<Object>rhythm1 === undefined) || (<Object>rhythm2 === undefined)) {

src/MusicalScore/VoiceData/SourceMeasure.ts

@@ -1,3 +1,11 @@
+import {Fraction} from "../../Common/DataObjects/fraction";
+import {VerticalSourceStaffEntryContainer} from "./VerticalSourceStaffEntryContainer";
+import {SourceStaffEntry} from "./SourceStaffEntry";
+import {RepetitionInstruction} from "./Instructions/RepetitionInstruction";
+import {Staff} from "./Staff";
+import {VoiceEntry} from "./VoiceEntry";
+import {Voice} from "./Voice";
+import {MusicSheet} from "../MusicSheet";
 export class SourceMeasure {
   constructor(completeNumberOfStaves: number) {
     this.completeNumberOfStaves = completeNumberOfStaves;
@@ -11,16 +19,16 @@ export class SourceMeasure {
   private absoluteTimestamp: Fraction;
   private completeNumberOfStaves: number;
   private duration: Fraction;
-  private staffLinkedExpressions: List<List<MultiExpression>> = new List<List<MultiExpression>>();
-  private tempoExpressions: List<MultiTempoExpression> = new List<MultiTempoExpression>();
-  private verticalSourceStaffEntryContainers: List<VerticalSourceStaffEntryContainer> = new List<VerticalSourceStaffEntryContainer>();
+  private staffLinkedExpressions: MultiExpression[] = new Array();
+  private tempoExpressions: MultiTempoExpression[] = new Array();
+  private verticalSourceStaffEntryContainers: VerticalSourceStaffEntryContainer[] = new Array();
   private implicitMeasure: boolean;
   private breakSystemAfter: boolean;
-  private staffMeasureErrors: List<boolean> = new List<boolean>();
-  private firstInstructionsStaffEntries: List<SourceStaffEntry> = new List<SourceStaffEntry>();
-  private lastInstructionsStaffEntries: List<SourceStaffEntry> = new List<SourceStaffEntry>();
-  private firstRepetitionInstructions: List<RepetitionInstruction> = new List<RepetitionInstruction>();
-  private lastRepetitionInstructions: List<RepetitionInstruction> = new List<RepetitionInstruction>();
+  private staffMeasureErrors: boolean[] = new Array();
+  private firstInstructionsStaffEntries: SourceStaffEntry[] = new Array();
+  private lastInstructionsStaffEntries: SourceStaffEntry[] = new Array();
+  private firstRepetitionInstructions: RepetitionInstruction[] = new Array();
+  private lastRepetitionInstructions: RepetitionInstruction[] = new Array();
   public get MeasureNumber(): number {
     return this.measureNumber;
   }
@@ -54,25 +62,25 @@ export class SourceMeasure {
   public set BreakSystemAfter(value: boolean) {
     this.breakSystemAfter = value;
   }
-  public get StaffLinkedExpressions(): List<List<MultiExpression>> {
+  public get StaffLinkedExpressions(): MultiExpression[] {
     return this.staffLinkedExpressions;
   }
-  public get TempoExpressions(): List<MultiTempoExpression> {
+  public get TempoExpressions(): MultiTempoExpression[] {
     return this.tempoExpressions;
   }
-  public get VerticalSourceStaffEntryContainers(): List<VerticalSourceStaffEntryContainer> {
+  public get VerticalSourceStaffEntryContainers(): VerticalSourceStaffEntryContainer[] {
     return this.verticalSourceStaffEntryContainers;
   }
-  public get FirstInstructionsStaffEntries(): List<SourceStaffEntry> {
+  public get FirstInstructionsStaffEntries(): SourceStaffEntry[] {
     return this.firstInstructionsStaffEntries;
   }
-  public get LastInstructionsStaffEntries(): List<SourceStaffEntry> {
+  public get LastInstructionsStaffEntries(): SourceStaffEntry[] {
     return this.lastInstructionsStaffEntries;
   }
-  public get FirstRepetitionInstructions(): List<RepetitionInstruction> {
+  public get FirstRepetitionInstructions(): RepetitionInstruction[] {
     return this.firstRepetitionInstructions;
   }
-  public get LastRepetitionInstructions(): List<RepetitionInstruction> {
+  public get LastRepetitionInstructions(): RepetitionInstruction[] {
     return this.lastRepetitionInstructions;
   }
   public getErrorInMeasure(staffIndex: number): boolean {
@@ -81,13 +89,13 @@ export class SourceMeasure {
   public setErrorInStaffMeasure(staffIndex: number, hasError: boolean): void {
     this.staffMeasureErrors[staffIndex] = hasError;
   }
-  public getNextMeasure(measures: List<SourceMeasure>): SourceMeasure {
-    if (this.MeasureListIndex + 1 < measures.Count) {
+  public getNextMeasure(measures: SourceMeasure[]): SourceMeasure {
+    if (this.MeasureListIndex + 1 < measures.length) {
       return measures[this.MeasureListIndex + 1];
     }
     return undefined;
   }
-  public getPreviousMeasure(measures: List<SourceMeasure>): SourceMeasure {
+  public getPreviousMeasure(measures: SourceMeasure[]): SourceMeasure {
     if (this.MeasureListIndex > 1) {
       return measures[this.MeasureListIndex - 1];
     }
@@ -113,12 +121,12 @@ export class SourceMeasure {
       let container: VerticalSourceStaffEntryContainer = new VerticalSourceStaffEntryContainer(
         this, new Fraction(inMeasureTimestamp), this.completeNumberOfStaves
       );
-      this.verticalSourceStaffEntryContainers.Add(container);
+      this.verticalSourceStaffEntryContainers.push(container);
       staffEntry = new SourceStaffEntry(container, staff);
       container[inSourceMeasureStaffIndex] = staffEntry;
     } else {
       for (
-        let i: number = this.verticalSourceStaffEntryContainers.Count - 1;
+        let i: number = this.verticalSourceStaffEntryContainers.length - 1;
         i >= 0; i--
       ) {
         if (this.verticalSourceStaffEntryContainers[i].Timestamp < inMeasureTimestamp) {
@@ -145,8 +153,7 @@ export class SourceMeasure {
   }
   public findOrCreateVoiceEntry(sse: SourceStaffEntry, voice: Voice, createdNewVoiceEntry: boolean): VoiceEntry {
     let ve: VoiceEntry = undefined;
-    for (let idx: number = 0, len: number = sse.VoiceEntries.Count; idx < len; ++idx) {
-      let voiceEntry: VoiceEntry = sse.VoiceEntries[idx];
+    for (let voiceEntry: VoiceEntry of sse.VoiceEntries) {
       if (voiceEntry.ParentVoice === voice) {
         ve = voiceEntry;
         break;
@@ -154,7 +161,7 @@ export class SourceMeasure {
     }
     if (ve === undefined) {
       ve = new VoiceEntry(sse.Timestamp, voice, sse);
-      sse.VoiceEntries.Add(ve);
+      sse.VoiceEntries.push(ve);
       createdNewVoiceEntry = true;
     } else {
       createdNewVoiceEntry = false;
@@ -203,14 +210,14 @@ export class SourceMeasure {
   }
   public reverseCheck(musicSheet: MusicSheet, maxInstDuration: Fraction): Fraction {
     let maxDuration: Fraction = new Fraction(0, 1);
-    let instrumentsDurations: List<Fraction> = new List<Fraction>();
-    for (let i: number = 0; i < musicSheet.Instruments.Count; i++) {
+    let instrumentsDurations: Fraction[] = new Array();
+    for (let i: number = 0; i < musicSheet.Instruments.length; i++) {
       let instrumentDuration: Fraction = new Fraction(0, 1);
       let inSourceMeasureInstrumentIndex: number = musicSheet.getGlobalStaffIndexOfFirstStaff(musicSheet.Instruments[i]);
       for (let j: number = 0; j < musicSheet.Instruments[i].Staves.Count; j++) {
         let lastStaffEntry: SourceStaffEntry = this.getLastSourceStaffEntryForInstrument(inSourceMeasureInstrumentIndex + j);
         if (lastStaffEntry !== undefined && !lastStaffEntry.hasTie()) {
-          let verticalContainerIndex: number = this.verticalSourceStaffEntryContainers.IndexOf(lastStaffEntry.VerticalContainerParent);
+          let verticalContainerIndex: number = this.verticalSourceStaffEntryContainers.indexOf(lastStaffEntry.VerticalContainerParent);
           for (let m: number = verticalContainerIndex - 1; m >= 0; m--) {
             let previousStaffEntry: SourceStaffEntry = this.verticalSourceStaffEntryContainers[m][inSourceMeasureInstrumentIndex + j];
             if (previousStaffEntry !== undefined && previousStaffEntry.hasTie()) {
@@ -232,9 +239,9 @@ export class SourceMeasure {
     }
     return Math.max(maxDuration, maxInstDuration);
   }
-  public calculateInstrumentsDuration(musicSheet: MusicSheet, instrumentMaxTieNoteFractions: List<Fraction>): List<Fraction> {
-    let instrumentsDurations: List<Fraction> = new List<Fraction>();
-    for (let i: number = 0; i < musicSheet.Instruments.Count; i++) {
+  public calculateInstrumentsDuration(musicSheet: MusicSheet, instrumentMaxTieNoteFractions: Fraction[]): Fraction[] {
+    let instrumentsDurations: Fraction[] = new Array();
+    for (let i: number = 0; i < musicSheet.Instruments.length; i++) {
       let instrumentDuration: Fraction = new Fraction(0, 1);
       let inSourceMeasureInstrumentIndex: number = musicSheet.getGlobalStaffIndexOfFirstStaff(musicSheet.Instruments[i]);
       for (let j: number = 0; j < musicSheet.Instruments[i].Staves.Count; j++) {
@@ -248,32 +255,32 @@ export class SourceMeasure {
       if (instrumentDuration < instrumentMaxTieNoteFractions[i]) {
         instrumentDuration = instrumentMaxTieNoteFractions[i];
       }
-      instrumentsDurations.Add(instrumentDuration);
+      instrumentsDurations.push(instrumentDuration);
     }
     return instrumentsDurations;
   }
-  public getEntriesPerStaff(staffIndex: number): List<SourceStaffEntry> {
-    let sourceStaffEntries: List<SourceStaffEntry> = new List<SourceStaffEntry>();
-    for (let idx: number = 0, len: number = this.VerticalSourceStaffEntryContainers.Count; idx < len; ++idx) {
+  public getEntriesPerStaff(staffIndex: number): SourceStaffEntry[] {
+    let sourceStaffEntries: SourceStaffEntry[] = new Array();
+    for (let idx: number = 0, len: number = this.VerticalSourceStaffEntryContainers.length; idx < len; ++idx) {
       let container: VerticalSourceStaffEntryContainer = this.VerticalSourceStaffEntryContainers[idx];
       let sse: SourceStaffEntry = container[staffIndex];
-      if (sse !== undefined) { sourceStaffEntries.Add(sse); }
+      if (sse !== undefined) { sourceStaffEntries.push(sse); }
     }
     return sourceStaffEntries;
   }
   private initialize(): void {
     for (let i: number = 0; i < this.completeNumberOfStaves; i++) {
-      this.firstInstructionsStaffEntries.Add(undefined);
-      this.lastInstructionsStaffEntries.Add(undefined);
-      this.staffMeasureErrors.Add(false);
-      this.staffLinkedExpressions.Add(new List<MultiExpression>());
+      this.firstInstructionsStaffEntries.push(undefined);
+      this.lastInstructionsStaffEntries.push(undefined);
+      this.staffMeasureErrors.push(false);
+      this.staffLinkedExpressions.push([]);
     }
     this.implicitMeasure = false;
     this.breakSystemAfter = false;
     this.EndsPiece = false;
   }
   private getLastSourceStaffEntryForInstrument(instrumentIndex: number): SourceStaffEntry {
-    for (let i: number = this.verticalSourceStaffEntryContainers.Count - 1; i >= 0; i--) {
+    for (let i: number = this.verticalSourceStaffEntryContainers.length - 1; i >= 0; i--) {
       if (this.verticalSourceStaffEntryContainers[i][instrumentIndex] !== undefined) {
         return this.verticalSourceStaffEntryContainers[i][instrumentIndex];
       }