chordsheetjs 5.3.0 → 6.1.0

package/.husky/pre-commit

@@ -0,0 +1,5 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn readme
+git add README.md

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)
+# ChordChartJS [![Code Climate](https://codeclimate.com/github/PraiseCharts/ChordChartJS/badges/gpa.svg)](https://codeclimate.com/github/PraiseCharts/ChordChartJS)
 
 A JavaScript library for parsing and formatting chord sheets
 
@@ -466,6 +466,12 @@ Inherits from <a href="#ChordSheetParser">ChordSheetParser</a></p>
 <dt><a href="#TITLE">TITLE</a> : <code>string</code></dt>
 <dd><p>Title meta directive. See <a href="https://www.chordpro.org/chordpro/directives-title/">https://www.chordpro.org/chordpro/directives-title/</a></p>
 </dd>
+<dt><a href="#TRANSPOSE">TRANSPOSE</a> : <code>string</code></dt>
+<dd><p>Transpose meta directive. See: <a href="https://www.chordpro.org/chordpro/directives-transpose/">https://www.chordpro.org/chordpro/directives-transpose/</a></p>
+</dd>
+<dt><a href="#NEW_KEY">NEW_KEY</a> : <code>string</code></dt>
+<dd><p>New Key meta directive. See: <a href="https://github.com/PraiseCharts/ChordChartJS/issues/53">https://github.com/PraiseCharts/ChordChartJS/issues/53</a></p>
+</dd>
 <dt><a href="#YEAR">YEAR</a> : <code>string</code></dt>
 <dd><p>Year meta directive. See <a href="https://www.chordpro.org/chordpro/directives-year/">https://www.chordpro.org/chordpro/directives-year/</a></p>
 </dd>
