@scorelabs/core 1.0.2 → 1.0.4

package/dist/models/NoteSet.js

@@ -1,4 +1,5 @@
 import { Note } from './Note';
+import { Duration } from './types';
 export class NoteSet {
     notes;
     constructor(notes) {
@@ -71,11 +72,11 @@ export class NoteSet {
             return new NoteSet([first.withRest(true)]);
         }
         else {
-            return new NoteSet(this.notes.map(n => n.withRest(false)));
+            return new NoteSet(this.notes.map((n) => n.withRest(false)));
         }
     }
     withGrace(isGrace) {
-        return new NoteSet(this.notes.map(n => n.withGrace(isGrace)));
+        return new NoteSet(this.notes.map((n) => n.withGrace(isGrace)));
     }
     toggleEnharmonic() {
         const newNotes = [...this.notes];
@@ -141,6 +142,21 @@ export class NoteSet {
     withFingering(fingering) {
         return new NoteSet(this.notes.map((n) => n.withFingering(fingering)));
     }
+    withHammerOn(type) {
+        return new NoteSet(this.notes.map((n) => n.withHammerOn(type)));
+    }
+    withPullOff(type) {
+        return new NoteSet(this.notes.map((n) => n.withPullOff(type)));
+    }
+    withPalmMute(type) {
+        return new NoteSet(this.notes.map((n) => n.withPalmMute(type)));
+    }
+    withStringCircled(isStringCircled) {
+        return new NoteSet(this.notes.map((n) => n.withStringCircled(isStringCircled)));
+    }
+    withStemDirection(dir) {
+        return new NoteSet(this.notes.map((n) => n.withStemDirection(dir)));
+    }
     withLyric(lyric) {
         return new NoteSet(this.notes.map((n) => n.withLyric(lyric)));
     }
@@ -150,35 +166,118 @@ export class NoteSet {
     withFretboardDiagram(diagram) {
         return new NoteSet(this.notes.map((n) => n.withFretboardDiagram(diagram)));
     }
-    get pitch() { return this.notes[0].pitch; }
-    get accidental() { return this.notes[0].accidental; }
-    get tie() { return this.notes[0].tie; }
-    get slur() { return this.notes[0].slur; }
-    get articulation() { return this.notes[0].articulation; }
-    get ornament() { return this.notes[0].ornament; }
-    get dynamic() { return this.notes[0].dynamic; }
-    get hairpin() { return this.notes[0].hairpin; }
-    get glissando() { return this.notes[0].glissando; }
-    get arpeggio() { return this.notes[0].arpeggio; }
-    get ottava() { return this.notes[0].ottava; }
-    get pedal() { return this.notes[0].pedal; }
-    get notehead() { return this.notes[0].notehead; }
-    get color() { return this.notes[0].color; }
-    get fret() { return this.notes[0].fret; }
-    get string() { return this.notes[0].string; }
-    get bowing() { return this.notes[0].bowing; }
-    get fingering() { return this.notes[0].fingering; }
-    get lyrics() { return this.notes[0].lyrics; }
-    get lyric() { return this.notes[0].lyric; }
-    get chord() { return this.notes[0].chord; }
-    get fretboardDiagram() { return this.notes[0].fretboardDiagram; }
-    get staffText() { return this.notes[0].staffText; }
+    get pitch() {
+        return this.notes[0].pitch;
+    }
+    get accidental() {
+        return this.notes[0].accidental;
+    }
+    get tie() {
+        return this.notes[0].tie;
+    }
+    get slur() {
+        return this.notes[0].slur;
+    }
+    get articulation() {
+        return this.notes[0].articulation;
+    }
+    get ornament() {
+        return this.notes[0].ornament;
+    }
+    get dynamic() {
+        return this.notes[0].dynamic;
+    }
+    get hairpin() {
+        return this.notes[0].hairpin;
+    }
+    get glissando() {
+        return this.notes[0].glissando;
+    }
+    get arpeggio() {
+        return this.notes[0].arpeggio;
+    }
+    get ottava() {
+        return this.notes[0].ottava;
+    }
+    get pedal() {
+        return this.notes[0].pedal;
+    }
+    get notehead() {
+        return this.notes[0].notehead;
+    }
+    get color() {
+        return this.notes[0].color;
+    }
+    get fret() {
+        return this.notes[0].fret;
+    }
+    get string() {
+        return this.notes[0].string;
+    }
+    get bowing() {
+        return this.notes[0].bowing;
+    }
+    get fingering() {
+        return this.notes[0].fingering;
+    }
+    get allLyrics() {
+        return this.notes[0].allLyrics;
+    }
+    get lyrics() {
+        return this.notes[0].lyrics;
+    }
+    get lyric() {
+        return this.notes[0].lyric;
+    }
+    get chord() {
+        return this.notes[0].chord;
+    }
+    get fretboardDiagram() {
+        return this.notes[0].fretboardDiagram;
+    }
+    get staffText() {
+        return this.notes[0].staffText;
+    }
+    get hammerOn() {
+        return this.notes[0].hammerOn;
+    }
+    get pullOff() {
+        return this.notes[0].pullOff;
+    }
+    get palmMute() {
+        return this.notes[0].palmMute;
+    }
+    get isStringCircled() {
+        return this.notes[0].isStringCircled;
+    }
+    get stemDirection() {
+        return this.notes[0].stemDirection;
+    }
     toJSON() {
         return {
             notes: this.notes.map((n) => n.toJSON()),
         };
     }
     static fromJSON(data) {
-        return new NoteSet(data.notes.map((n) => Note.fromJSON(n)));
+        if (!data) {
+            console.warn('NoteSet.fromJSON: received null or undefined data');
+            return new NoteSet([new Note(Duration.Quarter, undefined, true)]);
+        }
+        let notesArray;
+        if (data.notes && Array.isArray(data.notes)) {
+            notesArray = data.notes;
+        }
+        else if (Array.isArray(data)) {
+            notesArray = data;
+        }
+        else {
+            // Treat it as a single NoteJSON
+            notesArray = [data];
+        }
+        return new NoteSet(notesArray.map((n) => {
+            if (n instanceof Note)
+                return n;
+            return Note.fromJSON(n);
+        }));
     }
 }

package/dist/models/Pitch.js

@@ -76,7 +76,13 @@ export class Pitch {
     }
     static fromNoteName(note, octave) {
         const baseSteps = {
-            C: 0, D: 1, E: 2, F: 3, G: 4, A: 5, B: 6,
+            C: 0,
+            D: 1,
+            E: 2,
+            F: 3,
+            G: 4,
+            A: 5,
+            B: 6,
         };
         const stepLabel = note[0].toUpperCase();
         const step = baseSteps[stepLabel] ?? 0;

package/dist/models/Score.d.ts

@@ -20,7 +20,8 @@ export declare class Score {
     readonly swing: boolean;
     readonly subtitle: string;
     readonly genre: Genre | string;
-    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre | string);
+    readonly tempoText: string;
+    constructor(title: string, composer: string, timeSignature: TimeSignature, keySignature: KeySignature, parts: Part[], bpm?: number, tempoDuration?: Duration, tempoIsDotted?: boolean, copyright?: string, lyricist?: string, swing?: boolean, subtitle?: string, genre?: Genre | string, tempoText?: string);
     withTitle(title: string): Score;
     withComposer(composer: string): Score;
     withSubtitle(subtitle: string): Score;
@@ -42,9 +43,11 @@ export declare class Score {
     changeNoteDuration(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, newDuration: Duration, isDotted?: boolean, voiceIndex?: number): Score;
     pasteNotes(partIndex: number, staffIndex: number, measureIndex: number, noteIndex: number, notesToPaste: NoteSet[]): Score;
     withTempo(bpm: number, duration: Duration, isDotted: boolean): Score;
+    withTempoText(text: string): Score;
     withSwing(swing: boolean): Score;
     withLyricist(lyricist: string): Score;
     withCopyright(copyright: string): Score;
+    withParts(parts: Part[]): Score;
     toJSON(): ScoreJSON;
     replacePart(partIndex: number, newPart: Part): Score;
     addPart(newPart: Part): Score;
@@ -68,4 +71,5 @@ export interface ScoreJSON {
     swing?: boolean;
     subtitle?: string;
     genre?: Genre | string;
+    tempoText?: string;
 }

package/dist/models/Score.js

@@ -17,7 +17,8 @@ export class Score {
     swing;
     subtitle;
     genre;
-    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, tempoIsDotted = false, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown) {
+    tempoText;
+    constructor(title, composer, timeSignature, keySignature, parts, bpm = 120, tempoDuration = Duration.Quarter, tempoIsDotted = false, copyright = '', lyricist = '', swing = false, subtitle = '', genre = Genre.Unknown, tempoText = '') {
         this.title = title;
         this.composer = composer;
         this.timeSignature = timeSignature;
@@ -31,18 +32,19 @@ export class Score {
         this.swing = swing;
         this.subtitle = subtitle;
         this.genre = genre;
+        this.tempoText = tempoText;
     }
     withTitle(title) {
-        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     withComposer(composer) {
-        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     withSubtitle(subtitle) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, subtitle, this.genre, this.tempoText);
     }
     withGenre(genre) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, genre, this.tempoText);
     }
     getMeasureCount() {
         return this.parts[0]?.getMeasureCount() ?? 0;
@@ -85,11 +87,22 @@ export class Score {
     }
     static fromJSON(data) {
         const parts = data.parts.map((p) => Part.fromJSON(p));
-        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.tempoIsDotted ?? false, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown);
+        return new Score(data.title, data.composer, data.timeSignature, data.keySignature, parts, data.bpm ?? 120, data.tempoDuration ?? Duration.Quarter, data.tempoIsDotted ?? false, data.copyright ?? '', data.lyricist ?? '', data.swing ?? false, data.subtitle ?? '', data.genre || Genre.Unknown, data.tempoText ?? '');
     }
     transpose(semitones) {
         const semitoneToFifths = {
-            0: 0, 1: 7, 2: 2, 3: -3, 4: 4, 5: -1, 6: 6, 7: 1, 8: -4, 9: 3, 10: -2, 11: 5
+            0: 0,
+            1: 7,
+            2: 2,
+            3: -3,
+            4: 4,
+            5: -1,
+            6: 6,
+            7: 1,
+            8: -4,
+            9: 3,
+            10: -2,
+            11: 5,
         };
         const normalizedSemitones = ((semitones % 12) + 12) % 12;
         const fifthsChange = semitoneToFifths[normalizedSemitones];
@@ -98,7 +111,7 @@ export class Score {
             newFifths -= 12;
         while (newFifths < -7)
             newFifths += 12;
-        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, { fifths: newFifths }, this.parts.map((p) => p.transpose(semitones)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     replaceNote(partIndex, staffIndex, measureIndex, noteIndex, newNote, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -117,7 +130,7 @@ export class Score {
         }
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceMeasure(staffIndex, measureIndex, measureToUse);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     deleteNote(partIndex, staffIndex, measureIndex, noteIndex, voiceIndex = 0) {
         if (partIndex < 0 || partIndex >= this.parts.length)
@@ -173,13 +186,17 @@ export class Score {
                     continue;
                 }
                 const fillPart = parts[0];
-                const filledNote = noteToPaste.withDuration(fillPart.duration, fillPart.isDotted).withTie(true);
+                const filledNote = noteToPaste
+                    .withDuration(fillPart.duration, fillPart.isDotted)
+                    .withTie(true);
                 newScore = newScore.changeNoteDuration(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, fillPart.duration, fillPart.isDotted);
                 newScore = newScore.replaceNote(partIndex, staffIndex, currentMeasureIdx, currentNoteIdx, filledNote);
                 const remainderParts = decomposeDuration(needed - fillPart.val);
                 const remainderNotes = remainderParts.map((p, idx) => {
                     const isLast = idx === remainderParts.length - 1;
-                    return noteToPaste.withDuration(p.duration, p.isDotted).withTie(isLast ? !!noteToPaste.tie : true);
+                    return noteToPaste
+                        .withDuration(p.duration, p.isDotted)
+                        .withTie(isLast ? !!noteToPaste.tie : true);
                 });
                 queue.unshift(...remainderNotes);
                 currentNoteIdx++;
@@ -188,23 +205,39 @@ export class Score {
         return newScore;
     }
     withTempo(bpm, duration, isDotted) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, isDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, bpm, duration, isDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+    }
+    withTempoText(text) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, text);
     }
     withSwing(swing) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, swing, this.subtitle, this.genre, this.tempoText);
     }
     withLyricist(lyricist) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     withCopyright(copyright) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts, this.bpm, this.tempoDuration, this.tempoIsDotted, copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
+    }
+    withParts(parts) {
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, parts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     toJSON() {
         return {
-            title: this.title, composer: this.composer, timeSignature: this.timeSignature, keySignature: this.keySignature,
-            parts: this.parts.map((p) => p.toJSON()), bpm: this.bpm, tempoDuration: this.tempoDuration,
-            tempoIsDotted: this.tempoIsDotted, copyright: this.copyright, lyricist: this.lyricist,
-            swing: this.swing, subtitle: this.subtitle, genre: this.genre,
+            title: this.title,
+            composer: this.composer,
+            timeSignature: this.timeSignature,
+            keySignature: this.keySignature,
+            parts: this.parts.map((p) => p.toJSON()),
+            bpm: this.bpm,
+            tempoDuration: this.tempoDuration,
+            tempoIsDotted: this.tempoIsDotted,
+            copyright: this.copyright,
+            lyricist: this.lyricist,
+            swing: this.swing,
+            subtitle: this.subtitle,
+            genre: this.genre,
+            tempoText: this.tempoText,
         };
     }
     replacePart(partIndex, newPart) {
@@ -212,29 +245,29 @@ export class Score {
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newPart;
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     addPart(newPart) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, [...this.parts, newPart], this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     removePart(partIndex) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = this.parts.filter((_, i) => i !== partIndex);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     replaceStaff(partIndex, staffIndex, newStaff) {
         if (partIndex < 0 || partIndex >= this.parts.length)
             return this;
         const newParts = [...this.parts];
         newParts[partIndex] = newParts[partIndex].replaceStaff(staffIndex, newStaff);
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, newParts, this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     addMeasure(index, measure) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.addMeasure(index, measure)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     deleteMeasure(index) {
-        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre);
+        return new Score(this.title, this.composer, this.timeSignature, this.keySignature, this.parts.map((p) => p.deleteMeasure(index)), this.bpm, this.tempoDuration, this.tempoIsDotted, this.copyright, this.lyricist, this.swing, this.subtitle, this.genre, this.tempoText);
     }
     getPlaybackSequence() {
         const measures = this.parts[0]?.staves[0]?.measures || [];

package/dist/models/types.d.ts

@@ -37,12 +37,25 @@ export declare enum Articulation {
     Tenuto = "tenuto",
     Marcato = "marcato",
     Fermata = "fermata",
-    Staccatissimo = "staccatissimo"
+    Staccatissimo = "staccatissimo",
+    Caesura = "caesura",
+    BreathMark = "breath-mark"
 }
 export declare enum Bowing {
     DownBow = "down-bow",
     UpBow = "up-bow"
 }
+export declare enum Syllabic {
+    Single = "single",
+    Begin = "begin",
+    Middle = "middle",
+    End = "end"
+}
+export interface Lyric {
+    text: string;
+    syllabic?: Syllabic;
+    isExtension?: boolean;
+}
 export declare enum NoteheadShape {
     Normal = "normal",
     Cross = "cross",// X shape (percussion, spoken)
@@ -170,7 +183,8 @@ export declare enum Ornament {
     Mordent = "mordent",
     InvertedMordent = "inverted-mordent",
     Turn = "turn",
-    InvertedTurn = "inverted-turn"
+    InvertedTurn = "inverted-turn",
+    Tremolo = "tremolo"
 }
 export declare const DURATION_VALUES: Record<Duration, number>;
 /**

package/dist/models/types.js

@@ -48,6 +48,8 @@ export var Articulation;
     Articulation["Marcato"] = "marcato";
     Articulation["Fermata"] = "fermata";
     Articulation["Staccatissimo"] = "staccatissimo";
+    Articulation["Caesura"] = "caesura";
+    Articulation["BreathMark"] = "breath-mark";
 })(Articulation || (Articulation = {}));
 // Bowing markings
 export var Bowing;
@@ -55,6 +57,14 @@ export var Bowing;
     Bowing["DownBow"] = "down-bow";
     Bowing["UpBow"] = "up-bow";
 })(Bowing || (Bowing = {}));
+// Lyrics Syllabic types
+export var Syllabic;
+(function (Syllabic) {
+    Syllabic["Single"] = "single";
+    Syllabic["Begin"] = "begin";
+    Syllabic["Middle"] = "middle";
+    Syllabic["End"] = "end";
+})(Syllabic || (Syllabic = {}));
 // Notehead shapes
 export var NoteheadShape;
 (function (NoteheadShape) {
@@ -154,6 +164,7 @@ export var Ornament;
     Ornament["InvertedMordent"] = "inverted-mordent";
     Ornament["Turn"] = "turn";
     Ornament["InvertedTurn"] = "inverted-turn";
+    Ornament["Tremolo"] = "tremolo";
 })(Ornament || (Ornament = {}));
 // Duration values in terms of quarter note = 1
 export const DURATION_VALUES = {

package/dist/utils/tier.d.ts

@@ -0,0 +1,36 @@
+export declare const TOKEN_MODULUS = 17;
+export declare const EXPECTED_REMAINDER = 2;
+export declare const EXPIRATION_MS: number;
+export type UserTier = 'free' | 'premium';
+/**
+ * Obfuscates the user's tier into a numeric token for the viewer.
+ * The viewer expects token % 17 === 2 for premium access.
+ */
+export declare function generateObfuscatedToken(tier: UserTier): number;
+/**
+ * Packs token and timestamp into an obfuscated string.
+ */
+export declare function packToken(token: number, timestamp: number, salt: string): string;
+/**
+ * Unpacks the token string and validates the signature.
+ */
+export declare function unpackToken(packed: string, salt: string): {
+    token: number;
+    timestamp: number;
+} | null;
+/**
+ * Returns the effective numeric token, checking for expiration.
+ */
+export declare function getEffectiveToken(user: any): number;
+/**
+ * Returns the effective tier from the obfuscated token
+ */
+export declare function getTierFromUser(user: any): UserTier;
+/**
+ * Returns true only if the user has a valid, non-expired premium token.
+ */
+export declare function isUserPremium(user: any): boolean;
+/**
+ * Returns true only if the user has a valid, non-expired free token.
+ */
+export declare function isUserFree(user: any): boolean;

package/dist/utils/tier.js

@@ -0,0 +1,112 @@
+export const TOKEN_MODULUS = 17;
+export const EXPECTED_REMAINDER = 2;
+export const EXPIRATION_MS = 24 * 60 * 60 * 1000;
+/**
+ * Obfuscates the user's tier into a numeric token for the viewer.
+ * The viewer expects token % 17 === 2 for premium access.
+ */
+export function generateObfuscatedToken(tier) {
+    const isPremium = tier === 'premium';
+    let base = Math.floor(Math.random() * 8999) + 1000;
+    if (isPremium) {
+        // Ensure token % 17 === 2
+        return base - (base % TOKEN_MODULUS) + EXPECTED_REMAINDER;
+    }
+    else {
+        // Ensure token % 17 !== 2
+        const result = base;
+        return result % TOKEN_MODULUS === EXPECTED_REMAINDER ? result + 1 : result;
+    }
+}
+/**
+ * Packs token and timestamp into an obfuscated string.
+ */
+export function packToken(token, timestamp, salt) {
+    // Use a more robust numeric salt
+    const saltNum = salt
+        .split('')
+        .reduce((acc, char, i) => acc + char.charCodeAt(0) * (i + 1), 0);
+    // Pack components
+    const tHex = token.toString(16);
+    // Obfuscate time using XOR with salt and token
+    const timeKey = (saltNum ^ token) % 1000000;
+    const oTime = (BigInt(timestamp) ^ BigInt(timeKey)).toString(16);
+    // Create a signature that binds token, time and salt
+    const sigPayload = `${token}:${timestamp}:${salt}`;
+    let sig = 0;
+    for (let i = 0; i < sigPayload.length; i++) {
+        sig = (sig << 5) - sig + sigPayload.charCodeAt(i);
+        sig |= 0; // Convert to 32bit integer
+    }
+    const sHex = Math.abs(sig).toString(16);
+    return `${tHex}-${oTime}-${sHex}`;
+}
+/**
+ * Unpacks the token string and validates the signature.
+ */
+export function unpackToken(packed, salt) {
+    try {
+        const [tHex, oTime, sHex] = packed.split('-');
+        if (!tHex || !oTime || !sHex)
+            return null;
+        const token = parseInt(tHex, 16);
+        const saltNum = salt
+            .split('')
+            .reduce((acc, char, i) => acc + char.charCodeAt(0) * (i + 1), 0);
+        const timeKey = (saltNum ^ token) % 1000000;
+        const timestamp = Number(BigInt(parseInt(oTime, 16)) ^ BigInt(timeKey));
+        // Validate signature
+        const sigPayload = `${token}:${timestamp}:${salt}`;
+        let sig = 0;
+        for (let i = 0; i < sigPayload.length; i++) {
+            sig = (sig << 5) - sig + sigPayload.charCodeAt(i);
+            sig |= 0;
+        }
+        const expectedSig = Math.abs(sig).toString(16);
+        if (sHex !== expectedSig)
+            return null;
+        return { token, timestamp };
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Returns the effective numeric token, checking for expiration.
+ */
+export function getEffectiveToken(user) {
+    if (!user)
+        return 0;
+    const accessToken = user.accessToken || user.access_token;
+    if (!accessToken) {
+        return 0;
+    }
+    const salt = (user.uuid || user.id || 'default-salt').toString();
+    const unpacked = unpackToken(accessToken, salt);
+    if (!unpacked)
+        return 0;
+    const now = Date.now();
+    if (now - unpacked.timestamp >= EXPIRATION_MS || now < unpacked.timestamp) {
+        return 0; // Expired
+    }
+    return unpacked.token;
+}
+/**
+ * Returns the effective tier from the obfuscated token
+ */
+export function getTierFromUser(user) {
+    const token = getEffectiveToken(user);
+    return token % TOKEN_MODULUS === EXPECTED_REMAINDER ? 'premium' : 'free';
+}
+/**
+ * Returns true only if the user has a valid, non-expired premium token.
+ */
+export function isUserPremium(user) {
+    return getTierFromUser(user) === 'premium';
+}
+/**
+ * Returns true only if the user has a valid, non-expired free token.
+ */
+export function isUserFree(user) {
+    return getTierFromUser(user) === 'free';
+}