@tspro/web-music-score 1.0.0 → 2.0.0

package/README.md

@@ -2,338 +2,361 @@
 
 This library allows you to view and play music scores (notation) in the browser.
 
-Note: I'm not a professional musician. I began learning classical guitar on my own, 
+I'm not a professional musician. I began learning classical guitar on my own, 
 later taking lessons in classical guitar. I've also studied music theory independently.
 
-This project has been a slow and steady effort over several years. It's now ready for
-public release — though please note that there may still be bugs or unexpected behavior.
+This is a work in progress project. Expect changes, bugs, or unexpected behavior.
 
-## Install
+## Version 2 Update
 
-```sh
-npm i @tspro/web-music-score
+**Breaking:** Version 2 is major update and brought many changes.
 
-# React is required, it is peer dependency
-npm i react
-```
+* Introduced subpath modules instead of one big main module. There is no main export.
+* Theory module had big refactor that affected whole library. Renamed all musical terms that
+  were wrong (e.g. pitch => diatonicId, noteId => chromaticId).
+* Score module stayed mostly same. Some changes (e.g. enum StaffKind => StaffPreset) but nothing major.
+* Classical guitar audio was put into separate module (audio-cg) because it bundles over 1MB of audio
+  samples. Also improved default synthesizer audio.
+* Numerous small changes/improvements.
 
-## Library Bundle
+Enough changes until next major update!
 
-This library is bundled to ESM, CJS and UMD formats.
+## Installation
 
-* CJS and UMD bundles are transpiled with Babel for ES5/IE11 compatibility.
-* ESM bundle targets modern environments (ES6+).
-* Uses ES6 features like Map, etc.
-* No polyfills are included.
+```sh
+npm i @tspro/web-music-score
+```
 
-While designed for compatibility in mind, the library has not been explicitly tested against specific Node.js or browser versions.
+## Import
 
-## Report a Bug
+```js
+// Import core module, it does not contain much.
+import * as Core from "@tspro/web-music-score/core";
 
-Found a bug or unexpected behavior?
+// Import audio module, it can play notes.
+import * as Audio from "@tspro/web-music-score/audio";
 
-[Please open a new issue.](https://github.com/pahkasoft/issues/issues/new)
+// Import theory module, it contains all music theory stuff.
+import * as Theory from "@tspro/web-music-score/theory";
 
-You can also suggest a feature or impovement.
+// Import score module, it contains music score stuff.
+import * as Score from "@tspro/web-music-score/score";
 
-Thanks for helping improve the project!
+// Import react-ui module, it contains all react components.
+// React is peer dependency "^18.0.0 || ^19.0.0".
+import * as ScoreUI from "@tspro/web-music-score/react-ui";
 
-## License
+// Import pieces module, it contains demo songs.
+import * as Pieces from "@tspro/web-music-score/pieces";
 
-This project is licensed under the [MIT License](https://mit-license.org/).
+// You can also use require
+const Core = require("@tspro/web-music-score/core");
 
-It also bundles the [Tone.js](https://github.com/Tonejs/Tone.js) library,
-which is licensed under the [MIT License](https://opensource.org/license/mit).
-
-## Usage And API Documentation
-
-### Import Methods
-```js
-// Import named exports
-import * as Score from "@tspro/web-music-score";
+// etc.
+```
 
-// Or import default export
-import Score from "@tspro/web-music-score";
+## Browser Script
 
-// Or use require
-const Score = require("@tspro/web-music-score");
-```
+This is an experimental module that can be used in html page via unpkg CDN.
+It declares global variable `WebMusicScore` that contains `Core`, `Audio`, `Theory`, `Score`, 
+and `Pieces` as corresponding subpath modules (excluding `react-ui` and `audio-cg`).
 
 ```html
+<script src="https://unpkg.com/@tspro/web-music-score@2.0.0"></script>
+
 <!--
-    Or use in browser via unpkg CDN.
-    Browser version comes without React-components.
--->
-<script src="https://unpkg.com/@tspro/web-music-score@1"></script>
+    It is recommended to use version number (e.g. @2.0.0, at least use @2). This way
+    if there is breaking change between versions your code does not stop working.
 
-<canvas id="scoreCanvas"></canvas><br />
-<button id="playButton"></button>
+    TODO: Add direct link to bundle.
+-->
 
 <script>
-    const Score = window.WebMusicScore;
+    const { Core, Audio, Theory, Score, Pieces } = window.WebMusicScore;
     // ...
 </script>
 ```
 
-### Create Document
-
-```js
-let doc = new Score.MDocument(Score.StaffKind.Treble, 4);
-```
+## API
 
-First argument can be Treble, TrebleForGuitar, Bass or Grand. TrebleForGuitar is same as Treble but one octave lower.
+Typedoc API reference is available [here](https://pahkasoft.github.io). It has no comments but
+is mostly self explanatory and gives idea of full API.
 
-Second argument is number of measures per row, and can be omitted.
+Following is the main interface explained.
 
-## Set Header
+### Create Document
 
 ```js
-doc.setHeader("Title", "Composer", "Arranger");
-doc.setHeader("Title");
+let doc = new Score.MDocument(staffPreset: Score.StaffPreset, options: Score.DocumentOptions);
 ```
+`staffPreset` can be:
+* `Score.StaffPreset.Treble`: Staff with treble (G-) clef.
+* `Score.StaffPreset.Bass`: Staff with bass (F-) clef.
+* `Score.StaffPreset.Grand`: Both treble and bas staves.
+* `Score.StaffPreset.GuitarTreble`: `Treble` but one octave lower.
+* `Score.StaffPreset.GuitarTab`: Guitar tab only.
+* `Score.StaffPreset.GuitarCombined`: Treble and tab for guitar.
 
-Any of title, composer and arranger can be omitted/set undefined.
-
-### Add Measure
-
-```js
-let m = doc.addMeasure();
+Second argument is optional `DocumentOptions`:
+```ts
+DocumentOptions = { measuresPerRow?: number, tuning?: string }
 ```
 
-### End Row
+Default tuning is `"Standard"`. `Theory.TuningNameList` is array of available tuning names.
 
 ```js
-m.endRow();
+// Example
+let doc = new Score.MDocument(Score.StaffPreset.GuitarCombined, { tuning: "Drop D" });
 ```
 
-Manually induce row change. Next measure will be added to new row.
-
-### Set Signature
+### Set Header
 
 ```js
-m.setKeySignature("C", Score.ScaleType.Major);
-```
-
-Firat argument is scale key note.
-
-Second argument is scale type, which can be Major, NaturalMinor, HarmonicMinor, Ionian, Dorian, Phrygian, Lydian, Mixolydian, 
-Aeolian, Locrian, MajorPentatonic, MinorPentatonic, MajorHexatonicBlues, MinorHexatonicBlues or HeptatonicBlues.
+doc.setHeader(title?: string, composer?: string, arranger?: string);
 
-```js
-m.setTimeSignature("4/4");
+// Example
+doc.setHeader("Demo Song");
 ```
 
-Time signature can be "2/4", "3/4", "4/4", "6/8" or "9/8".
+### Add Measure
 
 ```js
-m.setTempo(80, Score.NoteLength.Quarter, false);
-m.setTempo(80);
+let m = doc.addMeasure();
 ```
 
-First argument is beats per minute.
-
-Second argument is beat length. Third argument tells if beat length is dotted. Second and third arguments can be omitted.
-
-### Adding Notes and chords
+### End Row
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter);
-m.addChord(1, ["C3", "E3", "G3", "C4"], Score.NoteLength.Whole);
+m.endRow();
 ```
 
-First argument is voice track id and can be 0, 1, 2 or 3.
-
-Second argument is note or list of notes for chord.
+Manually induce row change. Next measure that is added will start new row.
 
-Third argument is note length. Note length can be Whole, Half, Quarter, Eighth, Sixteenth, ThirdySecond or SixtyFourth.
+### Set Signature
 
-### Add Rest
+```js
+m.setKeySignature(tonic: string, scaleType: Theory.ScaleType);
 
-```js    
-m.addRest(0, Score.NoteLength.Quarter);
+// Example: Am
+m.setKeySignature("A", Theory.ScaleType.Aeolian);
 ```
 
-First argument is voice track id and can be 0, 1, 2 or 3.
+`tonic` is scale tonic/root note, e.g. "C" (in "C Major").
 
-Second argument is rest length. Rest length can be Whole, Half, Quarter, Eighth, Sixteenth, ThirdySecond or SixtyFourth.
-
-### Note And Rest Options
-
-#### Doted Note And Rest
+ `scaleType` can be
+ - `Theory.ScaleType.Major`
+ - `Theory.ScaleType.NaturalMinor`
+ - `Theory.ScaleType.HarmonicMinor`
+ - `Theory.ScaleType.Ionian`
+ - `Theory.ScaleType.Dorian`
+ - `Theory.ScaleType.Phrygian`
+ - `Theory.ScaleType.Lydian`
+ - `Theory.ScaleType.Mixolydian`
+ - `Theory.ScaleType.Aeolian`
+ - `Theory.ScaleType.Locrian`
+ - `Theory.ScaleType.MajorPentatonic`
+ - `Theory.ScaleType.MinorPentatonic`
+ - `Theory.ScaleType.MajorHexatonicBlues`
+ - `Theory.ScaleType.MinorHexatonicBlues`
+ - `Theory.ScaleType.HeptatonicBlues`
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter, { dotted: true });
-m.addRest(0, Score.NoteLength.Quarter, { dotted: true });
-```
-
-#### Stem Direction
+m.setTimeSignature(timeSignature: string);
 
-```js
-m.addNote(0, "C3", Score.NoteLength.Quarter, { stem: Stem.Up });
+// Example
+m.setTimeSignature("3/4");
 ```
 
-Stem  direction can be Auto, Up or Down
-
-#### Arpeggio
+timeSignature can be:
+- `"2/4"`
+- `"3/4"`
+- `"4/4"`
+- `"6/8"`
+- `"9/8"`
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter, { arpeggio: Arpeggio.Down });
-```
-
-Play this column of notes in arpeggio. Arpeggio can be Up or Down.
+m.setTempo(beatsPerMinute: number, beatLength?: Theory.NoteLength, dotted?: boolean);
 
-#### Staccato
-
-```js
-m.addNote(0, "C3", Score.NoteLength.Quarter, { staccato: true });
+// Example
+m.setTempo(100, Theory.NoteLength.Quarter);
 ```
 
-#### Diamond Note Head
+`beatsPerMinute` is self explanatory.
 
-```js
-m.addNote(0, "C3", Score.NoteLength.Quarter, { diamond: true });
-```
+`beatLength` tells  the length of each beat, e.g. Theory.NoteLength.Quarter.
 
-#### Add Ties And Slurs
+`dotted` tells if `beatLength` is dotted.
 
-```js
-m.addNote(0, "C3", Score.NoteLength.Half, { tieSpan: 2, tiePos: Score.ArcPos.Below })
-m.addNote(0, "C3", Score.NoteLength.Quarter);
-```
-    
-Adds a tie.
+### Add Note Or Chord
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Eight, { slurSpan: 2, slurPos: Score.ArcPos.Below })
-m.addNote(0, "D3", Score.NoteLength.Eight);
+m.addNote(voiceId: number, note: string, noteLength: Theory.NoteLength, noteOptions?: Score.NoteOptions);
+m.addChord(voiceId: number, notes: string[], noteLength: Theory.NoteLength, noteOptions?: Score.NoteOptions);
+
+// Examples
+m.addNote(0, "C4", Theory.NoteLength.Half, { dotted: true });
+m.addChord(1, ["C3", "E3", "G3"], Theory.NoteLength.Whole, { arpeggio: Score.Arpeggio.Down });
 ```
 
