chordsheetjs 4.7.1 → 4.10.0

package/README.md

@@ -1,4 +1,4 @@
-# ChordSheetJS [![Build Status](https://travis-ci.org/martijnversluis/ChordSheetJS.svg?branch=master)](https://travis-ci.org/martijnversluis/ChordSheetJS) [![npm version](https://badge.fury.io/js/chordsheetjs.svg)](https://badge.fury.io/js/chordsheetjs) [![Code Climate](https://codeclimate.com/github/martijnversluis/ChordSheetJS/badges/gpa.svg)](https://codeclimate.com/github/martijnversluis/ChordSheetJS)
+# ChordSheetJS ![example branch parameter](https://github.com/martijnversluis/ChordSheetJS/actions/workflows/ci.yml/badge.svg?branch=master) [![npm version](https://badge.fury.io/js/chordsheetjs.svg)](https://badge.fury.io/js/chordsheetjs) [![Code Climate](https://codeclimate.com/github/martijnversluis/ChordSheetJS/badges/gpa.svg)](https://codeclimate.com/github/martijnversluis/ChordSheetJS)
 
 A JavaScript library for parsing and formatting chord sheets
 
@@ -138,6 +138,113 @@ HtmlTableFormatter.cssObject();
 // }
 ```
 
+### Parsing and modifying chords
+
+```javascript
+import { parseChord } from 'chordsheetjs';
+```
+
+#### Parse
+
+```javascript
+const chord = parseChord('Ebsus4/Bb');
+```
+
+Parse numeric chords (Nashville system):
+
+```javascript
+const chord = parseChord('b1sus4/#3');
+```
+
+#### Display with #toString
+
+Use #toString() to convert the chord to a chord string (eg Dsus/F#)
+
+```javascript
+const chord = parseChord('Ebsus4/Bb');
+chord.toString(); // --> "Ebsus4/Bb"
+```
+
+#### Clone
+
+```javascript
+var chord2 = chord.clone();
+```
+
+#### Normalize
+
+Normalizes keys B#, E#, Cb and Fb to C, F, B and E
+
+```javascript
+const chord = parseChord('E#/B#'),
+normalizedChord = chord.normalize();
+normalizedChord.toString(); // --> "F/C"
+```
+
+#### Switch modifier
+
+Convert # to b and vice versa
+
+```javascript
+const chord = parseChord('Eb/Bb');
+const chord2 = chord.switchModifier();
+chord2.toString(); // --> "D#/A#"
+```
+
+#### Use specific modifier
+
+Set the chord to a specific modifier (# or b)
+
+```javascript
+const chord = parseChord('Eb/Bb');
+const chord2 = chord.useModifier('#');
+chord2.toString(); // --> "D#/A#"
+```
+
+```javascript
+const chord = parseChord('Eb/Bb');
+const chord2 = chord.useModifier('b');
+chord2.toString(); // --> "Eb/Bb"
+```
+
+#### Transpose up
+
+```javascript
+const chord = parseChord('Eb/Bb');
+const chord2 = chord.transposeUp();
+chord2.toString(); // -> "E/B"
+```
+
+#### Transpose down
+
+```javascript
+const chord = parseChord('Eb/Bb');
+const chord2 = chord.transposeDown();
+chord2.toString(); // -> "D/A"
+```
+
+#### Transpose
+
+```javascript
+const chord = parseChord('C/E');
+const chord2 = chord.transpose(4);
+chord2.toString(); // -> "E/G#"
+```
+
+```javascript
+const chord = parseChord('C/E');
+const chord2 = chord.transpose(-4);
+chord2.toString(); // -> "Ab/C"
+```
+
+#### Convert numeric chord to chord symbol
+
+```javascript
+const numericChord = parseChord('2/4');
+const chordSymbol = toChordSymbol(numericChord, 'E');
+chordSymbol.toString(); // -> "F#m/A"
+```
+
 ## Supported ChordPro directives
 
 :heavy_check_mark: = supported
@@ -288,9 +395,18 @@ PDF conversion.</p>
 <dd><p>Parses an Ultimate Guitar chord sheet with metadata
 Inherits from <a href="#ChordSheetParser">ChordSheetParser</a></p>
 </dd>
+<dt><a href="#Chord">Chord</a></dt>
+<dd><p>Base class for <a href="#ChordSymbol">ChordSymbol</a> and <a href="#NumericChord">NumericChord</a></p>
+</dd>
 <dt><a href="#ChordSheetSerializer">ChordSheetSerializer</a></dt>
 <dd><p>Serializes a song into een plain object, and deserializes the serialized object back into a <a href="#Song">Song</a></p>
 </dd>
+<dt><a href="#ChordSymbol">ChordSymbol</a></dt>
+<dd><p>Represents a chord symbol, such as Esus4</p>
+</dd>
+<dt><a href="#NumericChord">NumericChord</a></dt>
+<dd><p>Represents a numeric chord, such as b3sus4</p>
+</dd>
 </dl>
 
 ## Constants
@@ -326,6 +442,9 @@ Inherits from <a href="#ChordSheetParser">ChordSheetParser</a></p>
 <dt><a href="#KEY">KEY</a> : <code>string</code></dt>
 <dd><p>Key meta directive. See <a href="https://www.chordpro.org/chordpro/directives-key/">https://www.chordpro.org/chordpro/directives-key/</a></p>
 </dd>
+<dt><a href="#_KEY">_KEY</a> : <code>string</code></dt>
+<dd><p>Key meta directive. See <a href="https://www.chordpro.org/chordpro/directives-key/">https://www.chordpro.org/chordpro/directives-key/</a></p>
+</dd>
 <dt><a href="#LYRICIST">LYRICIST</a> : <code>string</code></dt>
 <dd><p>Lyricist meta directive. See <a href="https://www.chordpro.org/chordpro/directives-lyricist/">https://www.chordpro.org/chordpro/directives-lyricist/</a></p>
 </dd>
@@ -372,7 +491,13 @@ For a CSS string see <a href="#scopedCss">scopedCss</a></p>
 
 <dl>
 <dt><a href="#scopedCss">scopedCss(scope)</a> ⇒ <code>string</code></dt>
-<dd><p>Generates basic CSS, scoped within the provided selector, to use with output generated by {@link }HtmlTableFormatter}</p>
+<dd><p>Generates basic CSS, scoped within the provided selector, to use with output generated by <a href="#HtmlTableFormatter">HtmlTableFormatter</a></p>
+</dd>
+<dt><a href="#parseChord">parseChord(chordString)</a> ⇒ <code>null</code> | <code><a href="#ChordSymbol">ChordSymbol</a></code> | <code><a href="#NumericChord">NumericChord</a></code></dt>
+<dd><p>Tries to parse a chord string into a chord</p>
+</dd>
+<dt><a href="#toChordSymbol">toChordSymbol(numericChord, key)</a> ⇒ <code><a href="#ChordSymbol">ChordSymbol</a></code></dt>
+<dd><p>Converts a numeric chord into a chord symbol, using the provided key</p>
 </dd>
 </dl>
 
@@ -1037,6 +1162,18 @@ Parses an Ultimate Guitar chord sheet with metadata
 Inherits from [ChordSheetParser](#ChordSheetParser)
 
 **Kind**: global class  
+<a name="Chord"></a>
+
+## Chord
+Base class for [ChordSymbol](#ChordSymbol) and [NumericChord](#NumericChord)
+
+**Kind**: global class  
+<a name="Chord+clone"></a>
+
+### chord.clone() ⇒ [<code>Chord</code>](#Chord)
+Returns a deep copy of the chord
+
+**Kind**: instance method of [<code>Chord</code>](#Chord)  
 <a name="ChordSheetSerializer"></a>
 
 ## ChordSheetSerializer
@@ -1068,6 +1205,147 @@ Deserializes a song that has been serialized using [serialize](serialize)
 | --- | --- | --- |
 | serializedSong | <code>object</code> | The serialized song |
 
+<a name="ChordSymbol"></a>
+
+## ChordSymbol
+Represents a chord symbol, such as Esus4
+
+**Kind**: global class  
+
+* [ChordSymbol](#ChordSymbol)
+    * [.normalize()](#ChordSymbol+normalize) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.switchModifier()](#ChordSymbol+switchModifier) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.useModifier(newModifier)](#ChordSymbol+useModifier) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.transposeUp()](#ChordSymbol+transposeUp) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.transposeDown()](#ChordSymbol+transposeDown) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.transpose(delta)](#ChordSymbol+transpose) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+    * [.toString()](#ChordSymbol+toString) ⇒ <code>string</code> \| <code>\*</code>
+
+<a name="ChordSymbol+normalize"></a>
+
+### chordSymbol.normalize() ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Normalizes the chord:
+- Fb becomes E
+- Cb becomes B
+- B# becomes C
+- E# becomes F
+If the chord is already normalized, this will return a copy.
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the normalized chord  
+<a name="ChordSymbol+switchModifier"></a>
+
+### chordSymbol.switchModifier() ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Switches between '#' and 'b' as modifiers. If
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the changed chord  
+<a name="ChordSymbol+useModifier"></a>
+
+### chordSymbol.useModifier(newModifier) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Switches to the specified modifier
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the changed chord  
+
+| Param | Description |
+| --- | --- |
+| newModifier | the modifier to use: `'#'` or `'b'` |
+
+<a name="ChordSymbol+transposeUp"></a>
+
+### chordSymbol.transposeUp() ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Transposes the chord up by 1 semitone. Eg. A becomes A#, Eb becomes E
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the transposed chord  
+<a name="ChordSymbol+transposeDown"></a>
+
+### chordSymbol.transposeDown() ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Transposes the chord down by 1 semitone. Eg. A# becomes A, E becomes Eb
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the transposed chord  
+<a name="ChordSymbol+transpose"></a>
+
+### chordSymbol.transpose(delta) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Transposes the chord by the specified number of semitones
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the transposed chord  
+
+| Param | Description |
+| --- | --- |
+| delta | de number of semitones |
+
+<a name="ChordSymbol+toString"></a>
+
+### chordSymbol.toString() ⇒ <code>string</code> \| <code>\*</code>
+Convert the chord to a string, eg. `'Esus4/G#'`
+
+**Kind**: instance method of [<code>ChordSymbol</code>](#ChordSymbol)  
+<a name="NumericChord"></a>
+
+## NumericChord
+Represents a numeric chord, such as b3sus4
+
+**Kind**: global class  
+
+* [NumericChord](#NumericChord)
+    * [.normalize()](#NumericChord+normalize) ⇒ [<code>NumericChord</code>](#NumericChord)
+    * [.switchModifier()](#NumericChord+switchModifier) ⇒ [<code>NumericChord</code>](#NumericChord)
+    * [.useModifier()](#NumericChord+useModifier) ⇒ [<code>NumericChord</code>](#NumericChord)
+    * [.transposeUp()](#NumericChord+transposeUp) ⇒ [<code>NumericChord</code>](#NumericChord)
+    * [.transposeDown()](#NumericChord+transposeDown) ⇒ [<code>NumericChord</code>](#NumericChord)
+    * [.transpose(delta)](#NumericChord+transpose) ⇒ [<code>NumericChord</code>](#NumericChord)
+
+<a name="NumericChord+normalize"></a>
+
+### numericChord.normalize() ⇒ [<code>NumericChord</code>](#NumericChord)
+Normalizes the chord - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+<a name="NumericChord+switchModifier"></a>
+
+### numericChord.switchModifier() ⇒ [<code>NumericChord</code>](#NumericChord)
+Switches between '#' and 'b' as modifiers - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+<a name="NumericChord+useModifier"></a>
+
+### numericChord.useModifier() ⇒ [<code>NumericChord</code>](#NumericChord)
+Switches to the specified modifier - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+<a name="NumericChord+transposeUp"></a>
+
+### numericChord.transposeUp() ⇒ [<code>NumericChord</code>](#NumericChord)
+Transposes the chord up by 1 semitone - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+<a name="NumericChord+transposeDown"></a>
+
+### numericChord.transposeDown() ⇒ [<code>NumericChord</code>](#NumericChord)
+Transposes the chord down by 1 semitone - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+<a name="NumericChord+transpose"></a>
+
+### numericChord.transpose(delta) ⇒ [<code>NumericChord</code>](#NumericChord)
+Transposes the chord by the specified number of semitones - this is a noop for numeric chords.
+
+**Kind**: instance method of [<code>NumericChord</code>](#NumericChord)  
+**Returns**: [<code>NumericChord</code>](#NumericChord) - a copy of the chord object  
+
+| Param | Description |
+| --- | --- |
+| delta | de number of semitones |
+
 <a name="ALBUM"></a>
 
 ## ALBUM : <code>string</code>
@@ -1127,6 +1405,12 @@ End of verse directive. See https://www.chordpro.org/chordpro/directives-env_ver
 ## KEY : <code>string</code>
 Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
 
+**Kind**: global constant  
+<a name="_KEY"></a>
+
+## \_KEY : <code>string</code>
+Key meta directive. See https://www.chordpro.org/chordpro/directives-key/
+
 **Kind**: global constant  
 <a name="LYRICIST"></a>
 
@@ -1210,7 +1494,7 @@ Used to mark a paragraph as containing lines with both verse and chorus type
 <a name="scopedCss"></a>
 
 ## scopedCss(scope) ⇒ <code>string</code>
-Generates basic CSS, scoped within the provided selector, to use with output generated by {@link }HtmlTableFormatter}
+Generates basic CSS, scoped within the provided selector, to use with output generated by [HtmlTableFormatter](#HtmlTableFormatter)
 
 **Kind**: global function  
 **Returns**: <code>string</code> - the CSS string  
@@ -1219,3 +1503,27 @@ Generates basic CSS, scoped within the provided selector, to use with output gen
 | --- | --- |
 | scope | the CSS scope to use, for example `.chordSheetViewer` |
 
+<a name="parseChord"></a>
+
+## parseChord(chordString) ⇒ <code>null</code> \| [<code>ChordSymbol</code>](#ChordSymbol) \| [<code>NumericChord</code>](#NumericChord)
+Tries to parse a chord string into a chord
+
+**Kind**: global function  
+
+| Param | Description |
+| --- | --- |
+| chordString | the chord string, eg Esus4/G# or 1sus4/#3 |
+
+<a name="toChordSymbol"></a>
+
+## toChordSymbol(numericChord, key) ⇒ [<code>ChordSymbol</code>](#ChordSymbol)
+Converts a numeric chord into a chord symbol, using the provided key
+
+**Kind**: global function  
+**Returns**: [<code>ChordSymbol</code>](#ChordSymbol) - the resulting chord symbol  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| numericChord | [<code>NumericChord</code>](#NumericChord) |  |
+| key | <code>string</code> | the to use, sp anything between Ab and G# |
+

package/lib/chord.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/**
+ * Base class for {@link ChordSymbol} and {@link NumericChord}
+ */
+var Chord = /*#__PURE__*/function () {
+  function Chord(_ref) {
+    var base = _ref.base,
+        modifier = _ref.modifier,
+        suffix = _ref.suffix,
+        bassBase = _ref.bassBase,
+        bassModifier = _ref.bassModifier;
+
+    _classCallCheck(this, Chord);
+
+    this.base = base || null;
+    this.modifier = modifier || null;
+    this.suffix = suffix || null;
+    this.bassBase = bassBase || null;
+    this.bassModifier = bassModifier || null;
+  }
+  /**
+   * Returns a deep copy of the chord
+   * @returns {Chord}
+   */
+
+
+  _createClass(Chord, [{
+    key: "clone",
+    value: function clone() {
+      var base = this.base,
+          modifier = this.modifier,
+          suffix = this.suffix,
+          bassBase = this.bassBase,
+          bassModifier = this.bassModifier;
+      return new this.constructor({
+        base: base,
+        modifier: modifier,
+        suffix: suffix,
+        bassBase: bassBase,
+        bassModifier: bassModifier
+      });
+    }
+  }, {
+    key: "set",
+    value: function set(properties) {
+      return new this.constructor(_objectSpread({
+        base: this.base,
+        modifier: this.modifier,
+        suffix: this.suffix,
+        bassBase: this.bassBase,
+        bassModifier: this.bassModifier
+      }, properties));
+    }
+  }]);
+
+  return Chord;
+}();
+
+var _default = Chord;
+exports["default"] = _default;

package/lib/chord_helpers.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deprecate = deprecate;
+exports.internalSwitchModifier = internalSwitchModifier;
+exports.isEmptyString = isEmptyString;
+exports.keyDown = keyDown;
+exports.keyUp = keyUp;
+exports.normalize = normalize;
+exports.processChord = processChord;
+exports.switchModifier = switchModifier;
+exports.transpose = transpose;
+exports.transposeDown = transposeDown;
+exports.transposeUp = transposeUp;
+exports.useModifier = useModifier;
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var A = 'A'.charCodeAt(0);
+var G = 'G'.charCodeAt(0);
+
+function keyChange(key, delta) {
+  var charCode;
+  charCode = key.toUpperCase().charCodeAt(0);
+  charCode += delta;
+
+  if (charCode > G) {
+    charCode = A;
+  }
+
+  if (charCode < A) {
+    charCode = G;
+  }
+
+  return String.fromCharCode(charCode);
+}
+
+function keyUp(key) {
+  return keyChange(key, 1);
+}
+
+function keyDown(key) {
+  return keyChange(key, -1);
+}
+
+function normalize(base, modifier) {
+  if (modifier === '#' && /^(B|E)$/.test(base)) {
+    return [keyUp(base), null];
+  }
+
+  if (modifier === 'b' && /^(C|F)$/.test(base)) {
+    return [keyDown(base), null];
+  }
+
+  return [base, modifier];
+}
+
+function internalSwitchModifier(base, modifier) {
+  if (modifier === '#') {
+    return [keyUp(base), 'b'];
+  }
+
+  if (modifier === 'b') {
+    return [keyDown(base), '#'];
+  }
+
+  throw new Error("Unexpected modifier ".concat(modifier));
+}
+
+function switchModifier(base, modifier) {
+  var _normalize = normalize(base, modifier),
+      _normalize2 = _slicedToArray(_normalize, 2),
+      normalizedBase = _normalize2[0],
+      normalizedModifier = _normalize2[1];
+
+  if (modifier) {
+    return internalSwitchModifier(normalizedBase, normalizedModifier);
+  }
+
+  return [normalizedBase, normalizedModifier];
+}
+
+function useModifier(base, modifier, newModifier) {
+  if (modifier && modifier !== newModifier) {
+    return internalSwitchModifier(base, modifier);
+  }
+
+  return [base, modifier];
+}
+
+function repeatProcessor(base, modifier, processor, amount) {
+  var processedBase = base,
+      processedModifier = modifier;
+
+  for (var i = 0; i < amount; i += 1) {
+    var _processor = processor(processedBase, processedModifier);
+
+    var _processor2 = _slicedToArray(_processor, 2);
+
+    processedBase = _processor2[0];
+    processedModifier = _processor2[1];
+  }
+
+  return [processedBase, processedModifier];
+}
+
+function transposeUp(base, modifier) {
+  var _normalize3 = normalize(base, modifier),
+      _normalize4 = _slicedToArray(_normalize3, 2),
+      normalizedBase = _normalize4[0],
+      normalizedModifier = _normalize4[1];
+
+  if (normalizedModifier === 'b') {
+    return [normalizedBase, null];
+  }
+
+  if (normalizedModifier === '#') {
+    return [keyUp(normalizedBase), null];
+  }
+
+  if (/^(B|E)$/.test(normalizedBase)) {
+    return [keyUp(normalizedBase), null];
+  }
+
+  return [normalizedBase, '#'];
+}
+
+function transposeDown(base, modifier) {
+  var _normalize5 = normalize(base, modifier),
+      _normalize6 = _slicedToArray(_normalize5, 2),
+      normalizedBase = _normalize6[0],
+      normalizedModifier = _normalize6[1];
+
+  if (normalizedModifier === 'b') {
+    return [keyDown(normalizedBase), null];
+  }
+
+  if (normalizedModifier === '#') {
+    return [normalizedBase, null];
+  }
+
+  if (/^(C|F)$/.test(normalizedBase)) {
+    return [keyDown(normalizedBase), null];
+  }
+
+  return [normalizedBase, 'b'];
+}
+
+function transpose(base, modifier, delta) {
+  var newBase = base,
+      newModifier = modifier;
+
+  if (delta < 0) {
+    var _repeatProcessor = repeatProcessor(base, modifier, transposeDown, Math.abs(delta));
+
+    var _repeatProcessor2 = _slicedToArray(_repeatProcessor, 2);
+
+    newBase = _repeatProcessor2[0];
+    newModifier = _repeatProcessor2[1];
+  } else if (delta > 0) {
+    var _repeatProcessor3 = repeatProcessor(base, modifier, transposeUp, delta);
+
+    var _repeatProcessor4 = _slicedToArray(_repeatProcessor3, 2);
+
+    newBase = _repeatProcessor4[0];
+    newModifier = _repeatProcessor4[1];
+  }
+
+  return useModifier(newBase, newModifier, modifier);
+}
+
+function processChord(sourceChord, processor, processorArg) {
+  var chord = sourceChord.clone();
+
+  var _processor3 = processor(sourceChord.base, sourceChord.modifier, processorArg);
+
+  var _processor4 = _slicedToArray(_processor3, 2);
+
+  chord.base = _processor4[0];
+  chord.modifier = _processor4[1];
+
+  if (sourceChord.bassBase) {
+    var _processor5 = processor(sourceChord.bassBase, sourceChord.bassModifier, processorArg);
+
+    var _processor6 = _slicedToArray(_processor5, 2);
+
+    chord.bassBase = _processor6[0];
+    chord.bassModifier = _processor6[1];
+  }
+
+  return chord;
+}
+
+function deprecate(message) {
+  try {
+    throw new Error("DEPRECATION: ".concat(message));
+  } catch (e) {
+    if ((typeof process === "undefined" ? "undefined" : _typeof(process)) === 'object' && typeof process.emitWarning === 'function') {
+      process.emitWarning("".concat(message, "\n").concat(e.stack));
+    } else {
+      console.warn("".concat(message, "\n").concat(e.stack));
+    }
+  }
+}
+
+function isEmptyString(string) {
+  return string === null || string === undefined || string === '';
+}

package/lib/chord_sheet/chord_pro/evaluation_error.js

@@ -13,7 +13,7 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }