A JavaScript library for parsing and formatting chord sheets
Contents
ChordSheetJS
is on npm, to install run:
npm install chordsheetjs
Load with import
:
import ChordSheetJS from 'chordsheetjs';
or require()
:
var ChordSheetJS = require('chordsheetjs').default;
const chordSheet = `
Am C/G F C
Let it be, let it be, let it be, let it be
C G F C/E Dm C
Whisper words of wisdom, let it be`.substring(1);
const parser = new ChordSheetJS.ChordSheetParser();
const song = parser.parse(chordSheet);
const chordSheet = `
[Chorus]
Am C/G F C
Let it be, let it be, let it be, let it be
C G F C/E Dm C
Whisper words of wisdom, let it be`.substring(1);
const parser = new ChordSheetJS.UltimateGuitarParser();
const song = parser.parse(chordSheet);
const chordSheet = `
{title: Let it be}
{subtitle: ChordSheetJS example version}
{Chorus}
Let it [Am]be, let it [C/G]be, let it [F]be, let it [C]be
[C]Whisper words of [G]wisdom, let it [F]be [C/E] [Dm] [C]`.substring(1);
const parser = new ChordSheetJS.ChordProParser();
const song = parser.parse(chordSheet);
const formatter = new ChordSheetJS.TextFormatter();
const disp = formatter.format(song);
const formatter = new ChordSheetJS.HtmlTableFormatter();
const disp = formatter.format(song);
const formatter = new ChordSheetJS.HtmlDivFormatter();
const disp = formatter.format(song);
const formatter = new ChordSheetJS.ChordProFormatter();
const disp = formatter.format(song);
Chord sheets (Song
s) can be serialized to plain JavaScript objects, which can be converted to JSON, XML etc by
third-party libraries. The serialized object can also be deserialized back into a Song
.
const serializedSong = new ChordSheetSerializer().serialize(song);
const deserialized = new ChordSheetSerializer().deserialize(serializedSong);
The HTML formatters (HtmlTableFormatter and HtmlDivFormatter) can provide basic CSS to help with styling the output:
HtmlTableFormatter.cssString();
// .paragraph {
// margin-bottom: 1em;
// }
HtmlTableFormatter.cssString('.chordSheetViewer');
// .chordSheetViewer .paragraph {
// margin-bottom: 1em;
// }
HtmlTableFormatter.cssObject();
// '.paragraph': {
// marginBottom: '1em'
// }
import { parseChord } from 'chordsheetjs';
const chord = parseChord('Ebsus4/Bb');
Parse numeric chords (Nashville system):
const chord = parseChord('b1sus4/#3');
Use #toString() to convert the chord to a chord string (eg Dsus/F#)
const chord = parseChord('Ebsus4/Bb');
chord.toString(); // --> "Ebsus4/Bb"
var chord2 = chord.clone();
Normalizes keys B#, E#, Cb and Fb to C, F, B and E
const chord = parseChord('E#/B#'),
normalizedChord = chord.normalize();
normalizedChord.toString(); // --> "F/C"
Convert # to b and vice versa
const chord = parseChord('Eb/Bb');
const chord2 = chord.switchModifier();
chord2.toString(); // --> "D#/A#"
Set the chord to a specific modifier (# or b)
const chord = parseChord('Eb/Bb');
const chord2 = chord.useModifier('#');
chord2.toString(); // --> "D#/A#"
const chord = parseChord('Eb/Bb');
const chord2 = chord.useModifier('b');
chord2.toString(); // --> "Eb/Bb"
const chord = parseChord('Eb/Bb');
const chord2 = chord.transposeUp();
chord2.toString(); // -> "E/B"
const chord = parseChord('Eb/Bb');
const chord2 = chord.transposeDown();
chord2.toString(); // -> "D/A"
const chord = parseChord('C/E');
const chord2 = chord.transpose(4);
chord2.toString(); // -> "E/G#"
const chord = parseChord('C/E');
const chord2 = chord.transpose(-4);
chord2.toString(); // -> "Ab/C"
const numericChord = parseChord('2/4');
const chordSymbol = toChordSymbol(numericChord, 'E');
chordSymbol.toString(); // -> "F#m/A"
✔️ = supported
🕑 = will be supported in a future version
✖️ = currently no plans to support it in the near future
Directive | Support |
---|---|
title (short: t) | ✔️ |
subtitle | ✔️ |
artist | ✔️ |
composer | ✔️ |
lyricist | ✔️ |
copyright | ✔️ |
album | ✔️ |
year | ✔️ |
key | ✔️ |
time | ✔️ |
tempo | ✔️ |
duration | ✔️ |
capo | ✔️ |
meta | ✔️ |
Directive | Support |
---|---|
comment (short: c) | ✔️ |
comment_italic (short: ci) | ✖️ |
comment_box (short: cb) | ✖️ |
chorus | ✖️ |
image | ✖️ |
Directive | Support |
---|---|
start_of_chorus (short: soc) | ✔️ |
end_of_chorus (short: eoc) | ✔️ |
start_of_verse | ✔️ |
end_of_verse | ✔️ |
start_of_tab (short: sot) | ✖️ |
end_of_tab (short: eot) | ✖️ |
start_of_grid | ✖️ |
end_of_grid | ✖️ |
Directive | Support |
---|---|
define | ✖️ |
chord | ✖️ |
Directive | Support |
---|---|
textfont | 🕑 |
textsize | 🕑 |
textcolour | 🕑 |
chordfont | 🕑 |
chordsize | 🕑 |
chordcolour | 🕑 |
tabfont | ✖️ |
tabsize | ✖️ |
tabcolour | ✖️ |
Directive | Support |
---|---|
new_page (short: np) | ✖️ |
new_physical_page (short: npp) | ✖️ |
column_break (short: cb) | ✖️ |
grid (short: g) | ✖️ |
no_grid (short: ng) | ✖️ |
titles | ✖️ |
columns (short: col) | ✖️ |
Directive | Support |
---|---|
x_ | ✔️ |
Note: all classes, methods and constants that are documented here can be considered public API and will only be subject to breaking changes between major versions.
- ChordLyricsPair
Represents a chord with the corresponding (partial) lyrics
- Comment
Represents a comment. See https://www.chordpro.org/chordpro/chordpro-file-format-specification/#overview
- Metadata
Stores song metadata. Properties can be accessed using the get() method:
const metadata = new Metadata({ author: 'John' }); metadata.get('author') // => 'John'
See [get](#Metadata+get)
- Paragraph
Represents a paragraph of lines in a chord sheet
- Song
Represents a song in a chord sheet. Currently a chord sheet can only have one song.
- Tag
Represents a tag/directive. See https://www.chordpro.org/chordpro/chordpro-directives/
- ChordProFormatter
Formats a song into a ChordPro chord sheet
- Formatter
Base class for all formatters, taking care of receiving a configuration wrapping that inside a Configuration object
- HtmlDivFormatter
Formats a song into HTML. It uses DIVs to align lyrics with chords, which makes it useful for responsive web pages.
- HtmlFormatter
Acts as a base class for HTML formatters, taking care of whitelisting prototype property access.
- HtmlTableFormatter
Formats a song into HTML. It uses TABLEs to align lyrics with chords, which makes the HTML for things like PDF conversion.
- TextFormatter
Formats a song into a plain text chord sheet
- ChordProParser
Parses a ChordPro chord sheet
- ChordSheetParser
Parses a normal chord sheet
- ParserWarning
Represents a parser warning, currently only used by ChordProParser.
- UltimateGuitarParser
Parses an Ultimate Guitar chord sheet with metadata Inherits from [ChordSheetParser](#ChordSheetParser)
- Chord
Represents a Chord, consisting of a root, suffix (quality) and bass
- ChordSheetSerializer
Serializes a song into een plain object, and deserializes the serialized object back into a [Song](#Song)
- ALBUM :
string
Artist meta directive. See https://www.chordpro.org/chordpro/directives-artist/
- ARTIST :
string
Capo meta directive. See https://www.chordpro.org/chordpro/directives-capo/
- CAPO :
string
Comment directive. See https://www.chordpro.org/chordpro/directives-comment/
- COMMENT :
string
Composer meta directive. See https://www.chordpro.org/chordpro/directives-composer/
- COMPOSER :
string
Copyright meta directive. See https://www.chordpro.org/chordpro/directives-copyright/
- COPYRIGHT :
string
Duration meta directive. See https://www.chordpro.org/chordpro/directives-duration/
- DURATION :
string
End of chorus directive. See https://www.chordpro.org/chordpro/directives-env_chorus/
- END_OF_CHORUS :
string
End of tab directive. See https://www.chordpro.org/chordpro/directives-env_tab/
- END_OF_TAB :
string
End of verse directive. See https://www.chordpro.org/chordpro/directives-env_verse/
- END_OF_VERSE :
string
Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
- KEY :
string
Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
- _KEY :
string
Lyricist meta directive. See https://www.chordpro.org/chordpro/directives-lyricist/
- LYRICIST :
string
Start of chorus directive. See https://www.chordpro.org/chordpro/directives-env_chorus/
- START_OF_CHORUS :
string
Start of tab directive. See https://www.chordpro.org/chordpro/directives-env_tab/
- START_OF_TAB :
string
Start of verse directive. See https://www.chordpro.org/chordpro/directives-env_verse/
- START_OF_VERSE :
string
Subtitle meta directive. See https://www.chordpro.org/chordpro/directives-subtitle/
- SUBTITLE :
string
Tempo meta directive. See https://www.chordpro.org/chordpro/directives-tempo/
- TEMPO :
string
Time meta directive. See https://www.chordpro.org/chordpro/directives-time/
- TIME :
string
Title meta directive. See https://www.chordpro.org/chordpro/directives-title/
- TITLE :
string
Transpose meta directive. See: https://www.chordpro.org/chordpro/directives-transpose/
- TRANSPOSE :
string
New Key meta directive. See: bettermusic#53
- NEW_KEY :
string
Year meta directive. See https://www.chordpro.org/chordpro/directives-year/
- defaultCss ⇒
string
Generates basic CSS, scoped within the provided selector, to use with output generated by [HtmlTableFormatter](#HtmlTableFormatter)
- defaultCss :
Object.<string, Object.<string, string>>
Basic CSS, in object style à la useStyles, to use with output generated by {@link }HtmlTableFormatter} For a CSS string see [scopedCss](scopedCss)
- VERSE :
string
Used to mark a paragraph as verse
- VERSE :
string
Used to mark a paragraph as chorus
- CHORUS :
string
Used to mark a paragraph as not containing a line marked with a type
- NONE :
string
Used to mark a paragraph as containing lines with both verse and chorus type
- INDETERMINATE :
string
Used to mark a paragraph as tab
parseChord(chordString) ⇒null
|Chord
Tries to parse a chord string into a chord
- getCapos(key) ⇒
Object.<string, string>
Returns applicable capos for the provided key
- getKeys(key) ⇒
Array.<string>
Returns applicable keys to transpose to from the provided key
Represents a chord with the corresponding (partial) lyrics
Kind: global class
- ChordLyricsPair
- new ChordLyricsPair(chords, lyrics)
- .chords :
string
- .lyrics :
string
- .isRenderable() ⇒
boolean
- .clone() ⇒
ChordLyricsPair
Initialises a ChordLyricsPair
Param | Type | Description |
---|---|---|
chords | string |
The chords |
lyrics | string |
The lyrics |
The chords
Kind: instance property of ChordLyricsPair
The lyrics
Kind: instance property of ChordLyricsPair
Indicates whether a ChordLyricsPair should be visible in a formatted chord sheet (except for ChordPro sheets)
Kind: instance method of ChordLyricsPair
chordLyricsPair.clone() ⇒ ChordLyricsPair
Returns a deep copy of the ChordLyricsPair, useful when programmatically transforming a song
Kind: instance method of ChordLyricsPair
Represents a comment. See https://www.chordpro.org/chordpro/chordpro-file-format-specification/#overview
Kind: global class
- Comment
- .isRenderable() ⇒
boolean
- .clone() ⇒
Comment
- .isRenderable() ⇒
Indicates whether a Comment should be visible in a formatted chord sheet (except for ChordPro sheets)
Kind: instance method of Comment
comment.clone() ⇒ Comment
Returns a deep copy of the Comment, useful when programmatically transforming a song
Kind: instance method of Comment
Stores song metadata. Properties can be accessed using the get() method:
const metadata = new Metadata({ author: 'John' }); metadata.get('author') // => 'John'
See [get](#Metadata+get)
Kind: global class
- Metadata
- .get(prop) ⇒
Array.<String>
|String
- .clone() ⇒
Metadata
- .get(prop) ⇒
Reads a metadata value by key. This method supports simple value lookup, as fetching single array values.
This method deprecates direct property access, eg: metadata['author']
Examples:
const metadata = new Metadata({ lyricist: 'Pete', author: ['John', 'Mary'] }); metadata.get('lyricist') // => 'Pete' metadata.get('author') // => ['John', 'Mary'] metadata.get('author.1') // => 'John' metadata.get('author.2') // => 'Mary'
Using a negative index will start counting at the end of the list:
const metadata = new Metadata({ lyricist: 'Pete', author: ['John', 'Mary'] }); metadata.get('author.-1') // => 'Mary' metadata.get('author.-2') // => 'John'
Kind: instance method of Metadata
Returns: Array.<String>
| String
-
the metadata value(s). If there is only one value, it will return a String, else it returns an array of strings.
Param | Description |
---|---|
prop | the property name |
metadata.clone() ⇒ Metadata
Returns a deep clone of this Metadata object
Kind: instance method of Metadata
Returns: Metadata
-
the cloned Metadata object
Represents a paragraph of lines in a chord sheet
Kind: global class
- Paragraph
- .type ⇒
string
- .hasRenderableItems() ⇒
boolean
- .type ⇒
Tries to determine the common type for all lines. If the types for all lines are equal, it returns that type. If not, it returns [INDETERMINATE](#INDETERMINATE)
Kind: instance property of Paragraph
Indicates whether the paragraph contains lines with renderable items.
Kind: instance method of Paragraph
See: Line.hasRenderableItems
Represents a song in a chord sheet. Currently a chord sheet can only have one song.
Kind: global class
- Song
- new Song(metadata)
- .bodyLines ⇒
Array.<Line>
- .bodyParagraphs ⇒
Array.<Paragraph>
.metaData ⇒- .clone() ⇒
Song
- .setCapo(capo) ⇒
Song
- .setKey(key) ⇒
Song
Creates a new {Song} instance
Param | Type | Description |
---|---|---|
metadata | Object | Metadata |
predefined metadata |
Returns the song lines, skipping the leading empty lines (empty as in not rendering any content). This is useful if you want to skip the "header lines": the lines that only contain meta data.
Kind: instance property of Song
Returns: Array.<Line>
-
The song body lines
song.bodyParagraphs ⇒ Array.<Paragraph>
Returns the song paragraphs, skipping the paragraphs that only contain empty lines (empty as in not rendering any content)
Kind: instance property of Song
See: bodyLines
Deprecated
The song's metadata. Please use [metadata](metadata) instead.
Kind: instance property of Song
Returns:
Metadata The metadata
song.clone() ⇒ Song
Returns a deep clone of the song
Kind: instance method of Song
Returns: Song
-
The cloned song
song.setCapo(capo) ⇒ Song
Returns a copy of the song with the capo value set to the specified capo. It changes:
- the value for
capo
in themetadata
set - any existing
capo
directive)
Kind: instance method of Song
Returns: Song
-
The changed song
Param | Type | Description |
---|---|---|
capo | number | null |
the capo. Passing
|
song.setKey(key) ⇒ Song
Returns a copy of the song with the key set to the specified key. It changes:
- the value for
key
in themetadata
set - any existing
key
directive - all chords, those are transposed according to the distance between the current and the new key
Kind: instance method of Song
Returns: Song
-
The changed song
Param | Type | Description |
---|---|---|
key | string |
The new key. |
Represents a tag/directive. See https://www.chordpro.org/chordpro/chordpro-directives/
Kind: global class
- Tag
- .name :
string
- .originalName :
string
- .value :
string
|null
- .hasValue() ⇒
boolean
- .isRenderable() ⇒
boolean
- .isMetaTag() ⇒
boolean
- .clone() ⇒
Tag
- .name :
The tag full name. When the original tag used the short name, name
will return the full name.
Kind: instance property of Tag
The original tag name that was used to construct the tag.
Kind: instance property of Tag
The tag value
Kind: instance property of Tag
Checks whether the tag value is a non-empty string.
Kind: instance method of Tag
Checks whether the tag is usually rendered inline. It currently only applies to comment tags.
Kind: instance method of Tag
Checks whether the tag is either a standard meta tag or a custom meta directive ({x_some_name}
)
Kind: instance method of Tag
tag.clone() ⇒ Tag
Returns a clone of the tag.
Kind: instance method of Tag
Returns: Tag
-
The cloned tag
Formats a song into a ChordPro chord sheet
Formats a song into a ChordPro chord sheet.
Kind: instance method of ChordProFormatter
Returns: string
-
The ChordPro string
Param | Type | Description |
---|---|---|
song | Song |
The song to be formatted |
Base class for all formatters, taking care of receiving a configuration wrapping that inside a Configuration object
Instantiate
Param | Type | Default | Description |
---|---|---|---|
[configuration] | Object |
{} |
options |
[configuration.evaluate] | boolean |
false |
Whether or not to evaluate meta expressions. For more info about meta expressions, see: https://bit.ly/2SC9c2u |
[configuration.metadata] | object |
{} |
|
[configuration.metadata.separator] | string |
"", "" |
The separator to be used when rendering a metadata value that has multiple values. See: https://bit.ly/2SC9c2u |
Formats a song into HTML. It uses DIVs to align lyrics with chords, which makes it useful for responsive web pages.
Kind: global class
- HtmlDivFormatter
- instance
- .format(song) ⇒
string
- .format(song) ⇒
- static
- .cssString(scope) ⇒
string
- .cssObject() ⇒
Object.<string, Object.<string, string>>
- .cssString(scope) ⇒
- instance
Formats a song into HTML.
Kind: instance method of HtmlDivFormatter
Returns: string
-
The HTML string
Param | Type | Description |
---|---|---|
song | Song |
The song to be formatted |
Generates basic CSS, optionally scoped within the provided selector, to use with output generated by [HtmlDivFormatter](#HtmlDivFormatter)
For example, execute cssString('.chordSheetViewer') will result in CSS like:
.chordSheetViewer .paragraph {
margin-bottom: 1em;
}
Kind: static method of HtmlDivFormatter
Returns: string
-
the CSS string
Param | Description |
---|---|
scope | the CSS scope to use, for example |
Basic CSS, in object style à la useStyles, to use with output generated by [HtmlDivFormatter](#HtmlDivFormatter)
Example:
'.paragraph': {
marginBottom: '1em'
}
For a CSS string see [cssString](cssString)
Kind: static method of HtmlDivFormatter
Returns: Object.<string, Object.<string, string>>
-
the CSS object
Acts as a base class for HTML formatters, taking care of whitelisting prototype property access.
Formats a song into HTML. It uses TABLEs to align lyrics with chords, which makes the HTML for things like PDF conversion.
Kind: global class
- HtmlTableFormatter
- instance
- .format(song) ⇒
string
- .format(song) ⇒
- static
- .cssString(scope) ⇒
string
- .cssObject() ⇒
Object.<string, Object.<string, string>>
- .cssString(scope) ⇒
- instance
Formats a song into HTML.
Kind: instance method of HtmlTableFormatter
Returns: string
-
The HTML string
Param | Type | Description |
---|---|---|
song | Song |
The song to be formatted |
Generates basic CSS, optionally scoped within the provided selector, to use with output generated by [HtmlTableFormatter](#HtmlTableFormatter)
For example, execute cssString('.chordSheetViewer') will result in CSS like:
.chordSheetViewer .paragraph {
margin-bottom: 1em;
}
Kind: static method of HtmlTableFormatter
Returns: string
-
the CSS string
Param | Description |
---|---|
scope | the CSS scope to use, for example |
Basic CSS, in object style à la useStyles, to use with output generated by [HtmlTableFormatter](#HtmlTableFormatter) For a CSS string see [cssString](cssString)
Example:
'.paragraph': {
marginBottom: '1em'
}
Kind: static method of HtmlTableFormatter
Returns: Object.<string, Object.<string, string>>
-
the CSS object
Formats a song into a plain text chord sheet
Formats a song into a plain text chord sheet
Kind: instance method of TextFormatter
Returns: string
-
the chord sheet
Param | Type | Description |
---|---|---|
song | Song |
The song to be formatted |
Parses a ChordPro chord sheet
Kind: global class
chordProParser.warnings : Array.<ParserWarning>
All warnings raised during parsing the ChordPro chord sheet
Kind: instance property of ChordProParser
chordProParser.parse(chordProChordSheet) ⇒ Song
Parses a ChordPro chord sheet into a song
Kind: instance method of ChordProParser
Returns: Song
-
The parsed song
Param | Type | Description |
---|---|---|
chordProChordSheet | string |
the ChordPro chord sheet |
Parses a normal chord sheet
Kind: global class
Instantiate a chord sheet parser
Param | Type | Default | Description |
---|---|---|---|
[options] | Object |
{} |
options |
[options.preserveWhitespace] | boolean |
true |
whether to preserve trailing whitespace for chords |
chordSheetParser.parse(chordSheet, [options]) ⇒ Song
Parses a chord sheet into a song
Kind: instance method of ChordSheetParser
Returns: Song
-
The parsed song
Param | Type | Default | Description |
---|---|---|---|
chordSheet | string |
The ChordPro chord sheet |
|
[options] | Object |
{} |
Optional parser options |
[options.song] | Song |
|
The Song to store the song data in |
Represents a parser warning, currently only used by ChordProParser.
Returns a stringified version of the warning
Kind: instance method of ParserWarning
Returns: string
-
The string warning
Parses an Ultimate Guitar chord sheet with metadata Inherits from [ChordSheetParser](#ChordSheetParser)
Represents a Chord, consisting of a root, suffix (quality) and bass
Kind: global class
- Chord
- instance
- .clone() ⇒
Chord
- .toChordSymbol([key]) ⇒
Chord
- .toChordSymbolString([key]) ⇒
string
- .isChordSymbol() ⇒
boolean
- .toNumeric([key]) ⇒
Chord
- .toNumeral(key) ⇒
Chord
- .toNumeralString([key]) ⇒
string
- .isNumeric() ⇒
boolean
- .toNumericString([key]) ⇒
string
- .isNumeral() ⇒
boolean
- .toString() ⇒
string
- .normalize() ⇒
Chord
- .useModifier(newModifier) ⇒
Chord
- .transposeUp() ⇒
Chord
- .transposeDown() ⇒
Chord
- .transpose(delta) ⇒
Chord
- .clone() ⇒
- static
- .parse(chordString) ⇒
null
|Chord
- .parse(chordString) ⇒
- instance
chord.clone() ⇒ Chord
Returns a deep copy of the chord
Kind: instance method of Chord
chord.toChordSymbol([key]) ⇒ Chord
Converts the chord to a chord symbol, using the supplied key as a reference.
For example, a numeric chord #4
with reference key E
will return the chord symbol A#
.
When the chord is already a chord symbol, it will return a clone of the object.
Kind: instance method of Chord
Returns: Chord
-
the chord symbol
Param | Type | Default | Description |
---|---|---|---|
[key] | Key | string |
|
the reference key |
Converts the chord to a chord symbol string, using the supplied key as a reference.
For example, a numeric chord #4
with reference key E
will return the chord symbol A#
.
When the chord is already a chord symbol, it will return a string version of the chord.
Kind: instance method of Chord
Returns: string
-
the chord symbol string
See: {toChordSymbol}
Param | Type | Default | Description |
---|---|---|---|
[key] | Key | string |
|
the reference key |
Determines whether the chord is a chord symbol
Kind: instance method of Chord
chord.toNumeric([key]) ⇒ Chord
Converts the chord to a numeric chord, using the supplied key as a reference. For example, a chord symbol A# with reference key E will return the numeric chord #4.
Kind: instance method of Chord
Returns: Chord
-
the numeric chord
Param | Type | Default | Description |
---|---|---|---|
[key] | Key | string |
|
the reference key |
chord.toNumeral(key) ⇒ Chord
Converts the chord to a numeral chord, using the supplied key as a reference. For example, a chord symbol A# with reference key E will return the numeral chord #IV.
Kind: instance method of Chord
Returns: Chord
-
the numeral chord
Param | Type | Default | Description |
---|---|---|---|
key | Key | string | null |
|
the reference key. The key is required when converting a chord symbol |
Converts the chord to a numeral chord string, using the supplied kye as a reference. For example, a chord symbol A# with reference key E will return the numeral chord #4.
Kind: instance method of Chord
Returns: string
-
the numeral chord string
See: {toNumeral}
Param | Type | Default | Description |
---|---|---|---|
[key] | Key | string |
|
the reference key |
Determines whether the chord is numeric
Kind: instance method of Chord
Converts the chord to a numeric chord string, using the supplied kye as a reference. For example, a chord symbol A# with reference key E will return the numeric chord #4.
Kind: instance method of Chord
Returns: string
-
the numeric chord string
See: {toNumeric}
Param | Type | Default | Description |
---|---|---|---|
[key] | Key | string |
|
the reference key |
Determines whether the chord is a numeral
Kind: instance method of Chord
Converts the chord to a string, eg Esus4/G#
or 1sus4/#3
Kind: instance method of Chord
Returns: string
-
the chord string
chord.normalize() ⇒ Chord
Normalizes the chord root and bass notes:
- Fb becomes E
- Cb becomes B
- B# becomes C
- E# becomes F
- 4b becomes 3
- 1b becomes 7
- 7# becomes 1
- 3# becomes 4
Besides that it normalizes the suffix. For example, sus2
becomes 2
, sus4
becomes sus
.
All suffix normalizations can be found in src/normalize_mappings/suffix-mapping.txt
.
Kind: instance method of Chord
Returns: Chord
-
the normalized chord
chord.useModifier(newModifier) ⇒ Chord
Switches to the specified modifier
Kind: instance method of Chord
Returns: Chord
-
the new, changed chord
Param | Description |
---|---|
newModifier | the modifier to use: |
chord.transposeUp() ⇒ Chord
Transposes the chord up by 1 semitone. Eg. A becomes A#, Eb becomes E
Kind: instance method of Chord
Returns: Chord
-
the new, transposed chord
chord.transposeDown() ⇒ Chord
Transposes the chord down by 1 semitone. Eg. A# becomes A, E becomes Eb
Kind: instance method of Chord
Returns: Chord
-
the new, transposed chord
chord.transpose(delta) ⇒ Chord
Transposes the chord by the specified number of semitones
Kind: instance method of Chord
Returns: Chord
-
the new, transposed chord
Param | Description |
---|---|
delta | de number of semitones |
Chord.parse(chordString) ⇒ null
| Chord
Tries to parse a chord string into a chord
Kind: static method of Chord
Param | Description |
---|---|
chordString | the chord string, eg |
Serializes a song into een plain object, and deserializes the serialized object back into a [Song](#Song)
Kind: global class
Serializes the chord sheet to a plain object, which can be converted to any format like JSON, XML etc Can be deserialized using [deserialize](deserialize)
Kind: instance method of ChordSheetSerializer
Returns:
object A plain JS object containing all chord sheet data
chordSheetSerializer.deserialize(serializedSong) ⇒ Song
Deserializes a song that has been serialized using [serialize](serialize)
Kind: instance method of ChordSheetSerializer
Returns: Song
-
The deserialized song
Param | Type | Description |
---|---|---|
serializedSong | object |
The serialized song |
Artist meta directive. See https://www.chordpro.org/chordpro/directives-artist/
Capo meta directive. See https://www.chordpro.org/chordpro/directives-capo/
Comment directive. See https://www.chordpro.org/chordpro/directives-comment/
Composer meta directive. See https://www.chordpro.org/chordpro/directives-composer/
Copyright meta directive. See https://www.chordpro.org/chordpro/directives-copyright/
Duration meta directive. See https://www.chordpro.org/chordpro/directives-duration/
End of chorus directive. See https://www.chordpro.org/chordpro/directives-env_chorus/
End of tab directive. See https://www.chordpro.org/chordpro/directives-env_tab/
End of verse directive. See https://www.chordpro.org/chordpro/directives-env_verse/
Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
Lyricist meta directive. See https://www.chordpro.org/chordpro/directives-lyricist/
Start of chorus directive. See https://www.chordpro.org/chordpro/directives-env_chorus/
Start of tab directive. See https://www.chordpro.org/chordpro/directives-env_tab/
Start of verse directive. See https://www.chordpro.org/chordpro/directives-env_verse/
Subtitle meta directive. See https://www.chordpro.org/chordpro/directives-subtitle/
Tempo meta directive. See https://www.chordpro.org/chordpro/directives-tempo/
Time meta directive. See https://www.chordpro.org/chordpro/directives-time/
Title meta directive. See https://www.chordpro.org/chordpro/directives-title/
Transpose meta directive. See: https://www.chordpro.org/chordpro/directives-transpose/
New Key meta directive. See: bettermusic#53
Year meta directive. See https://www.chordpro.org/chordpro/directives-year/
Generates basic CSS, scoped within the provided selector, to use with output generated by [HtmlTableFormatter](#HtmlTableFormatter)
Kind: global variable
Returns: string
-
the CSS string
Param | Description |
---|---|
scope | the CSS scope to use, for example |
Basic CSS, in object style à la useStyles, to use with output generated by {@link }HtmlTableFormatter} For a CSS string see [scopedCss](scopedCss)
Used to mark a paragraph as verse
Used to mark a paragraph as chorus
Used to mark a paragraph as not containing a line marked with a type
Used to mark a paragraph as containing lines with both verse and chorus type
Used to mark a paragraph as tab
parseChord(chordString) ⇒ null
| Chord
null
| Chord
Deprecated
Tries to parse a chord string into a chord
Kind: global function
Param | Description |
---|---|
chordString | the chord string, eg Esus4/G# or 1sus4/#3 |
Returns applicable capos for the provided key
Kind: global function
Returns: Object.<string, string>
-
The available capos, where the keys are capo numbers and the values are the effective key for that capo.
Param | Type | Description |
---|---|---|
key | Key | string |
The key to get capos for |
Returns applicable keys to transpose to from the provided key
Kind: global function
Returns: Array.<string>
-
The available keys
Param | Type | Description |
---|---|---|
key | Key | string |
The key to get keys for |