-Adds a slur.
+`voiceId` can be `0`, `1`, `2` or `3`.
 
-ArcPos can be Auto, Above (above note head), Middle (next to note head), Below (below note head), StemTip.
+`note` is note name, e.g. `"G#3"`, `"Db3"`.
 
-#### Add Triplet
+`notes`: array of notes `string[]` (e.g. `["C3", "E3"]`)
 
-```js
-doc.addMeasure()
-    .addNote(0, "C3", Score.NoteLength.Eight, { triplet: true })
-    .addNote(0, "D3", Score.NoteLength.Eight, { triplet: true })
-    .addNote(0, "E3", Score.NoteLength.Eight, { triplet: true });
-```
+`noteLength` can be:
+* `Theory.NoteLength.Whole`
+* `Theory.NoteLength.Half`
+* `Theory.NoteLength.Quarter`
+* `Theory.NoteLength.Eighth`
+* `Theory.NoteLength.Sixteenth`
+* `Theory.NoteLength.ThirtySecond`
+* `Theory.NoteLength.SixtyFourth`
 
-Adds triplet between three notes or rest of equal length.
+`noteOptions` is optional object of note options (e.g. `{ dotted: true }`):
 
-```js
-doc.addMeasure()
-    .addNote(0, "C3", Score.NoteLength.Eight, { triplet: true })
-    .addRest(0, Score.NoteLength.Quarter, { triplet: true });
-```
+| Note option | Type                      |                     |
+|-------------|---------------------------|---------------------|
+| dotted      | `boolean`                 | Create dotted note. |
+| stem        | `Score.Stem.Auto/Up/Down` | Set stem direction. |
+| arpeggio    | `Score.Arpeggio.Up/Down` \| `boolean`  | Play column in arpeggio. |
+| staccato    | `boolean`               | Play column in staccato. |
+| diamond     | `boolean`               | Diamond shaped note head. |
+| tieSpan     | `number` \| `TieType.Stub/ToMeasureEnd` | How many notes this tie spans. |
+| tieAnchor   | `Score.NoteAnchor.Auto/Above/Center/Below/StemTip` | Tie attach point. |
+| slurSpan    | `number`                | How many notes this slur spans. |
+| slurAnchor  | `Score.NoteAnchor.Auto/Above/Center/Below/StemTip` | Slur attach point. |
+| triplet     | `boolean`               | Set this note part of triplet. |
+| string      | `number` \| `number[]`  | String number for guitar tab. Array of string numbers for chord. |
 