@@ -753,6 +759,8 @@ Represents a song in a chord sheet. Currently a chord sheet can only have one so
     * [.bodyParagraphs](#Song+bodyParagraphs) ⇒ [<code>Array.&lt;Paragraph&gt;</code>](#Paragraph)
     * ~~[.metaData](#Song+metaData) ⇒~~
     * [.clone()](#Song+clone) ⇒ [<code>Song</code>](#Song)
+    * [.setCapo(capo)](#Song+setCapo) ⇒ [<code>Song</code>](#Song)
+    * [.setKey(key)](#Song+setKey) ⇒ [<code>Song</code>](#Song)
 
 <a name="new_Song_new"></a>
 
@@ -815,6 +823,35 @@ Returns a deep clone of the song
 
 **Kind**: instance method of [<code>Song</code>](#Song)  
 **Returns**: [<code>Song</code>](#Song) - The cloned song  
+<a name="Song+setCapo"></a>
+
+### song.setCapo(capo) ⇒ [<code>Song</code>](#Song)
+Returns a copy of the song with the capo value set to the specified capo. It changes:
+- the value for `capo` in the `metadata` set
+- any existing `capo` directive)
+
+**Kind**: instance method of [<code>Song</code>](#Song)  
+**Returns**: [<code>Song</code>](#Song) - The changed song  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| capo | <code>number</code> \| <code>null</code> | the capo. Passing `null` will: - remove the current key from `metadata` - remove any `capo` directive |
+
+<a name="Song+setKey"></a>
+
+### song.setKey(key) ⇒ [<code>Song</code>](#Song)
+Returns a copy of the song with the key set to the specified key. It changes:
+- the value for `key` in the `metadata` 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 [<code>Song</code>](#Song)  
+**Returns**: [<code>Song</code>](#Song) - The changed song  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>string</code> | The new key. |
+
 <a name="Tag"></a>
 
 ## Tag
@@ -1176,8 +1213,11 @@ Represents a Chord, consisting of a root, suffix (quality) and bass
         * [.toChordSymbolString(key)](#Chord+toChordSymbolString) ⇒ <code>string</code>
         * [.isChordSymbol()](#Chord+isChordSymbol) ⇒ <code>boolean</code>
         * [.toNumeric(key)](#Chord+toNumeric) ⇒ [<code>Chord</code>](#Chord)
+        * [.toNumeral(key)](#Chord+toNumeral) ⇒ [<code>Chord</code>](#Chord)
+        * [.toNumeralString(key)](#Chord+toNumeralString) ⇒ <code>string</code>
         * [.isNumeric()](#Chord+isNumeric) ⇒ <code>boolean</code>
         * [.toNumericString(key)](#Chord+toNumericString) ⇒ <code>string</code>
+        * [.isNumeral()](#Chord+isNumeral) ⇒ <code>boolean</code>
         * [.toString()](#Chord+toString) ⇒ <code>string</code>
         * [.normalize()](#Chord+normalize) ⇒ [<code>Chord</code>](#Chord)
         * [.useModifier(newModifier)](#Chord+useModifier) ⇒ [<code>Chord</code>](#Chord)
@@ -1231,7 +1271,7 @@ Determines whether the chord is a chord symbol
 <a name="Chord+toNumeric"></a>
 
 ### chord.toNumeric(key) ⇒ [<code>Chord</code>](#Chord)
-Converts the chord to a numeric chord, using the supplied kye as a reference.
+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 [<code>Chord</code>](#Chord)  
@@ -1241,6 +1281,33 @@ For example, a chord symbol A# with reference key E will return the numeric chor
 | --- | --- | --- |
 | key | <code>Key</code> \| <code>string</code> | the reference key |
 
+<a name="Chord+toNumeral"></a>
+
+### chord.toNumeral(key) ⇒ [<code>Chord</code>](#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 [<code>Chord</code>](#Chord)  
+**Returns**: [<code>Chord</code>](#Chord) - the numeral chord  
+
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| key | <code>Key</code> \| <code>string</code> \| <code>null</code> | <code></code> | the reference key. The key is required when converting a chord symbol |
+
+<a name="Chord+toNumeralString"></a>
+
+### chord.toNumeralString(key) ⇒ <code>string</code>
+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 [<code>Chord</code>](#Chord)  
+**Returns**: <code>string</code> - the numeral chord string  
+**See**: {toNumeral}  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| key | <code>Key</code> \| <code>string</code> | the reference key |
+
 <a name="Chord+isNumeric"></a>
 
 ### chord.isNumeric() ⇒ <code>boolean</code>
@@ -1261,6 +1328,12 @@ For example, a chord symbol A# with reference key E will return the numeric chor
 | --- | --- | --- |
 | key | <code>Key</code> \| <code>string</code> | the reference key |
 
+<a name="Chord+isNumeral"></a>
+
+### chord.isNumeral() ⇒ <code>boolean</code>
+Determines whether the chord is a numeral
+
+**Kind**: instance method of [<code>Chord</code>](#Chord)  
 <a name="Chord+toString"></a>
 
 ### chord.toString() ⇒ <code>string</code>
@@ -1271,7 +1344,7 @@ Converts the chord to a string, eg `Esus4/G#` or `1sus4/#3`
 <a name="Chord+normalize"></a>
 
 ### chord.normalize() ⇒ [<code>Chord</code>](#Chord)
-Normalizes the chord:
+Normalizes the chord root and bass notes:
 - Fb becomes E
 - Cb becomes B
 - B# becomes C
@@ -1281,7 +1354,8 @@ Normalizes the chord:
 - 7# becomes 1
 - 3# becomes 4
 
-If the chord is already normalized, this will return a copy.
+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 [<code>Chord</code>](#Chord)  
 **Returns**: [<code>Chord</code>](#Chord) - the normalized chord  
@@ -1484,6 +1558,18 @@ Time meta directive. See https://www.chordpro.org/chordpro/directives-time/
 ## TITLE : <code>string</code>
 Title meta directive. See https://www.chordpro.org/chordpro/directives-title/
 
+**Kind**: global constant  
+<a name="TRANSPOSE"></a>
+
+## TRANSPOSE : <code>string</code>
+Transpose meta directive. See: https://www.chordpro.org/chordpro/directives-transpose/
+
+**Kind**: global constant  
+<a name="NEW_KEY"></a>
+
+## NEW\_KEY : <code>string</code>
+New Key meta directive. See: https://github.com/PraiseCharts/ChordChartJS/issues/53
+
 **Kind**: global constant  
 <a name="YEAR"></a>
 

package/lib/chord.js

@@ -12,6 +12,8 @@ var _utilities = require("./utilities");
 
 var _key = _interopRequireDefault(require("./key"));
 
+var _suffixNormalizeMapping = _interopRequireDefault(require("./normalize_mappings/suffix-normalize-mapping"));
+
 var _constants = require("./constants");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
@@ -36,12 +38,6 @@ function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollect
 
 function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
 
-function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
-
-function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
-
-function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
-
 function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
@@ -60,23 +56,12 @@ function _inherits(subClass, superClass) { if (typeof superClass !== "function"
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-var MAJOR_SCALE = [null, 'M', 'm', 'm', 'M', 'M', 'm', 'dim'];
-
 function normalizeSuffix(suffix) {
-  if (suffix === 'M') {
-    return '';
+  if (_suffixNormalizeMapping["default"][suffix] === '[blank]') {
+    return null;
   }
 
-  return suffix;
-}
-
-function chordSuffix(noteNumber, suffix) {
-  if ((0, _utilities.isEmptyString)(suffix)) {
-    var defaultSuffix = MAJOR_SCALE[noteNumber];
-    return normalizeSuffix(defaultSuffix);
-  }
-
-  return normalizeSuffix(suffix);
+  return _suffixNormalizeMapping["default"][suffix] || suffix;
 }
 
 var chordRegex = /*#__PURE__*/_wrapRegExp(/^([A-G])(#|b)?((?:(?![\t-\r \/\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF])[\s\S])*)(\/([A-G])(#|b)?)?$/i, {
@@ -143,15 +128,24 @@ var Chord = /*#__PURE__*/function () {
       set: void 0
     });
 
+    this.suffix = (0, _utilities.presence)(suffix);
     this.root = root || new _key["default"]({
       note: base,
-      modifier: modifier
+      modifier: modifier,
+      minor: suffix === 'm'
     });
-    this.suffix = (0, _utilities.presence)(suffix);
-    this.bass = bass || (bassBase ? new _key["default"]({
-      note: bassBase,
-      modifier: bassModifier
-    }) : null);
+
+    if (bass) {
+      this.bass = bass;
+    } else if (bassBase) {
+      this.bass = new _key["default"]({
+        note: bassBase,
+        modifier: bassModifier,
+        minor: suffix === 'm'
+      });
+    } else {
+      this.bass = null;
+    }
   }
 
   _createClass(Chord, [{
@@ -183,10 +177,11 @@ var Chord = /*#__PURE__*/function () {
 
       var keyObj = _key["default"].wrap(key);
 
+      var rootKey = this.root.toChordSymbol(keyObj).normalizeEnharmonics(keyObj);
       var chordSymbolChord = new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
-        root: this.root.toChordSymbol(keyObj),
-        bass: (_this$bass = this.bass) === null || _this$bass === void 0 ? void 0 : _this$bass.toChordSymbol(keyObj)
+        suffix: normalizeSuffix(this.suffix),
+        root: rootKey,
+        bass: (_this$bass = this.bass) === null || _this$bass === void 0 ? void 0 : _this$bass.toChordSymbol(keyObj).normalizeEnharmonics(rootKey)
       });
 
       if (this.root.isMinor()) {
@@ -247,7 +242,7 @@ var Chord = /*#__PURE__*/function () {
       var keyObj = _key["default"].wrap(key);
 
       return new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
+        suffix: normalizeSuffix(this.suffix),
         root: this.root.toNumeric(keyObj),
         bass: (_this$bass3 = this.bass) === null || _this$bass3 === void 0 ? void 0 : _this$bass3.toNumeric(keyObj)
       });
@@ -282,7 +277,7 @@ var Chord = /*#__PURE__*/function () {
       var keyObj = _key["default"].wrap(key);
 
       return new Chord({
-        suffix: chordSuffix(_classPrivateFieldGet(this, _rootNote), this.suffix),
+        suffix: normalizeSuffix(this.suffix),
         root: this.root.toNumeral(keyObj),
         bass: (_this$bass5 = this.bass) === null || _this$bass5 === void 0 ? void 0 : _this$bass5.toNumeral(keyObj)
       });
@@ -350,7 +345,7 @@ var Chord = /*#__PURE__*/function () {
       return chordString;
     }
     /**
-     * Normalizes the chord:
+     * Normalizes the chord root and bass notes:
      * - Fb becomes E
      * - Cb becomes B
      * - B# becomes C
@@ -360,14 +355,26 @@ var Chord = /*#__PURE__*/function () {
      * - 7# becomes 1
      * - 3# becomes 4
      *
-     * If the chord is already normalized, this will return a copy.
+     * 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`.
+     *
      * @returns {Chord} the normalized chord
      */
 
   }, {
     key: "normalize",
-    value: function normalize() {
-      return _classPrivateMethodGet(this, _process, _process2).call(this, 'normalize');
+    value: function normalize(key) {
+      if (!(0, _utilities.presence)(key)) {
+        return _classPrivateMethodGet(this, _process, _process2).call(this, 'normalize').set({
+          suffix: (0, _utilities.presence)(normalizeSuffix(this.suffix))
+        });
+      }
+
+      return this.set({
+        root: this.root.normalizeEnharmonics(key),
+        suffix: (0, _utilities.presence)(normalizeSuffix(this.suffix)),
+        bass: this.bass ? this.bass.normalizeEnharmonics(this.root.toString()) : null
+      });
     }
     /**
      * Switches to the specified modifier

package/lib/chord_sheet/chord_lyrics_pair.js

@@ -66,6 +66,11 @@ var ChordLyricsPair = /*#__PURE__*/function () {
     value: function toString() {
       return "ChordLyricsPair(chords=".concat(this.chords, ", lyrics=").concat(this.lyrics, ")");
     }
+  }, {
+    key: "set",
+    value: function set(properties) {
+      return new this.constructor(properties.chords || this.chords, properties.lyrics || this.lyrics);
+    }
   }]);
 
   return ChordLyricsPair;

package/lib/chord_sheet/line.js

@@ -15,6 +15,12 @@ var _constants = require("../constants");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : 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); } }
@@ -93,9 +99,17 @@ var Line = /*#__PURE__*/function () {
   }, {
     key: "clone",
     value: function clone() {
+      return this.mapItems(null);
+    }
+  }, {
+    key: "mapItems",
+    value: function mapItems(func) {
       var clonedLine = new Line();
       clonedLine.items = this.items.map(function (item) {
-        return item.clone();
+        var clonedItem = item.clone();
+        return func ? func(clonedItem) : clonedItem;
+      }).filter(function (item) {
+        return item;
       });
       clonedLine.type = this.type;
       return clonedLine;
@@ -176,6 +190,14 @@ var Line = /*#__PURE__*/function () {
       this.items.push(comment);
       return comment;
     }
+  }, {
+    key: "set",
+    value: function set(properties) {
+      return new this.constructor(_objectSpread({
+        type: this.type,
+        items: this.items
+      }, properties));
+    }
   }]);
 
   return Line;

package/lib/chord_sheet/metadata.js

@@ -74,6 +74,11 @@ var Metadata = /*#__PURE__*/function () {
   }
 
   _createClass(Metadata, [{
+    key: "contains",
+    value: function contains(key) {
+      return key in this;
+    }
+  }, {
     key: "add",
     value: function add(key, value) {
       if ((0, _tag.isReadonlyTag)(key)) {
@@ -98,6 +103,15 @@ var Metadata = /*#__PURE__*/function () {
 
       this[key] = [currentValue, value];
     }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (value) {
+        this[key] = value;
+      } else {
+        delete this[key];
+      }
+    }
     /**
      * Reads a metadata value by key. This method supports simple value lookup, as fetching single array values.
      *

package/lib/chord_sheet/song.js

@@ -11,6 +11,12 @@ var _line = _interopRequireDefault(require("./line"));
 
 var _paragraph = _interopRequireDefault(require("./paragraph"));
 
+var _key = _interopRequireDefault(require("../key"));
+
+var _chord = _interopRequireDefault(require("../chord"));
+
+var _chord_lyrics_pair = _interopRequireDefault(require("./chord_lyrics_pair"));
+
 var _utilities = require("../utilities");
 
 var _metadata = _interopRequireDefault(require("./metadata"));
@@ -45,6 +51,22 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+
+var _insertDirective = /*#__PURE__*/new WeakSet();
+
+var _mapItems = /*#__PURE__*/new WeakSet();
+
+var _mapLines = /*#__PURE__*/new WeakSet();
+
+var _updateItem = /*#__PURE__*/new WeakSet();
+
+var _removeItem = /*#__PURE__*/new WeakSet();
+
 /**
  * Represents a song in a chord sheet. Currently a chord sheet can only have one song.
  */
@@ -58,16 +80,24 @@ var Song = /*#__PURE__*/function () {
 
     _classCallCheck(this, Song);
 
+    _classPrivateMethodInitSpec(this, _removeItem);
+
+    _classPrivateMethodInitSpec(this, _updateItem);
+
+    _classPrivateMethodInitSpec(this, _mapLines);
+
+    _classPrivateMethodInitSpec(this, _mapItems);
+
+    _classPrivateMethodInitSpec(this, _insertDirective);
+
     /**
      * The {@link Line} items of which the song consists
-     * @member
-     * @type {Array<Line>}
+     * @member {Array<Line>}
      */
     this.lines = [];
     /**
      * The {@link Paragraph} items of which the song consists
-     * @member
-     * @type {Paragraph[]}
+     * @member {Paragraph[]}
      */
 
     this.paragraphs = [];
@@ -83,6 +113,7 @@ var Song = /*#__PURE__*/function () {
     this.warnings = [];
     this.sectionType = _constants.NONE;
     this.currentKey = null;
+    this.transposeKey = null;
   }
 
   _createClass(Song, [{
@@ -147,11 +178,14 @@ var Song = /*#__PURE__*/function () {
   }, {
     key: "addLine",
     value: function addLine() {
+      var _this$transposeKey;
+
       this.ensureParagraph();
       this.flushLine();
       this.currentLine = (0, _utilities.pushNew)(this.lines, _line["default"]);
       this.setCurrentLineType(this.sectionType);
-      this.currentLine.key = this.currentKey;
+      this.currentLine.transposeKey = (_this$transposeKey = this.transposeKey) !== null && _this$transposeKey !== void 0 ? _this$transposeKey : this.currentKey;
+      this.currentLine.key = this.currentKey || this.key;
       return this.currentLine;
     }
   }, {
@@ -211,6 +245,8 @@ var Song = /*#__PURE__*/function () {
       if (tag.isMetaTag()) {
         this.setMetaData(tag.name, tag.value);
       } else if (tag.name === _tag.TRANSPOSE) {
+        this.transposeKey = tag.value;
+      } else if (tag.name === _tag.NEW_KEY) {
         this.currentKey = tag.value;
       } else {
         this.setSectionTypeFromTag(tag);
@@ -304,12 +340,7 @@ var Song = /*#__PURE__*/function () {
   }, {
     key: "clone",
     value: function clone() {
-      var clonedSong = new Song();
-      clonedSong.lines = this.lines.map(function (line) {
-        return line.clone();
-      });
-      clonedSong.metadata = this.metadata.clone();
-      return clonedSong;
+      return _classPrivateMethodGet(this, _mapItems, _mapItems2).call(this, null);
     }
   }, {
     key: "setMetaData",
@@ -333,11 +364,158 @@ var Song = /*#__PURE__*/function () {
     value: function getMetaData(name) {
       return this.metadata[name] || null;
     }
+    /**
+     * Returns a copy of the song with the capo value set to the specified capo. It changes:
+     * - the value for `capo` in the `metadata` set
+     * - any existing `capo` directive)
+     * @param {number|null} capo the capo. Passing `null` will:
+     * - remove the current key from `metadata`
+     * - remove any `capo` directive
+     * @returns {Song} The changed song
+     */
+
+  }, {
+    key: "setCapo",
+    value: function setCapo(capo) {
+      var updatedSong;
+
+      if (capo === null) {
+        updatedSong = _classPrivateMethodGet(this, _removeItem, _removeItem2).call(this, function (item) {
+          return item instanceof _tag["default"] && item.name === _tag.CAPO;
+        });
+      } else {
+        updatedSong = _classPrivateMethodGet(this, _updateItem, _updateItem2).call(this, function (item) {
+          return item instanceof _tag["default"] && item.name === _tag.CAPO;
+        }, function (item) {
+          return item.set({
+            value: capo
+          });
+        }, function (song) {
+          return _classPrivateMethodGet(song, _insertDirective, _insertDirective2).call(song, _tag.CAPO, capo);
+        });
+      }
+
+      updatedSong.metadata.set('capo', capo);
+      return updatedSong;
+    }
+    /**
+     * Returns a copy of the song with the key set to the specified key. It changes:
+     * - the value for `key` in the `metadata` set
+     * - any existing `key` directive
+     * - all chords, those are transposed according to the distance between the current and the new key
+     * @param {string} key The new key.
+     * @returns {Song} The changed song
+     */
+
+  }, {
+    key: "setKey",
+    value: function setKey(key) {
+      var transpose = _key["default"].distance(this.key, key);
+
+      var updatedSong = _classPrivateMethodGet(this, _mapItems, _mapItems2).call(this, function (item) {
+        if (item instanceof _tag["default"] && item.name === _tag.KEY) {
+          return item.set({
+            value: key
+          });
+        }
+
+        if (item instanceof _chord_lyrics_pair["default"]) {
+          var chordObj = _chord["default"].parse(item.chords);
+
+          if (chordObj) {
+            return item.set({
+              chords: chordObj.transpose(transpose).normalize(key)
+            });
+          }
+        }
+
+        return item;
+      });
+
+      updatedSong.metadata.set('key', key);
+      return updatedSong;
+    }
   }]);
 
   return Song;
 }();
 
+function _insertDirective2(name, value) {
+  var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      _ref2$after = _ref2.after,
+      after = _ref2$after === void 0 ? null : _ref2$after;
+
+  var insertIndex = this.lines.findIndex(function (line) {
+    return line.items.some(function (item) {
+      return !(item instanceof _tag["default"]) || after && item instanceof _tag["default"] && item.name === after;
+    });
+  });
+  var newLine = new _line["default"]();
+  newLine.addTag(name, value);
+  var clonedSong = this.clone();
+  var lines = clonedSong.lines;
+  clonedSong.lines = [].concat(_toConsumableArray(lines.slice(0, insertIndex)), [newLine], _toConsumableArray(lines.slice(insertIndex)));
+  return clonedSong;
+}
+
+function _mapItems2(func) {
+  var clonedSong = new Song();
+  clonedSong.lines = this.lines.map(function (line) {
+    return line.mapItems(func);
+  });
+  clonedSong.metadata = this.metadata.clone();
+  return clonedSong;
+}
+
+function _mapLines2(func) {
+  var clonedSong = new Song();
+  clonedSong.lines = this.lines.map(function (line) {
+    return func(line.clone());
+  }).filter(function (line) {
+    return line;
+  });
+  clonedSong.metadata = this.metadata.clone();
+  return clonedSong;
+}
+
+function _updateItem2(findCallback, updateCallback, notFoundCallback) {
+  var found = false;
+
+  var updatedSong = _classPrivateMethodGet(this, _mapItems, _mapItems2).call(this, function (item) {
+    if (findCallback(item)) {
+      found = true;
+      return updateCallback(item);
+    }
+
+    return item;
+  });
+
+  if (!found) {
+    return notFoundCallback(updatedSong);
+  }
+
+  return updatedSong;
+}
+
+function _removeItem2(callback) {
+  return _classPrivateMethodGet(this, _mapLines, _mapLines2).call(this, function (line) {
+    var items = line.items;
+    var index = items.findIndex(callback);
+
+    if (index === -1) {
+      return line;
+    }
+
+    if (items.length === 1) {
+      return null;
+    }
+
+    return line.set({
+      items: [].concat(_toConsumableArray(items.slice(0, index)), _toConsumableArray(items.slice(index + 1)))
+    });
+  });
+}
+
 var defineProperty = Object.defineProperty;
 var songPrototype = Song.prototype;