songsheet 6.0.0 → 6.2.0

package/CLAUDE.md

@@ -16,15 +16,16 @@ const songInBb = transpose(song, 3, { preferFlats: true })
 
 ```
 index.js              — Public API: re-exports parse + transpose
+index.d.ts            — TypeScript type definitions (adjacent to index.js)
 src/
   lexer.js            — scanChordLine(), isChordLine(), lexExpression()
   parser.js           — parse(), expression parser, section assembly
   transpose.js        — transpose(), note math
 test/
-  lexer.test.js       — Chord line detection, bar lines, edge cases
-  parser.test.js      — All 4 song fixture tests + bar line tests
+  lexer.test.js       — Chord line detection, bar lines, slash chords, edge cases
+  parser.test.js      — All 4 song fixture tests + bar line + time signature tests
   expression.test.js  — Expression parsing and resolution
-  transpose.test.js   — Semitone math, round-trips, flat/sharp preference
+  transpose.test.js   — Semitone math, round-trips, flat/sharp preference, slash chords
 *.txt                 — Song fixtures (do not modify)
 ```
 
@@ -48,10 +49,15 @@ npx vitest run test/parser.test.js   # single file
 {
   title: 'SONG TITLE',
   author: 'AUTHOR NAME',
+  bpm: 120,                // number | null
+  timeSignature: {         // { beats, value } | null
+    beats: 3,
+    value: 4,
+  },
   sections: {
     verse: {
       count: 4,
-      chords: [{ root: 'G', type: '' }, { root: 'F', type: '' }, ...],
+      chords: [{ root: 'G', type: '' }, { root: 'F', type: '', bass: 'B' }, ...],
       lyrics: ['lyric line 1', ...],
       lines: [
         {
@@ -84,21 +90,25 @@ npx vitest run test/parser.test.js   # single file
 
 ## Key Design Decisions
 
-- **Chord line detection**: Exhaustive left-to-right scan — every non-whitespace token must parse as a valid chord or `|`, otherwise the line is lyrics
+- **Chord line detection**: Exhaustive left-to-right scan — every non-whitespace token must parse as a valid chord (including slash chords) or `|`, otherwise the line is lyrics
 - **root includes accidental**: `root: 'Bb'` not `root: 'B', accidental: 'b'`
+- **Slash chords**: `G/B` → `{ root: 'G', type: '', bass: 'B' }`. Bass note is optional — only present on slash chords
 - **Synchronous parse**: No Promise wrapper, plain objects (no Immutable.js)
 - **Expression AST preserved**: `(VERSE, CHORUS*2)` stored as tree AND resolved to flat chords
 - **Character alignment includes barLines**: `{ character: 'r', barLine: true }` at `|` column positions
 - **Column preservation**: Chord lines are never trimmed — column positions match the original file
+- **Title metadata**: BPM and time signature parsed from `(120 BPM, 3/4 time)` in the title block
+- **TypeScript types**: `index.d.ts` adjacent to `index.js` — consumers get types automatically with bundler module resolution
 
 ## Songsheet Format
 
 ```
 SONG TITLE - AUTHOR NAME
+(120 BPM, 3/4 time)
 
 G                               F
  Lyrics aligned under chords...
-               C                G
+               C/E              G/B
  More lyrics here
 
 F                C             D
@@ -155,18 +165,6 @@ This would add a `duration` or `percent` field to chord objects:
 { root: 'G', type: '', percent: 50 }
 ```
 
-### Slash chords
-Parse slash chords like `G/B`, `Am/E`:
-```js
-{ root: 'G', type: '', bass: 'B' }
-```
-
-### Time signature support
-```
-TIME: 3/4
-```
-Stored as `song.timeSignature = { beats: 3, value: 4 }`.
-
 ### Key detection
 Auto-detect the song's key from its chord progression. Useful for intelligent transposition suggestions.
 

package/README.md

@@ -23,10 +23,11 @@ const songInBb = transpose(song, 3, { preferFlats: true })
 
 ```
 SONG TITLE - AUTHOR NAME
+(120 BPM, 3/4 time)
 
 G                               F
  Lyrics aligned under chords...
-               C                G
+               C/E              G/B
  More lyrics here
 
 F                C             D
@@ -47,6 +48,25 @@ FILL: D G D A D
 BRIDGE
 ```
 
+### Metadata
+
+BPM and time signature can be specified in parentheses after the title line:
+
+```
+SONG TITLE - AUTHOR NAME
+(120 BPM)
+(3/4 time)
+(120 BPM, 3/4 time)
+```
+
+### Slash Chords
+
+Slash chords like `G/B`, `Am7/E`, `F#m/C#` are supported in both chord lines and expressions. The bass note is stored separately:
+
+```js
+{ root: 'G', type: '', bass: 'B' }
+```
+
 ### Section Type Inference
 
 1. 1st block with chords+lyrics → `verse`
@@ -76,12 +96,17 @@ Examples: `(VERSE, CHORUS*2)`, `(D G D A)*4`, `D G D A D`
 {
   title: 'SONG TITLE',
   author: 'AUTHOR NAME',
+  bpm: 120,                // number | null
+  timeSignature: {         // { beats, value } | null
+    beats: 3,
+    value: 4,
+  },
 
   // Unique section definitions
   sections: {
     verse: {
       count: 4,
-      chords: [{ root: 'G', type: '' }, { root: 'F', type: '' }, ...],
+      chords: [{ root: 'G', type: '' }, { root: 'F', type: '', bass: 'B' }, ...],
       lyrics: ['lyric line 1', ...],
       lines: [
         {
@@ -116,7 +141,7 @@ Examples: `(VERSE, CHORUS*2)`, `(D G D A)*4`, `D G D A D`
 
 ## Transposition
 
-`transpose()` deep-walks the AST and replaces every chord root. It auto-detects whether the song uses flats or sharps, or you can override with `{ preferFlats: true }`.
+`transpose()` deep-walks the AST and replaces every chord root (and bass note on slash chords). It auto-detects whether the song uses flats or sharps, or you can override with `{ preferFlats: true }`.
 
 ```js
 const song = parse(rawText)

package/index.d.ts

@@ -1,6 +1,12 @@
 export interface Chord {
   root: string
   type: string
+  bass?: string
+  nashville?: boolean
+  diamond?: boolean
+  push?: boolean
+  stop?: boolean
+  splitMeasure?: Chord[]
 }
 
 export interface PositionedChord extends Chord {
@@ -42,13 +48,22 @@ export interface StructureEntry {
   expression: Expression | null
 }
 
+export interface TimeSignature {
+  beats: number
+  value: number
+}
+
 export interface Song {
   title: string
   author: string
   bpm: number | null
+  timeSignature: TimeSignature | null
+  key: string | null
   sections: Record<string, Section>
   structure: StructureEntry[]
 }
 
 export function parse(raw: string): Song
 export function transpose(song: Song, semitones: number, options?: { preferFlats?: boolean }): Song
+export function toNashville(song: Song, key: string): Song
+export function toStandard(song: Song, key: string): Song

package/index.js

@@ -1,2 +1,3 @@
 export { parse } from './src/parser.js'
 export { transpose } from './src/transpose.js'
+export { toNashville, toStandard } from './src/notation.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "songsheet",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "A songsheet interpreter",
   "type": "module",
   "exports": "./index.js",

package/song-of-myself.txt

@@ -1,4 +1,5 @@
 SONG OF MYSELF - WILLIE AND WALT
+(3/4 time)
 
        G                           Am
 I have heard what the talkers were talking...

package/src/lexer.js

@@ -1,13 +1,67 @@
 const ROOTS = new Set(['A', 'B', 'C', 'D', 'E', 'F', 'G'])
+const NNS_ROOTS = new Set(['1', '2', '3', '4', '5', '6', '7'])
 const ACCIDENTALS = new Set(['#', 'b'])
-const QUALITY_CHARS = /[a-z0-9#+\/]/i
+const QUALITY_CHARS = /[a-z0-9#+]/i
+
+/**
+ * Try to parse a chord starting at position i in line.
+ * Accepts both letter roots (A-G) and NNS roots (1-7).
+ * Returns { token, end } or null.
+ */
+function parseChordAt(line, i, stopChars) {
+  const ch = line[i]
+  const isNNS = NNS_ROOTS.has(ch)
+  const isLetter = ROOTS.has(ch)
+  if (!isNNS && !isLetter) return null
+
+  let root = ch
+  let j = i + 1
+
+  // accidental (only for letter roots)
+  if (!isNNS && j < line.length && ACCIDENTALS.has(line[j])) {
+    root += line[j]
+    j++
+  }
+
+  // quality: consume word chars that are valid in chord names
+  let quality = ''
+  while (j < line.length && QUALITY_CHARS.test(line[j]) && line[j] !== ' ' && line[j] !== '|') {
+    if (stopChars && stopChars.has(line[j])) break
+    quality += line[j]
+    j++
+  }
+
+  // slash chord: /Bass
+  let bass = ''
+  if (j < line.length && line[j] === '/') {
+    j++ // consume /
+    if (j < line.length && (ROOTS.has(line[j]) || NNS_ROOTS.has(line[j]))) {
+      const bassIsNNS = NNS_ROOTS.has(line[j])
+      bass = line[j]
+      j++
+      if (!bassIsNNS && j < line.length && ACCIDENTALS.has(line[j])) {
+        bass += line[j]
+        j++
+      }
+    } else {
+      return null // / not followed by a valid note
+    }
+  }
+
+  const token = { type: 'CHORD', column: i, root, quality }
+  if (bass) token.bass = bass
+  if (isNNS) token.nashville = true
+  return { token, end: j }
+}
+
+const DECORATOR_STOP_CHARS = new Set(['>', ']', '!'])
 
 /**
  * Scan a line left-to-right and return an array of chord/bar-line tokens,
  * or null if the line is not a valid chord line.
  *
  * A chord line must contain at least one chord, and every non-whitespace
- * token must parse as a valid chord or `|`.
+ * token must parse as a valid chord, decorator, or `|`.
  */
 export function scanChordLine(line) {
   if (!line || line.trim().length === 0) return null
@@ -31,21 +85,91 @@ export function scanChordLine(line) {
       continue
     }
 
-    // try to parse a chord: root + optional accidental + optional quality
-    if (ROOTS.has(line[i])) {
-      let root = line[i]
-      i++
+    // diamond: <chord>
+    if (line[i] === '<') {
+      i++ // consume <
+      const result = parseChordAt(line, i, DECORATOR_STOP_CHARS)
+      if (!result) return null
+      if (result.end >= line.length || line[result.end] !== '>') return null
+      i = result.end + 1 // consume >
+      const token = { ...result.token, column, diamond: true }
+      // next char must be whitespace, end-of-line, |, or !
+      if (i < line.length && line[i] === '!') {
+        token.stop = true
+        i++
+      }
+      if (i < line.length && line[i] !== ' ' && line[i] !== '\t' && line[i] !== '|') {
+        return null
+      }
+      tokens.push(token)
+      continue
+    }
 
-      // accidental
-      if (i < line.length && ACCIDENTALS.has(line[i])) {
-        root += line[i]
+    // push: ^chord
+    if (line[i] === '^') {
+      i++ // consume ^
+      const result = parseChordAt(line, i, DECORATOR_STOP_CHARS)
+      if (!result) return null
+      i = result.end
+      const token = { ...result.token, column, push: true }
+      if (i < line.length && line[i] === '!') {
+        token.stop = true
         i++
       }
+      if (i < line.length && line[i] !== ' ' && line[i] !== '\t' && line[i] !== '|') {
+        return null
+      }
+      tokens.push(token)
+      continue
+    }
 
-      // quality: consume word chars that are valid in chord names
-      let quality = ''
-      while (i < line.length && QUALITY_CHARS.test(line[i]) && line[i] !== ' ' && line[i] !== '|') {
-        quality += line[i]
+    // split measure: [chord chord ...]
+    if (line[i] === '[') {
+      i++ // consume [
+      const chords = []
+      while (i < line.length && line[i] !== ']') {
+        if (line[i] === ' ' || line[i] === '\t') { i++; continue }
+        const result = parseChordAt(line, i, DECORATOR_STOP_CHARS)
+        if (!result) return null
+        chords.push(result.token)
+        i = result.end
+      }
+      if (i >= line.length || line[i] !== ']') return null
+      i++ // consume ]
+      if (chords.length < 2) return null
+      // next char must be whitespace, end-of-line, or |
+      if (i < line.length && line[i] !== ' ' && line[i] !== '\t' && line[i] !== '|') {
+        return null
+      }
+      // Use the first chord as the main token, attach all chords as splitMeasure
+      const first = chords[0]
+      const token = {
+        type: 'CHORD',
+        column,
+        root: first.root,
+        quality: first.quality,
+        splitMeasure: chords.map(c => {
+          const sc = { root: c.root, type: c.quality }
+          if (c.bass) sc.bass = c.bass
+          if (c.nashville) sc.nashville = true
+          return sc
+        }),
+      }
+      if (first.bass) token.bass = first.bass
+      if (first.nashville) token.nashville = true
+      tokens.push(token)
+      continue
+    }
+
+    // try to parse a chord: letter root or NNS root
+    if (ROOTS.has(line[i]) || NNS_ROOTS.has(line[i])) {
+      const result = parseChordAt(line, i, DECORATOR_STOP_CHARS)
+      if (!result) return null
+      i = result.end
+
+      // check for stop suffix
+      if (i < line.length && line[i] === '!') {
+        result.token.stop = true
         i++
       }
 
@@ -54,7 +178,7 @@ export function scanChordLine(line) {
         return null // not a chord line
       }
 
-      tokens.push({ type: 'CHORD', column, root, quality })
+      tokens.push(result.token)
       continue
     }
 
@@ -94,26 +218,58 @@ const ExprTokenTypes = {
 export function lexExpression(text) {
   const tokens = []
   let i = 0
+  let lastType = null
 
   while (i < text.length) {
     if (text[i] === ' ' || text[i] === '\t') { i++; continue }
-    if (text[i] === '(') { tokens.push({ type: ExprTokenTypes.LPAREN }); i++; continue }
-    if (text[i] === ')') { tokens.push({ type: ExprTokenTypes.RPAREN }); i++; continue }
-    if (text[i] === ',') { tokens.push({ type: ExprTokenTypes.COMMA }); i++; continue }
-    if (text[i] === '*') { tokens.push({ type: ExprTokenTypes.STAR }); i++; continue }
+    if (text[i] === '(') { tokens.push({ type: ExprTokenTypes.LPAREN }); lastType = ExprTokenTypes.LPAREN; i++; continue }
+    if (text[i] === ')') { tokens.push({ type: ExprTokenTypes.RPAREN }); lastType = ExprTokenTypes.RPAREN; i++; continue }
+    if (text[i] === ',') { tokens.push({ type: ExprTokenTypes.COMMA }); lastType = ExprTokenTypes.COMMA; i++; continue }
+    if (text[i] === '*') { tokens.push({ type: ExprTokenTypes.STAR }); lastType = ExprTokenTypes.STAR; i++; continue }
 
-    // number
+    // NNS chord: digit 1-7 when previous token is not STAR
+    if (NNS_ROOTS.has(text[i]) && lastType !== ExprTokenTypes.STAR) {
+      let root = text[i]
+      i++
+      // quality
+      let quality = ''
+      while (i < text.length && QUALITY_CHARS.test(text[i]) && text[i] !== ' ' && text[i] !== ')' && text[i] !== ',' && text[i] !== '*') {
+        quality += text[i]
+        i++
+      }
+      // slash bass
+      let bass = ''
+      if (i < text.length && text[i] === '/') {
+        i++
+        if (i < text.length && (ROOTS.has(text[i]) || NNS_ROOTS.has(text[i]))) {
+          bass = text[i]
+          i++
+          if (!NNS_ROOTS.has(bass) && i < text.length && ACCIDENTALS.has(text[i])) {
+            bass += text[i]
+            i++
+          }
+        }
+      }
+      const token = { type: ExprTokenTypes.CHORD, root, quality, nashville: true }
+      if (bass) token.bass = bass
+      tokens.push(token)
+      lastType = ExprTokenTypes.CHORD
+      continue
+    }
+
+    // number (including NNS digits when after STAR)
     if (/[0-9]/.test(text[i])) {
       let num = ''
       while (i < text.length && /[0-9]/.test(text[i])) { num += text[i]; i++ }
       tokens.push({ type: ExprTokenTypes.NUMBER, value: parseInt(num, 10) })
+      lastType = ExprTokenTypes.NUMBER
       continue
     }
 
     // word or chord: starts with a letter
     if (/[A-Za-z]/.test(text[i])) {
       let word = ''
-      while (i < text.length && /[A-Za-z0-9#b+\/]/.test(text[i])) { word += text[i]; i++ }
+      while (i < text.length && /[A-Za-z0-9#b+]/.test(text[i])) { word += text[i]; i++ }
 
       // Determine if this is a chord (starts with A-G, followed by optional accidental + quality)
       // or a section reference word (all caps like VERSE, CHORUS)
@@ -125,9 +281,26 @@ export function lexExpression(text) {
           root += rest[0]
           rest = rest.slice(1)
         }
-        tokens.push({ type: ExprTokenTypes.CHORD, root, quality: rest })
+        // Check for slash bass note
+        let bass = ''
+        if (i < text.length && text[i] === '/') {
+          i++ // consume /
+          if (i < text.length && ROOTS.has(text[i])) {
+            bass = text[i]
+            i++
+            if (i < text.length && ACCIDENTALS.has(text[i])) {
+              bass += text[i]
+              i++
+            }
+          }
+        }
+        const token = { type: ExprTokenTypes.CHORD, root, quality: rest }
+        if (bass) token.bass = bass
+        tokens.push(token)
+        lastType = ExprTokenTypes.CHORD
       } else {
         tokens.push({ type: ExprTokenTypes.WORD, value: word })
+        lastType = ExprTokenTypes.WORD
       }
       continue
     }

package/src/notation.js

@@ -0,0 +1,189 @@
+import { noteToSemitone, semitoneToNote } from './transpose.js'
+
+const MAJOR_SCALE = [0, 2, 4, 5, 7, 9, 11] // semitones for scale degrees 1-7
+const NNS_DIGITS = ['1', '2', '3', '4', '5', '6', '7']
+
+/**
+ * Convert a chord's root to a Nashville number relative to the given key.
+ * Returns { root, prefixAccidental } where root is '1'-'7' and prefixAccidental
+ * is '' (exact match), 'b' (flat of a scale degree), or '#' (sharp of a scale degree).
+ */
+function rootToNashville(root, keySemitone) {
+  const chordSemitone = noteToSemitone(root)
+  const interval = ((chordSemitone - keySemitone) + 12) % 12
+
+  // Exact scale degree match
+  const exactIdx = MAJOR_SCALE.indexOf(interval)
+  if (exactIdx !== -1) {
+    return { root: NNS_DIGITS[exactIdx], prefixAccidental: '' }
+  }
+
+  // Flat of the next scale degree
+  const sharpIdx = MAJOR_SCALE.indexOf((interval + 1) % 12)
+  if (sharpIdx !== -1) {
+    return { root: NNS_DIGITS[sharpIdx], prefixAccidental: 'b' }
+  }
+
+  // Sharp of the previous scale degree
+  const flatIdx = MAJOR_SCALE.indexOf((interval + 11) % 12)
+  if (flatIdx !== -1) {
+    return { root: NNS_DIGITS[flatIdx], prefixAccidental: '#' }
+  }
+
+  // Shouldn't reach here, but fallback
+  return { root: root, prefixAccidental: '' }
+}
+
+/**
+ * Convert a Nashville number root back to a letter note.
+ */
+function nashvilleToRoot(root, keySemitone, prefixAccidental, preferFlats) {
+  const digit = parseInt(root, 10)
+  if (digit < 1 || digit > 7) return root
+
+  let semitone = (MAJOR_SCALE[digit - 1] + keySemitone) % 12
+  if (prefixAccidental === 'b') semitone = (semitone + 11) % 12
+  else if (prefixAccidental === '#') semitone = (semitone + 1) % 12
+
+  return semitoneToNote(semitone, preferFlats)
+}
+
+function convertChord(chord, keySemitone, toNNS, preferFlats) {
+  if (!chord || !chord.root) return chord
+
+  if (toNNS) {
+    // Already nashville — leave as-is
+    if (chord.nashville) return chord
+
+    const { root: nnsRoot, prefixAccidental } = rootToNashville(chord.root, keySemitone)
+    const result = { ...chord, root: nnsRoot, nashville: true }
+    if (prefixAccidental) {
+      result.type = prefixAccidental + chord.type
+    }
+    // Convert bass note too
+    if (chord.bass) {
+      const { root: nnsBass, prefixAccidental: bassAcc } = rootToNashville(chord.bass, keySemitone)
+      result.bass = (bassAcc || '') + nnsBass
+    }
+    if (chord.splitMeasure) {
+      result.splitMeasure = chord.splitMeasure.map(c => convertChord(c, keySemitone, true, preferFlats))
+    }
+    return result
+  } else {
+    // To standard — only convert nashville chords
+    if (!chord.nashville) return chord
+
+    // Extract prefix accidental from type if present
+    let prefixAccidental = ''
+    let type = chord.type
+    if (type.startsWith('b') || type.startsWith('#')) {
+      prefixAccidental = type[0]
+      type = type.slice(1)
+    }
+
+    const newRoot = nashvilleToRoot(chord.root, keySemitone, prefixAccidental, preferFlats)
+    const result = { ...chord, root: newRoot, type }
+    delete result.nashville
+
+    if (chord.bass) {
+      // Bass could have prefix accidental too (e.g., 'b3')
+      let bassPre = ''
+      let bassDigit = chord.bass
+      if (bassDigit.startsWith('b') || bassDigit.startsWith('#')) {
+        bassPre = bassDigit[0]
+        bassDigit = bassDigit.slice(1)
+      }
+      const digit = parseInt(bassDigit, 10)
+      if (digit >= 1 && digit <= 7) {
+        result.bass = nashvilleToRoot(bassDigit, keySemitone, bassPre, preferFlats)
+      }
+    }
+
+    if (chord.splitMeasure) {
+      result.splitMeasure = chord.splitMeasure.map(c => convertChord(c, keySemitone, false, preferFlats))
+    }
+
+    return result
+  }
+}
+
+function convertLines(lines, keySemitone, toNNS, preferFlats) {
+  return lines.map(line => ({
+    ...line,
+    chords: line.chords.map(c => ({
+      ...convertChord(c, keySemitone, toNNS, preferFlats),
+      column: c.column,
+    })),
+    characters: line.characters.map(ch => {
+      if (ch.chord) {
+        return { ...ch, chord: convertChord(ch.chord, keySemitone, toNNS, preferFlats) }
+      }
+      return ch
+    }),
+  }))
+}
+
+function convertExpressionNode(node, keySemitone, toNNS, preferFlats) {
+  if (!node) return node
+  switch (node.type) {
+    case 'chord_list':
+      return { ...node, chords: node.chords.map(c => convertChord(c, keySemitone, toNNS, preferFlats)) }
+    case 'sequence':
+      return { ...node, items: node.items.map(item => convertExpressionNode(item, keySemitone, toNNS, preferFlats)) }
+    case 'repeat':
+      return { ...node, body: convertExpressionNode(node.body, keySemitone, toNNS, preferFlats) }
+    default:
+      return node
+  }
+}
+
+function detectPreferFlats(song) {
+  for (const key in song.sections) {
+    for (const chord of song.sections[key].chords) {
+      if (chord.root && chord.root.length === 2 && chord.root[1] === 'b') return true
+    }
+  }
+  return false
+}
+
+function convertSong(song, key, toNNS) {
+  const keySemitone = noteToSemitone(key)
+  const preferFlats = detectPreferFlats(song)
+
+  const newSections = {}
+  for (const sKey in song.sections) {
+    const section = song.sections[sKey]
+    newSections[sKey] = {
+      ...section,
+      chords: section.chords.map(c => convertChord(c, keySemitone, toNNS, preferFlats)),
+      lines: convertLines(section.lines, keySemitone, toNNS, preferFlats),
+    }
+  }
+
+  const newStructure = song.structure.map(entry => ({
+    ...entry,
+    chords: entry.chords.map(c => convertChord(c, keySemitone, toNNS, preferFlats)),
+    lines: convertLines(entry.lines, keySemitone, toNNS, preferFlats),
+    expression: convertExpressionNode(entry.expression, keySemitone, toNNS, preferFlats),
+  }))
+
+  return {
+    ...song,
+    sections: newSections,
+    structure: newStructure,
+  }
+}
+
+/**
+ * Convert a song with letter-root chords to Nashville Number System notation.
+ */
+export function toNashville(song, key) {
+  return convertSong(song, key, true)
+}
+
+/**
+ * Convert a song with Nashville Number System chords back to standard letter roots.
+ */
+export function toStandard(song, key) {
+  return convertSong(song, key, false)
+}