-Triplet can also be added between two notes or rest. Other note or rest is double length of the other.
+### Add Rest
 
-#### Rest Pitch
+```js    
+m.addRest(voideId: number, restLength: Theory.NoteLength, restOptions?: Score.RestOptions);
 
-```js
-m.addRest(0, Score.NoteLength.Quarter, { pitch: "C3" });
+// Example
+m.addRest(0, Theory.NoteLength.Sixteenth);
 ```
 
-Positions rest at the pitch level of note "C3".
+ `voiceId` can be `0`, `1`, `2` or `3`.
 
-#### Hide Rest
+`restLength` is length of rest, similar as noteLength above.
 
-```js
-m.addRest(0, Score.NoteLength.Quarter, { hide: true });
-```
+`restOptions` is optional object of rest options (e.g. `{ hide: true }`):
 
-Creates invisible rest.
+| Rest option | Type         |                     |
+|-------------|--------------|---------------------|
+| dotted      | `boolean`    | Create dotted rest. |
+| staffPos    | `string`     | Staff positions (e.g. `"C3"`). |
+| hide        | `boolean`    | Add invisible rest. |
+| triplet     | `boolean`    | Set this rest part of triplet. |
 
 ### Add Fermata
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter).addFermata(Score.Fermata.AtNote);
-m.addRest(0, Score.NoteLength.Quarter).addFermata();
-```
+m.addFermata(fermata?: Score.Fermata);
 
-Adds fermata anchored to previously added note or rest.
-
-```js
+// Example
 m.addFermata(Score.Fermata.AtMeasureEnd);
 ```
 
-Adds fermata at measure end.
+`fermata` is typeof `Score.Fermata` and can be:
+- `Score.Fermata.AtNote`: Adds fermata anchored to previously added note, chord or rest.
+- `Score.Fermata.AtMeasureEnd`: Adds fermata at the end of measure.
 
 ### Add Navigation
 
+Add navigational element to measure.
+
 ```js
-m.addNavigation(Score.Navigation.DC_al_Fine);
+m.addNavigation(navigation: Score.Navigation, ...args?);
+
+// Examples
+m.addNavigation(Score.Navigation.StartRepeat);
+m.addNavigation(Score.Navigation.EndRepeat, 3);
+m.addNavigation(Score.Navigation.Ending, 1, 2);
 ```
 
-Adds navigational element to measure.
+`navigation` can be:
+* `Score.Navigation.DC_al_Fine`
+* `Score.Navigation.DC_al_Coda`
+* `Score.Navigation.DS_al_Fine`
+* `Score.Navigation.DS_al_Coda`
+* `Score.Navigation.Coda`
+* `Score.Navigation.toCoda`
+* `Score.Navigation.Segno`
+* `Score.Navigation.Fine`
+* `Score.Navigation.StartRepeat`
+* `Score.Navigation.EndRepeat`
+* `Score.Navigation.Ending`
+
+`Score.Navigation.EndRepeat` takes optional second arg which is number of times to repeat (once if omitted).
 
-Available navigations are:
+`Score.Navigation.Ending` takes variable number of number args, each is a passage number.
 
-* Navigation.DC\_al\_Fine
-* Navigation.DC\_al\_Coda
-* Navigation.DS\_al\_Fine
-* Navigation.DS\_al\_Coda
-* Navigation.Coda
-* Navigation.toCoda
-* Navigation.Segno
-* Navigation.Fine
-* Navigation.StartRepeat
-* Navigation.EndRepeat
-* Navigation.Ending
+### Add Label
 
-Navigation.EndRepeat takes optional second argument which is number of repeats. Defaults to 1 if omitted.
+Add text label anchored to previously added note, chord or rest.
 
 ```js
-m.addNavigation(Score.Navigation.EndRepeat, 2);
+m.addLabel(label: Score.Label, text: string);
+
+// Example
+m.addLabel(Score.Label.Chord, "Am);
 ```
 
-Navigation.Ending takes variable number of arguments, each is a passage number.
+`label` can be:
+* `Score.Label.Note`: Used to label notes and is positioned below note.
+* `Score.Label.Chord`: Used to label chords and is positioned on top.
 
-```js
-m.addNavigation(Score.Navigation.Ending, 1, 2);
-m.addNavigation(Score.Navigation.Ending, 3);
-```
+### Add Annotation
 
-### Add Label
+Add annotation text anchored to previously added note, chord or rest.
 
 ```js
-m.addChord(0, ["D3", "F3", "A3"], Score.NoteLength.Quarter).addLabel(Score.Label.Chord, "Dm");
+m.addAnnotation(annotation: Score.Annotation, text: string);
+
+// Example
+m.addAnnotation(Score.Annotation.Tempo, "accel.");
 ```
 
-Available Label types are:
+`annotation` can be:
+* `Score.Annotation.Dynamics`: `text` could be for example `"fff"`, `"cresc."`, `"dim."`, etc.
+* `Score.Annotation.Tempo`: `text` could be for example `"accel."`, `"rit."`, `"a tempo"`, etc.
 
-* Label.Note is used to label notes and is positioned below note.
-* Label.Chord is used to label chords and is positioned on top.
+### Add Extension
 
-### Add Annotation
+Adds extension line to element, for example to previously added annotation.
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter).addAnnotation(Score.Annotation.Dynamics, "fff");
+m.addExtension(extensionLength: number, visible?: boolean);
+
+// Example
+m.addAnnotation(Score.Annotation.Tempo, "accel.").addExtension(Theory.NoteLength.Whole * 2, true);
 ```
 
-First argument is Annotation, second argument is the annotation text.
+`extensionLength` is `number` but `Theory.NoteLength` values can be used as number and multiplied to set desired extension length.
 
-Available annotations are:
+`visible` sets visibility of extension line, visible by default (if omitted).
 
-* Annotation.Dynamics could be for example "fff", "cresc.", "dim.", etc.
-* Annotation.Tempo could be for example "accel.", "rit.", "a tempo", etc.
+### Guitar Tab
 
-### Add Extension
+This library has preliminary guitar tabs rendering. 
+Create document with `Score.StaffPreset.GuitarTab` or `Score.StaffPreset.GuitarCombined`, and specify tuning (defaults to `"Standard"` if omitted).
 
 ```js
-m.addNote(0, "C3", Score.NoteLength.Quarter).
-    addAnnotation(Score.Annotation.Tempo, "accel.").
-    addExtension(Score.NoteLength.Whole * 2, true);
+let doc = new Score.MDocument(Score.StaffPreset.GuitarCombined, { tuning: "Standard" });
 ```
 
-Adds extension line to element, annotation in this case.
+Add notes with `{ string: number | number[] }` to specify which string the fret number is rendered in guitar tab.
 
-First argument is extension length, of type number. NoteLength values can be used as number, and NoteLength values can be multiplied to set desired extension length.
+```js
+// Single note
+m.addNote(0, "G3", Theory.NoteLength.Eighth, { string: 3 });
 
-Second argument is true/false whether extension line is visible. This argument cvan be omitted, extension line is visible by default.
+// Multi note
+m.addChord(0, ["E4", "C3"], Theory.NoteLength.Eighth, { string: [1, 5] });
+```
 
 ### Queueing
 
@@ -341,30 +364,35 @@ Adding stuff to measures can be queued like this:
 
 ```js
 doc.addMeasure()
-    .addNote(1, "C3", Score.NoteLength.Quarter)
-    .addChord(1, ["C3", "E3", "G3"], Score.NoteLength.Quarter).addLabel(Score.Label.Chord, "C")
-    .addRest(1, Score.NoteLength.Quarter);
+    .addNote(1, "C3", Theory.NoteLength.Quarter)
+    .addChord(1, ["C3", "E3", "G3"], Theory.NoteLength.Quarter).addLabel(Score.Label.Chord, "C")
+    .addRest(1, Theory.NoteLength.Quarter);
 ```
 
 ### Beams
 
 Beams are detected and added automatically.
 
-### Play Document
+### Classical Guitar Audio Module
 
-```js
-Score.Audio.setInstrument(Score.Audio.Instrument.ClassicalGuitar);
-```
+Default instrument is `Synthesizer`.
 
-Sets instrument. Instrument can be ClassicalGuitar or Synth.
+`Classical Guitar` is available via `audio-cg` module.
+It was included as separate module because it contains over 1MB of audio samples bundled in it.
 
 ```js
-doc.play();
+import { registerClassicalGuitar } from "@tspro/web-music-score/audio-cg";
+
+registerClassicalGuitar();
 ```
 
-Plays the document.
+### Play Document
 
 ```js
+// Simple play
+doc.play();
+
+// More playback options:
 let player = new MPlayer(doc);
 
 player.play();
@@ -374,21 +402,19 @@ player.stop();
 MPlayer.stopAll();
 ```
 
-More playback methods.
-
 ### Viewing Using React JSX/TSX
 
 ```js
 // Draw document
-<Score.MusicScoreView doc={doc} />
+<ScoreUI.MusicScoreView doc={doc} />
 
 // Add playback buttons
-<Score.PlaybackButtons doc={doc} buttonLayout={Score.PlaybackButtonsLayout.PlayStopSingle}/> // Single Play/Stopo button
-<Score.PlaybackButtons doc={doc} buttonLayout={Score.PlaybackButtonsLayout.PlayStop}/> // Play and Stop buttons
-<Score.PlaybackButtons doc={doc} buttonLayout={Score.PlaybackButtonsLayout.PlayPauseStop}/> // Play, Pause and Stop buttons
+<ScoreUI.PlaybackButtons doc={doc} buttonLayout={ScoreUI.PlaybackButtonsLayout.PlayStopSingle}/> // Single Play/Stopo button
+<ScoreUI.PlaybackButtons doc={doc} buttonLayout={ScoreUI.PlaybackButtonsLayout.PlayStop}/>       // Play and Stop buttons
+<ScoreUI.PlaybackButtons doc={doc} buttonLayout={ScoreUI.PlaybackButtonsLayout.PlayPauseStop}/>  // Play, Pause and Stop buttons
 ```
 
-Bootstrap is used for better visual appearance but you must load it.
+Bootstrap is used for better visual appearance, but it needs to be installed and loaded.
 
 ### Viewing Using Plain JS/TS
 
@@ -427,17 +453,38 @@ p.setPlayStopButton("playStopButtonId")
 p.setPlayButton(playButtonElement)
 ```
 
-### Error Handling
-
+### MusicError
 ```js
 try {
-    // Invalid note "C" without octave.
-    m.addNote(0, "C", Score.NoteLength.Quarter);        
+    // Do your music stuff
 }
-catch(e) {
-    // MusicError is raised on errors.
-    if(e instanceof Score.MusicError) {
-        console.log(e);
+catch (e) {
+    if(e instanceof Core.MusicError) {
+        // There was music error.
     }
 }
 ```
+
+## Compatibility
+- This library is bundled to ESM, CJS and IIFE formats.
+- Target is to support ES6/ES2015.
+- No polyfills are included.
+
+While designed for compatibility in mind, the library has not been explicitly tested against specific Node.js or browser versions.
+
+## Report a Bug
+
+Found a bug or unexpected behavior?
+
+[Please open a new issue.](https://github.com/pahkasoft/issues/issues/new)
+
+You can also suggest a feature or impovement.
+
+Thanks for helping improve the project!
+
+## License
+
+This project is licensed under the [MIT License](https://mit-license.org/).
+
+It also bundles the [Tone.js](https://github.com/Tonejs/Tone.js) library,
+which is licensed under the [MIT License](https://opensource.org/license/mit).