@tonaljs/chord 4.6.5 → 4.7.0

package/README.md

@@ -5,13 +5,13 @@
 ES6:
 
 ```js
-import { Chord } from "@tonaljs/tonal";
+import { Chord } from "tonal";
 ```
 
 Nodejs:
 
 ```js
-const { Chord } = require("@tonaljs/tonal");
+const { Chord } = require("tonal");
 ```
 
 ## API

package/dist/index.d.ts

@@ -1,91 +1,93 @@
-import { detect } from "@tonaljs/chord-detect";
-import { ChordType } from "@tonaljs/chord-type";
-import { NoteName } from "@tonaljs/core";
-export { detect } from "@tonaljs/chord-detect";
-declare type ChordName = string;
-declare type ChordNameTokens = [string, string];
-export interface Chord extends ChordType {
-    tonic: string | null;
-    type: string;
-    root: string;
-    rootDegree: number;
-    symbol: string;
-    notes: NoteName[];
-}
-/**
- * Tokenize a chord name. It returns an array with the tonic and chord type
- * If not tonic is found, all the name is considered the chord name.
- *
- * This function does NOT check if the chord type exists or not. It only tries
- * to split the tonic and chord type.
- *
- * @function
- * @param {string} name - the chord name
- * @return {Array} an array with [tonic, type]
- * @example
- * tokenize("Cmaj7") // => [ "C", "maj7" ]
- * tokenize("C7") // => [ "C", "7" ]
- * tokenize("mMaj7") // => [ null, "mMaj7" ]
- * tokenize("Cnonsense") // => [ null, "nonsense" ]
- */
-export declare function tokenize(name: string): ChordNameTokens;
-/**
- * Get a Chord from a chord name.
- */
-export declare function get(src: ChordName | ChordNameTokens): Chord;
-/**
- * Get chord properties
- *
- * @param typeName - the chord type name
- * @param [tonic] - Optional tonic
- * @param [root]  - Optional root (requires a tonic)
- */
-export declare function getChord(typeName: string, optionalTonic?: string, optionalRoot?: string): Chord;
-export declare const chord: (this: unknown, ...args: unknown[]) => Chord;
-/**
- * Transpose a chord name
- *
- * @param {string} chordName - the chord name
- * @return {string} the transposed chord
- *
- * @example
- * transpose('Dm7', 'P4') // => 'Gm7
- */
-export declare function transpose(chordName: string, interval: string): string;
-/**
- * Get all scales where the given chord fits
- *
- * @example
- * chordScales('C7b9')
- * // => ["phrygian dominant", "flamenco", "spanish heptatonic", "half-whole diminished", "chromatic"]
- */
-export declare function chordScales(name: string): string[];
-/**
- * Get all chords names that are a superset of the given one
- * (has the same notes and at least one more)
- *
- * @function
- * @example
- * extended("CMaj7")
- * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]
- */
-export declare function extended(chordName: string): string[];
-/**
- * Find all chords names that are a subset of the given one
- * (has less notes but all from the given chord)
- *
- * @example
- */
-export declare function reduced(chordName: string): string[];
-declare const _default: {
-    getChord: typeof getChord;
-    get: typeof get;
-    detect: typeof detect;
-    chordScales: typeof chordScales;
-    extended: typeof extended;
-    reduced: typeof reduced;
-    tokenize: typeof tokenize;
-    transpose: typeof transpose;
-    chord: (this: unknown, ...args: unknown[]) => Chord;
-};
-export default _default;
+import { detect } from '@tonaljs/chord-detect';
+export { detect } from '@tonaljs/chord-detect';
+import { ChordType } from '@tonaljs/chord-type';
+import { NoteName } from '@tonaljs/core';
+
+type ChordName = string;
+type ChordNameTokens = [string, string];
+interface Chord extends ChordType {
+    tonic: string | null;
+    type: string;
+    root: string;
+    rootDegree: number;
+    symbol: string;
+    notes: NoteName[];
+}
+/**
+ * Tokenize a chord name. It returns an array with the tonic and chord type
+ * If not tonic is found, all the name is considered the chord name.
+ *
+ * This function does NOT check if the chord type exists or not. It only tries
+ * to split the tonic and chord type.
+ *
+ * @function
+ * @param {string} name - the chord name
+ * @return {Array} an array with [tonic, type]
+ * @example
+ * tokenize("Cmaj7") // => [ "C", "maj7" ]
+ * tokenize("C7") // => [ "C", "7" ]
+ * tokenize("mMaj7") // => [ null, "mMaj7" ]
+ * tokenize("Cnonsense") // => [ null, "nonsense" ]
+ */
+declare function tokenize(name: string): ChordNameTokens;
+/**
+ * Get a Chord from a chord name.
+ */
+declare function get(src: ChordName | ChordNameTokens): Chord;
+/**
+ * Get chord properties
+ *
+ * @param typeName - the chord type name
+ * @param [tonic] - Optional tonic
+ * @param [root]  - Optional root (requires a tonic)
+ */
+declare function getChord(typeName: string, optionalTonic?: string, optionalRoot?: string): Chord;
+declare const chord: (this: unknown, ...args: unknown[]) => Chord;
+/**
+ * Transpose a chord name
+ *
+ * @param {string} chordName - the chord name
+ * @return {string} the transposed chord
+ *
+ * @example
+ * transpose('Dm7', 'P4') // => 'Gm7
+ */
+declare function transpose(chordName: string, interval: string): string;
+/**
+ * Get all scales where the given chord fits
+ *
+ * @example
+ * chordScales('C7b9')
+ * // => ["phrygian dominant", "flamenco", "spanish heptatonic", "half-whole diminished", "chromatic"]
+ */
+declare function chordScales(name: string): string[];
+/**
+ * Get all chords names that are a superset of the given one
+ * (has the same notes and at least one more)
+ *
+ * @function
+ * @example
+ * extended("CMaj7")
+ * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]
+ */
+declare function extended(chordName: string): string[];
+/**
+ * Find all chords names that are a subset of the given one
+ * (has less notes but all from the given chord)
+ *
+ * @example
+ */
+declare function reduced(chordName: string): string[];
+declare const _default: {
+    getChord: typeof getChord;
+    get: typeof get;
+    detect: typeof detect;
+    chordScales: typeof chordScales;
+    extended: typeof extended;
+    reduced: typeof reduced;
+    tokenize: typeof tokenize;
+    transpose: typeof transpose;
+    chord: (this: unknown, ...args: unknown[]) => Chord;
+};
+
+export { Chord, chord, chordScales, _default as default, extended, get, getChord, reduced, tokenize, transpose };

package/dist/index.js

@@ -1,233 +1,169 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@tonaljs/chord-detect'), require('@tonaljs/chord-type'), require('@tonaljs/core'), require('@tonaljs/pcset'), require('@tonaljs/scale-type')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@tonaljs/chord-detect', '@tonaljs/chord-type', '@tonaljs/core', '@tonaljs/pcset', '@tonaljs/scale-type'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Chord = {}, global.chordDetect, global.chordType, global.core, global.pcset, global.scaleType));
-}(this, (function (exports, chordDetect, chordType, core, pcset, scaleType) { 'use strict';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(t) {
-            for (var s, i = 1, n = arguments.length; i < n; i++) {
-                s = arguments[i];
-                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-            return t;
-        };
-        return __assign.apply(this, arguments);
-    };
-
-    var NoChord = {
-        empty: true,
-        name: "",
-        symbol: "",
-        root: "",
-        rootDegree: 0,
-        type: "",
-        tonic: null,
-        setNum: NaN,
-        quality: "Unknown",
-        chroma: "",
-        normalized: "",
-        aliases: [],
-        notes: [],
-        intervals: [],
-    };
-    // 6, 64, 7, 9, 11 and 13 are consider part of the chord
-    // (see https://github.com/danigb/tonal/issues/55)
-    var NUM_TYPES = /^(6|64|7|9|11|13)$/;
-    /**
-     * Tokenize a chord name. It returns an array with the tonic and chord type
-     * If not tonic is found, all the name is considered the chord name.
-     *
-     * This function does NOT check if the chord type exists or not. It only tries
-     * to split the tonic and chord type.
-     *
-     * @function
-     * @param {string} name - the chord name
-     * @return {Array} an array with [tonic, type]
-     * @example
-     * tokenize("Cmaj7") // => [ "C", "maj7" ]
-     * tokenize("C7") // => [ "C", "7" ]
-     * tokenize("mMaj7") // => [ null, "mMaj7" ]
-     * tokenize("Cnonsense") // => [ null, "nonsense" ]
-     */
-    function tokenize(name) {
-        var _a = core.tokenizeNote(name), letter = _a[0], acc = _a[1], oct = _a[2], type = _a[3];
-        if (letter === "") {
-            return ["", name];
-        }
-        // aug is augmented (see https://github.com/danigb/tonal/issues/55)
-        if (letter === "A" && type === "ug") {
-            return ["", "aug"];
-        }
-        // see: https://github.com/tonaljs/tonal/issues/70
-        if (!type && (oct === "4" || oct === "5")) {
-            return [letter + acc, oct];
-        }
-        if (NUM_TYPES.test(oct)) {
-            return [letter + acc, oct + type];
-        }
-        else {
-            return [letter + acc + oct, type];
-        }
-    }
-    /**
-     * Get a Chord from a chord name.
-     */
-    function get(src) {
-        if (src === "") {
-            return NoChord;
-        }
-        if (Array.isArray(src) && src.length === 2) {
-            return getChord(src[1], src[0]);
-        }
-        else {
-            var _a = tokenize(src), tonic = _a[0], type = _a[1];
-            var chord_1 = getChord(type, tonic);
-            return chord_1.empty ? getChord(src) : chord_1;
-        }
-    }
-    /**
-     * Get chord properties
-     *
-     * @param typeName - the chord type name
-     * @param [tonic] - Optional tonic
-     * @param [root]  - Optional root (requires a tonic)
-     */
-    function getChord(typeName, optionalTonic, optionalRoot) {
-        var type = chordType.get(typeName);
-        var tonic = core.note(optionalTonic || "");
-        var root = core.note(optionalRoot || "");
-        if (type.empty ||
-            (optionalTonic && tonic.empty) ||
-            (optionalRoot && root.empty)) {
-            return NoChord;
-        }
-        var rootInterval = core.distance(tonic.pc, root.pc);
-        var rootDegree = type.intervals.indexOf(rootInterval) + 1;
-        if (!root.empty && !rootDegree) {
-            return NoChord;
-        }
-        var intervals = Array.from(type.intervals);
-        for (var i = 1; i < rootDegree; i++) {
-            var num = intervals[0][0];
-            var quality = intervals[0][1];
-            var newNum = parseInt(num, 10) + 7;
-            intervals.push("" + newNum + quality);
-            intervals.shift();
-        }
-        var notes = tonic.empty
-            ? []
-            : intervals.map(function (i) { return core.transpose(tonic, i); });
-        typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
-        var symbol = "" + (tonic.empty ? "" : tonic.pc) + typeName + (root.empty || rootDegree <= 1 ? "" : "/" + root.pc);
-        var name = "" + (optionalTonic ? tonic.pc + " " : "") + type.name + (rootDegree > 1 && optionalRoot ? " over " + root.pc : "");
-        return __assign(__assign({}, type), { name: name, symbol: symbol, type: type.name, root: root.name, intervals: intervals, rootDegree: rootDegree, tonic: tonic.name, notes: notes });
-    }
-    var chord = core.deprecate("Chord.chord", "Chord.get", get);
-    /**
-     * Transpose a chord name
-     *
-     * @param {string} chordName - the chord name
-     * @return {string} the transposed chord
-     *
-     * @example
-     * transpose('Dm7', 'P4') // => 'Gm7
-     */
-    function transpose(chordName, interval) {
-        var _a = tokenize(chordName), tonic = _a[0], type = _a[1];
-        if (!tonic) {
-            return chordName;
-        }
-        return core.transpose(tonic, interval) + type;
-    }
-    /**
-     * Get all scales where the given chord fits
-     *
-     * @example
-     * chordScales('C7b9')
-     * // => ["phrygian dominant", "flamenco", "spanish heptatonic", "half-whole diminished", "chromatic"]
-     */
-    function chordScales(name) {
-        var s = get(name);
-        var isChordIncluded = pcset.isSupersetOf(s.chroma);
-        return scaleType.all()
-            .filter(function (scale) { return isChordIncluded(scale.chroma); })
-            .map(function (scale) { return scale.name; });
-    }
-    /**
-     * Get all chords names that are a superset of the given one
-     * (has the same notes and at least one more)
-     *
-     * @function
-     * @example
-     * extended("CMaj7")
-     * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]
-     */
-    function extended(chordName) {
-        var s = get(chordName);
-        var isSuperset = pcset.isSupersetOf(s.chroma);
-        return chordType.all()
-            .filter(function (chord) { return isSuperset(chord.chroma); })
-            .map(function (chord) { return s.tonic + chord.aliases[0]; });
-    }
-    /**
-     * Find all chords names that are a subset of the given one
-     * (has less notes but all from the given chord)
-     *
-     * @example
-     */
-    function reduced(chordName) {
-        var s = get(chordName);
-        var isSubset = pcset.isSubsetOf(s.chroma);
-        return chordType.all()
-            .filter(function (chord) { return isSubset(chord.chroma); })
-            .map(function (chord) { return s.tonic + chord.aliases[0]; });
-    }
-    var index = {
-        getChord: getChord,
-        get: get,
-        detect: chordDetect.detect,
-        chordScales: chordScales,
-        extended: extended,
-        reduced: reduced,
-        tokenize: tokenize,
-        transpose: transpose,
-        // deprecate
-        chord: chord,
-    };
-
-    Object.defineProperty(exports, 'detect', {
-        enumerable: true,
-        get: function () {
-            return chordDetect.detect;
-        }
-    });
-    exports.chord = chord;
-    exports.chordScales = chordScales;
-    exports['default'] = index;
-    exports.extended = extended;
-    exports.get = get;
-    exports.getChord = getChord;
-    exports.reduced = reduced;
-    exports.tokenize = tokenize;
-    exports.transpose = transpose;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
-//# sourceMappingURL=index.js.map
+// index.ts
+var chord_exports = {};
+__export(chord_exports, {
+  chord: () => chord,
+  chordScales: () => chordScales,
+  default: () => chord_default,
+  detect: () => import_chord_detect2.detect,
+  extended: () => extended,
+  get: () => get,
+  getChord: () => getChord,
+  reduced: () => reduced,
+  tokenize: () => tokenize,
+  transpose: () => transpose
+});
+module.exports = __toCommonJS(chord_exports);
+var import_chord_detect = require("@tonaljs/chord-detect");
+var import_chord_type = require("@tonaljs/chord-type");
+var import_core = require("@tonaljs/core");
+var import_pcset = require("@tonaljs/pcset");
+var import_scale_type = require("@tonaljs/scale-type");
+var import_chord_detect2 = require("@tonaljs/chord-detect");
+var NoChord = {
+  empty: true,
+  name: "",
+  symbol: "",
+  root: "",
+  rootDegree: 0,
+  type: "",
+  tonic: null,
+  setNum: NaN,
+  quality: "Unknown",
+  chroma: "",
+  normalized: "",
+  aliases: [],
+  notes: [],
+  intervals: []
+};
+var NUM_TYPES = /^(6|64|7|9|11|13)$/;
+function tokenize(name) {
+  const [letter, acc, oct, type] = (0, import_core.tokenizeNote)(name);
+  if (letter === "") {
+    return ["", name];
+  }
+  if (letter === "A" && type === "ug") {
+    return ["", "aug"];
+  }
+  if (!type && (oct === "4" || oct === "5")) {
+    return [letter + acc, oct];
+  }
+  if (NUM_TYPES.test(oct)) {
+    return [letter + acc, oct + type];
+  } else {
+    return [letter + acc + oct, type];
+  }
+}
+function get(src) {
+  if (src === "") {
+    return NoChord;
+  }
+  if (Array.isArray(src) && src.length === 2) {
+    return getChord(src[1], src[0]);
+  } else {
+    const [tonic, type] = tokenize(src);
+    const chord2 = getChord(type, tonic);
+    return chord2.empty ? getChord(src) : chord2;
+  }
+}
+function getChord(typeName, optionalTonic, optionalRoot) {
+  const type = (0, import_chord_type.get)(typeName);
+  const tonic = (0, import_core.note)(optionalTonic || "");
+  const root = (0, import_core.note)(optionalRoot || "");
+  if (type.empty || optionalTonic && tonic.empty || optionalRoot && root.empty) {
+    return NoChord;
+  }
+  const rootInterval = (0, import_core.distance)(tonic.pc, root.pc);
+  const rootDegree = type.intervals.indexOf(rootInterval) + 1;
+  if (!root.empty && !rootDegree) {
+    return NoChord;
+  }
+  const intervals = Array.from(type.intervals);
+  for (let i = 1; i < rootDegree; i++) {
+    const num = intervals[0][0];
+    const quality = intervals[0][1];
+    const newNum = parseInt(num, 10) + 7;
+    intervals.push(`${newNum}${quality}`);
+    intervals.shift();
+  }
+  const notes = tonic.empty ? [] : intervals.map((i) => (0, import_core.transpose)(tonic, i));
+  typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
+  const symbol = `${tonic.empty ? "" : tonic.pc}${typeName}${root.empty || rootDegree <= 1 ? "" : "/" + root.pc}`;
+  const name = `${optionalTonic ? tonic.pc + " " : ""}${type.name}${rootDegree > 1 && optionalRoot ? " over " + root.pc : ""}`;
+  return {
+    ...type,
+    name,
+    symbol,
+    type: type.name,
+    root: root.name,
+    intervals,
+    rootDegree,
+    tonic: tonic.name,
+    notes
+  };
+}
+var chord = (0, import_core.deprecate)("Chord.chord", "Chord.get", get);
+function transpose(chordName, interval) {
+  const [tonic, type] = tokenize(chordName);
+  if (!tonic) {
+    return chordName;
+  }
+  return (0, import_core.transpose)(tonic, interval) + type;
+}
+function chordScales(name) {
+  const s = get(name);
+  const isChordIncluded = (0, import_pcset.isSupersetOf)(s.chroma);
+  return (0, import_scale_type.all)().filter((scale) => isChordIncluded(scale.chroma)).map((scale) => scale.name);
+}
+function extended(chordName) {
+  const s = get(chordName);
+  const isSuperset = (0, import_pcset.isSupersetOf)(s.chroma);
+  return (0, import_chord_type.all)().filter((chord2) => isSuperset(chord2.chroma)).map((chord2) => s.tonic + chord2.aliases[0]);
+}
+function reduced(chordName) {
+  const s = get(chordName);
+  const isSubset = (0, import_pcset.isSubsetOf)(s.chroma);
+  return (0, import_chord_type.all)().filter((chord2) => isSubset(chord2.chroma)).map((chord2) => s.tonic + chord2.aliases[0]);
+}
+var chord_default = {
+  getChord,
+  get,
+  detect: import_chord_detect.detect,
+  chordScales,
+  extended,
+  reduced,
+  tokenize,
+  transpose,
+  chord
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chord,
+  chordScales,
+  detect,
+  extended,
+  get,
+  getChord,
+  reduced,
+  tokenize,
+  transpose
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"sources":["../index.ts"],"sourcesContent":["import { detect } from \"@tonaljs/chord-detect\";\nimport {\n  all as chordTypes,\n  ChordType,\n  get as getChordType,\n} from \"@tonaljs/chord-type\";\n\nimport {\n  deprecate,\n  distance,\n  note,\n  NoteName,\n  tokenizeNote,\n  transpose as transposeNote,\n} from \"@tonaljs/core\";\n\nimport { isSubsetOf, isSupersetOf } from \"@tonaljs/pcset\";\n\nimport { all as scaleTypes } from \"@tonaljs/scale-type\";\nexport { detect } from \"@tonaljs/chord-detect\";\n\ntype ChordName = string;\ntype ChordNameTokens = [string, string]; // [TONIC, SCALE TYPE]\n\nexport interface Chord extends ChordType {\n  tonic: string | null;\n  type: string;\n  root: string;\n  rootDegree: number;\n  symbol: string;\n  notes: NoteName[];\n}\n\nconst NoChord: Chord = {\n  empty: true,\n  name: \"\",\n  symbol: \"\",\n  root: \"\",\n  rootDegree: 0,\n  type: \"\",\n  tonic: null,\n  setNum: NaN,\n  quality: \"Unknown\",\n  chroma: \"\",\n  normalized: \"\",\n  aliases: [],\n  notes: [],\n  intervals: [],\n};\n\n// 6, 64, 7, 9, 11 and 13 are consider part of the chord\n// (see https://github.com/danigb/tonal/issues/55)\nconst NUM_TYPES = /^(6|64|7|9|11|13)$/;\n/**\n * Tokenize a chord name. It returns an array with the tonic and chord type\n * If not tonic is found, all the name is considered the chord name.\n *\n * This function does NOT check if the chord type exists or not. It only tries\n * to split the tonic and chord type.\n *\n * @function\n * @param {string} name - the chord name\n * @return {Array} an array with [tonic, type]\n * @example\n * tokenize(\"Cmaj7\") // => [ \"C\", \"maj7\" ]\n * tokenize(\"C7\") // => [ \"C\", \"7\" ]\n * tokenize(\"mMaj7\") // => [ null, \"mMaj7\" ]\n * tokenize(\"Cnonsense\") // => [ null, \"nonsense\" ]\n */\nexport function tokenize(name: string): ChordNameTokens {\n  const [letter, acc, oct, type] = tokenizeNote(name);\n  if (letter === \"\") {\n    return [\"\", name];\n  }\n  // aug is augmented (see https://github.com/danigb/tonal/issues/55)\n  if (letter === \"A\" && type === \"ug\") {\n    return [\"\", \"aug\"];\n  }\n  // see: https://github.com/tonaljs/tonal/issues/70\n  if (!type && (oct === \"4\" || oct === \"5\")) {\n    return [letter + acc, oct];\n  }\n\n  if (NUM_TYPES.test(oct)) {\n    return [letter + acc, oct + type];\n  } else {\n    return [letter + acc + oct, type];\n  }\n}\n\n/**\n * Get a Chord from a chord name.\n */\nexport function get(src: ChordName | ChordNameTokens): Chord {\n  if (src === \"\") {\n    return NoChord;\n  }\n  if (Array.isArray(src) && src.length === 2) {\n    return getChord(src[1], src[0]);\n  } else {\n    const [tonic, type] = tokenize(src);\n    const chord = getChord(type, tonic);\n    return chord.empty ? getChord(src) : chord;\n  }\n}\n\n/**\n * Get chord properties\n *\n * @param typeName - the chord type name\n * @param [tonic] - Optional tonic\n * @param [root]  - Optional root (requires a tonic)\n */\nexport function getChord(\n  typeName: string,\n  optionalTonic?: string,\n  optionalRoot?: string\n): Chord {\n  const type = getChordType(typeName);\n  const tonic = note(optionalTonic || \"\");\n  const root = note(optionalRoot || \"\");\n\n  if (\n    type.empty ||\n    (optionalTonic && tonic.empty) ||\n    (optionalRoot && root.empty)\n  ) {\n    return NoChord;\n  }\n\n  const rootInterval = distance(tonic.pc, root.pc);\n  const rootDegree = type.intervals.indexOf(rootInterval) + 1;\n  if (!root.empty && !rootDegree) {\n    return NoChord;\n  }\n\n  const intervals = Array.from(type.intervals);\n\n  for (let i = 1; i < rootDegree; i++) {\n    const num = intervals[0][0];\n    const quality = intervals[0][1];\n    const newNum = parseInt(num, 10) + 7;\n    intervals.push(`${newNum}${quality}`);\n    intervals.shift();\n  }\n\n  const notes = tonic.empty\n    ? []\n    : intervals.map((i) => transposeNote(tonic, i));\n\n  typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];\n  const symbol = `${tonic.empty ? \"\" : tonic.pc}${typeName}${\n    root.empty || rootDegree <= 1 ? \"\" : \"/\" + root.pc\n  }`;\n  const name = `${optionalTonic ? tonic.pc + \" \" : \"\"}${type.name}${\n    rootDegree > 1 && optionalRoot ? \" over \" + root.pc : \"\"\n  }`;\n  return {\n    ...type,\n    name,\n    symbol,\n    type: type.name,\n    root: root.name,\n    intervals,\n    rootDegree,\n    tonic: tonic.name,\n    notes,\n  };\n}\n\nexport const chord = deprecate(\"Chord.chord\", \"Chord.get\", get);\n\n/**\n * Transpose a chord name\n *\n * @param {string} chordName - the chord name\n * @return {string} the transposed chord\n *\n * @example\n * transpose('Dm7', 'P4') // => 'Gm7\n */\nexport function transpose(chordName: string, interval: string): string {\n  const [tonic, type] = tokenize(chordName);\n  if (!tonic) {\n    return chordName;\n  }\n  return transposeNote(tonic, interval) + type;\n}\n\n/**\n * Get all scales where the given chord fits\n *\n * @example\n * chordScales('C7b9')\n * // => [\"phrygian dominant\", \"flamenco\", \"spanish heptatonic\", \"half-whole diminished\", \"chromatic\"]\n */\nexport function chordScales(name: string): string[] {\n  const s = get(name);\n  const isChordIncluded = isSupersetOf(s.chroma);\n  return scaleTypes()\n    .filter((scale) => isChordIncluded(scale.chroma))\n    .map((scale) => scale.name);\n}\n/**\n * Get all chords names that are a superset of the given one\n * (has the same notes and at least one more)\n *\n * @function\n * @example\n * extended(\"CMaj7\")\n * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]\n */\nexport function extended(chordName: string): string[] {\n  const s = get(chordName);\n  const isSuperset = isSupersetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => isSuperset(chord.chroma))\n    .map((chord) => s.tonic + chord.aliases[0]);\n}\n\n/**\n * Find all chords names that are a subset of the given one\n * (has less notes but all from the given chord)\n *\n * @example\n */\nexport function reduced(chordName: string): string[] {\n  const s = get(chordName);\n  const isSubset = isSubsetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => isSubset(chord.chroma))\n    .map((chord) => s.tonic + chord.aliases[0]);\n}\n\nexport default {\n  getChord,\n  get,\n  detect,\n  chordScales,\n  extended,\n  reduced,\n  tokenize,\n  transpose,\n  // deprecate\n  chord,\n};\n"],"mappings":"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","names":["import_chord_detect","chord","getChordType","transposeNote","scaleTypes","chordTypes"]}

package/dist/index.mjs

@@ -0,0 +1,145 @@
+// index.ts
+import { detect } from "@tonaljs/chord-detect";
+import {
+  all as chordTypes,
+  get as getChordType
+} from "@tonaljs/chord-type";
+import {
+  deprecate,
+  distance,
+  note,
+  tokenizeNote,
+  transpose as transposeNote
+} from "@tonaljs/core";
+import { isSubsetOf, isSupersetOf } from "@tonaljs/pcset";
+import { all as scaleTypes } from "@tonaljs/scale-type";
+import { detect as detect2 } from "@tonaljs/chord-detect";
+var NoChord = {
+  empty: true,
+  name: "",
+  symbol: "",
+  root: "",
+  rootDegree: 0,
+  type: "",
+  tonic: null,
+  setNum: NaN,
+  quality: "Unknown",
+  chroma: "",
+  normalized: "",
+  aliases: [],
+  notes: [],
+  intervals: []
+};
+var NUM_TYPES = /^(6|64|7|9|11|13)$/;
+function tokenize(name) {
+  const [letter, acc, oct, type] = tokenizeNote(name);
+  if (letter === "") {
+    return ["", name];
+  }
+  if (letter === "A" && type === "ug") {
+    return ["", "aug"];
+  }
+  if (!type && (oct === "4" || oct === "5")) {
+    return [letter + acc, oct];
+  }
+  if (NUM_TYPES.test(oct)) {
+    return [letter + acc, oct + type];
+  } else {
+    return [letter + acc + oct, type];
+  }
+}
+function get(src) {
+  if (src === "") {
+    return NoChord;
+  }
+  if (Array.isArray(src) && src.length === 2) {
+    return getChord(src[1], src[0]);
+  } else {
+    const [tonic, type] = tokenize(src);
+    const chord2 = getChord(type, tonic);
+    return chord2.empty ? getChord(src) : chord2;
+  }
+}
+function getChord(typeName, optionalTonic, optionalRoot) {
+  const type = getChordType(typeName);
+  const tonic = note(optionalTonic || "");
+  const root = note(optionalRoot || "");
+  if (type.empty || optionalTonic && tonic.empty || optionalRoot && root.empty) {
+    return NoChord;
+  }
+  const rootInterval = distance(tonic.pc, root.pc);
+  const rootDegree = type.intervals.indexOf(rootInterval) + 1;
+  if (!root.empty && !rootDegree) {
+    return NoChord;
+  }
+  const intervals = Array.from(type.intervals);
+  for (let i = 1; i < rootDegree; i++) {
+    const num = intervals[0][0];
+    const quality = intervals[0][1];
+    const newNum = parseInt(num, 10) + 7;
+    intervals.push(`${newNum}${quality}`);
+    intervals.shift();
+  }
+  const notes = tonic.empty ? [] : intervals.map((i) => transposeNote(tonic, i));
+  typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
+  const symbol = `${tonic.empty ? "" : tonic.pc}${typeName}${root.empty || rootDegree <= 1 ? "" : "/" + root.pc}`;
+  const name = `${optionalTonic ? tonic.pc + " " : ""}${type.name}${rootDegree > 1 && optionalRoot ? " over " + root.pc : ""}`;
+  return {
+    ...type,
+    name,
+    symbol,
+    type: type.name,
+    root: root.name,
+    intervals,
+    rootDegree,
+    tonic: tonic.name,
+    notes
+  };
+}
+var chord = deprecate("Chord.chord", "Chord.get", get);
+function transpose(chordName, interval) {
+  const [tonic, type] = tokenize(chordName);
+  if (!tonic) {
+    return chordName;
+  }
+  return transposeNote(tonic, interval) + type;
+}
+function chordScales(name) {
+  const s = get(name);
+  const isChordIncluded = isSupersetOf(s.chroma);
+  return scaleTypes().filter((scale) => isChordIncluded(scale.chroma)).map((scale) => scale.name);
+}
+function extended(chordName) {
+  const s = get(chordName);
+  const isSuperset = isSupersetOf(s.chroma);
+  return chordTypes().filter((chord2) => isSuperset(chord2.chroma)).map((chord2) => s.tonic + chord2.aliases[0]);
+}
+function reduced(chordName) {
+  const s = get(chordName);
+  const isSubset = isSubsetOf(s.chroma);
+  return chordTypes().filter((chord2) => isSubset(chord2.chroma)).map((chord2) => s.tonic + chord2.aliases[0]);
+}
+var chord_default = {
+  getChord,
+  get,
+  detect,
+  chordScales,
+  extended,
+  reduced,
+  tokenize,
+  transpose,
+  chord
+};
+export {
+  chord,
+  chordScales,
+  chord_default as default,
+  detect2 as detect,
+  extended,
+  get,
+  getChord,
+  reduced,
+  tokenize,
+  transpose
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts"],"sourcesContent":["import { detect } from \"@tonaljs/chord-detect\";\nimport {\n  all as chordTypes,\n  ChordType,\n  get as getChordType,\n} from \"@tonaljs/chord-type\";\n\nimport {\n  deprecate,\n  distance,\n  note,\n  NoteName,\n  tokenizeNote,\n  transpose as transposeNote,\n} from \"@tonaljs/core\";\n\nimport { isSubsetOf, isSupersetOf } from \"@tonaljs/pcset\";\n\nimport { all as scaleTypes } from \"@tonaljs/scale-type\";\nexport { detect } from \"@tonaljs/chord-detect\";\n\ntype ChordName = string;\ntype ChordNameTokens = [string, string]; // [TONIC, SCALE TYPE]\n\nexport interface Chord extends ChordType {\n  tonic: string | null;\n  type: string;\n  root: string;\n  rootDegree: number;\n  symbol: string;\n  notes: NoteName[];\n}\n\nconst NoChord: Chord = {\n  empty: true,\n  name: \"\",\n  symbol: \"\",\n  root: \"\",\n  rootDegree: 0,\n  type: \"\",\n  tonic: null,\n  setNum: NaN,\n  quality: \"Unknown\",\n  chroma: \"\",\n  normalized: \"\",\n  aliases: [],\n  notes: [],\n  intervals: [],\n};\n\n// 6, 64, 7, 9, 11 and 13 are consider part of the chord\n// (see https://github.com/danigb/tonal/issues/55)\nconst NUM_TYPES = /^(6|64|7|9|11|13)$/;\n/**\n * Tokenize a chord name. It returns an array with the tonic and chord type\n * If not tonic is found, all the name is considered the chord name.\n *\n * This function does NOT check if the chord type exists or not. It only tries\n * to split the tonic and chord type.\n *\n * @function\n * @param {string} name - the chord name\n * @return {Array} an array with [tonic, type]\n * @example\n * tokenize(\"Cmaj7\") // => [ \"C\", \"maj7\" ]\n * tokenize(\"C7\") // => [ \"C\", \"7\" ]\n * tokenize(\"mMaj7\") // => [ null, \"mMaj7\" ]\n * tokenize(\"Cnonsense\") // => [ null, \"nonsense\" ]\n */\nexport function tokenize(name: string): ChordNameTokens {\n  const [letter, acc, oct, type] = tokenizeNote(name);\n  if (letter === \"\") {\n    return [\"\", name];\n  }\n  // aug is augmented (see https://github.com/danigb/tonal/issues/55)\n  if (letter === \"A\" && type === \"ug\") {\n    return [\"\", \"aug\"];\n  }\n  // see: https://github.com/tonaljs/tonal/issues/70\n  if (!type && (oct === \"4\" || oct === \"5\")) {\n    return [letter + acc, oct];\n  }\n\n  if (NUM_TYPES.test(oct)) {\n    return [letter + acc, oct + type];\n  } else {\n    return [letter + acc + oct, type];\n  }\n}\n\n/**\n * Get a Chord from a chord name.\n */\nexport function get(src: ChordName | ChordNameTokens): Chord {\n  if (src === \"\") {\n    return NoChord;\n  }\n  if (Array.isArray(src) && src.length === 2) {\n    return getChord(src[1], src[0]);\n  } else {\n    const [tonic, type] = tokenize(src);\n    const chord = getChord(type, tonic);\n    return chord.empty ? getChord(src) : chord;\n  }\n}\n\n/**\n * Get chord properties\n *\n * @param typeName - the chord type name\n * @param [tonic] - Optional tonic\n * @param [root]  - Optional root (requires a tonic)\n */\nexport function getChord(\n  typeName: string,\n  optionalTonic?: string,\n  optionalRoot?: string\n): Chord {\n  const type = getChordType(typeName);\n  const tonic = note(optionalTonic || \"\");\n  const root = note(optionalRoot || \"\");\n\n  if (\n    type.empty ||\n    (optionalTonic && tonic.empty) ||\n    (optionalRoot && root.empty)\n  ) {\n    return NoChord;\n  }\n\n  const rootInterval = distance(tonic.pc, root.pc);\n  const rootDegree = type.intervals.indexOf(rootInterval) + 1;\n  if (!root.empty && !rootDegree) {\n    return NoChord;\n  }\n\n  const intervals = Array.from(type.intervals);\n\n  for (let i = 1; i < rootDegree; i++) {\n    const num = intervals[0][0];\n    const quality = intervals[0][1];\n    const newNum = parseInt(num, 10) + 7;\n    intervals.push(`${newNum}${quality}`);\n    intervals.shift();\n  }\n\n  const notes = tonic.empty\n    ? []\n    : intervals.map((i) => transposeNote(tonic, i));\n\n  typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];\n  const symbol = `${tonic.empty ? \"\" : tonic.pc}${typeName}${\n    root.empty || rootDegree <= 1 ? \"\" : \"/\" + root.pc\n  }`;\n  const name = `${optionalTonic ? tonic.pc + \" \" : \"\"}${type.name}${\n    rootDegree > 1 && optionalRoot ? \" over \" + root.pc : \"\"\n  }`;\n  return {\n    ...type,\n    name,\n    symbol,\n    type: type.name,\n    root: root.name,\n    intervals,\n    rootDegree,\n    tonic: tonic.name,\n    notes,\n  };\n}\n\nexport const chord = deprecate(\"Chord.chord\", \"Chord.get\", get);\n\n/**\n * Transpose a chord name\n *\n * @param {string} chordName - the chord name\n * @return {string} the transposed chord\n *\n * @example\n * transpose('Dm7', 'P4') // => 'Gm7\n */\nexport function transpose(chordName: string, interval: string): string {\n  const [tonic, type] = tokenize(chordName);\n  if (!tonic) {\n    return chordName;\n  }\n  return transposeNote(tonic, interval) + type;\n}\n\n/**\n * Get all scales where the given chord fits\n *\n * @example\n * chordScales('C7b9')\n * // => [\"phrygian dominant\", \"flamenco\", \"spanish heptatonic\", \"half-whole diminished\", \"chromatic\"]\n */\nexport function chordScales(name: string): string[] {\n  const s = get(name);\n  const isChordIncluded = isSupersetOf(s.chroma);\n  return scaleTypes()\n    .filter((scale) => isChordIncluded(scale.chroma))\n    .map((scale) => scale.name);\n}\n/**\n * Get all chords names that are a superset of the given one\n * (has the same notes and at least one more)\n *\n * @function\n * @example\n * extended(\"CMaj7\")\n * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]\n */\nexport function extended(chordName: string): string[] {\n  const s = get(chordName);\n  const isSuperset = isSupersetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => isSuperset(chord.chroma))\n    .map((chord) => s.tonic + chord.aliases[0]);\n}\n\n/**\n * Find all chords names that are a subset of the given one\n * (has less notes but all from the given chord)\n *\n * @example\n */\nexport function reduced(chordName: string): string[] {\n  const s = get(chordName);\n  const isSubset = isSubsetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => isSubset(chord.chroma))\n    .map((chord) => s.tonic + chord.aliases[0]);\n}\n\nexport default {\n  getChord,\n  get,\n  detect,\n  chordScales,\n  extended,\n  reduced,\n  tokenize,\n  transpose,\n  // deprecate\n  chord,\n};\n"],"mappings":"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","names":["detect","chord"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonaljs/chord",
-  "version": "4.6.5",
+  "version": "4.7.0",
   "description": "Musical chords and its relations",
   "keywords": [
     "chord",
@@ -10,23 +10,25 @@
     "@tonaljs"
   ],
   "main": "dist/index.js",
-  "module": "dist/index.es.js",
+  "module": "dist/index.mjs",
   "files": [
     "dist"
   ],
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@tonaljs/chord-detect": "^4.6.5",
-    "@tonaljs/chord-type": "^4.6.5",
-    "@tonaljs/collection": "^4.6.2",
-    "@tonaljs/core": "^4.6.5",
-    "@tonaljs/pcset": "^4.6.5",
-    "@tonaljs/scale-type": "^4.6.5"
+    "@tonaljs/chord-detect": "^4.7.0",
+    "@tonaljs/chord-type": "^4.7.0",
+    "@tonaljs/collection": "^4.7.0",
+    "@tonaljs/core": "^4.6.11",
+    "@tonaljs/pcset": "^4.7.0",
+    "@tonaljs/scale-type": "^4.7.0"
   },
   "author": "danigb@gmail.com",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9622ec8fa4031f0c80515d278dfa06424bf159e5"
+  "scripts": {
+    "build": "tsup index.ts --sourcemap --dts --format esm,cjs"
+  }
 }

package/dist/index.es.js

@@ -1,200 +0,0 @@
-import { detect } from '@tonaljs/chord-detect';
-export { detect } from '@tonaljs/chord-detect';
-import { get as get$1, all as all$1 } from '@tonaljs/chord-type';
-import { deprecate, tokenizeNote, note, distance, transpose as transpose$1 } from '@tonaljs/core';
-import { isSupersetOf, isSubsetOf } from '@tonaljs/pcset';
-import { all } from '@tonaljs/scale-type';
-
-const NoChord = {
-    empty: true,
-    name: "",
-    symbol: "",
-    root: "",
-    rootDegree: 0,
-    type: "",
-    tonic: null,
-    setNum: NaN,
-    quality: "Unknown",
-    chroma: "",
-    normalized: "",
-    aliases: [],
-    notes: [],
-    intervals: [],
-};
-// 6, 64, 7, 9, 11 and 13 are consider part of the chord
-// (see https://github.com/danigb/tonal/issues/55)
-const NUM_TYPES = /^(6|64|7|9|11|13)$/;
-/**
- * Tokenize a chord name. It returns an array with the tonic and chord type
- * If not tonic is found, all the name is considered the chord name.
- *
- * This function does NOT check if the chord type exists or not. It only tries
- * to split the tonic and chord type.
- *
- * @function
- * @param {string} name - the chord name
- * @return {Array} an array with [tonic, type]
- * @example
- * tokenize("Cmaj7") // => [ "C", "maj7" ]
- * tokenize("C7") // => [ "C", "7" ]
- * tokenize("mMaj7") // => [ null, "mMaj7" ]
- * tokenize("Cnonsense") // => [ null, "nonsense" ]
- */
-function tokenize(name) {
-    const [letter, acc, oct, type] = tokenizeNote(name);
-    if (letter === "") {
-        return ["", name];
-    }
-    // aug is augmented (see https://github.com/danigb/tonal/issues/55)
-    if (letter === "A" && type === "ug") {
-        return ["", "aug"];
-    }
-    // see: https://github.com/tonaljs/tonal/issues/70
-    if (!type && (oct === "4" || oct === "5")) {
-        return [letter + acc, oct];
-    }
-    if (NUM_TYPES.test(oct)) {
-        return [letter + acc, oct + type];
-    }
-    else {
-        return [letter + acc + oct, type];
-    }
-}
-/**
- * Get a Chord from a chord name.
- */
-function get(src) {
-    if (src === "") {
-        return NoChord;
-    }
-    if (Array.isArray(src) && src.length === 2) {
-        return getChord(src[1], src[0]);
-    }
-    else {
-        const [tonic, type] = tokenize(src);
-        const chord = getChord(type, tonic);
-        return chord.empty ? getChord(src) : chord;
-    }
-}
-/**
- * Get chord properties
- *
- * @param typeName - the chord type name
- * @param [tonic] - Optional tonic
- * @param [root]  - Optional root (requires a tonic)
- */
-function getChord(typeName, optionalTonic, optionalRoot) {
-    const type = get$1(typeName);
-    const tonic = note(optionalTonic || "");
-    const root = note(optionalRoot || "");
-    if (type.empty ||
-        (optionalTonic && tonic.empty) ||
-        (optionalRoot && root.empty)) {
-        return NoChord;
-    }
-    const rootInterval = distance(tonic.pc, root.pc);
-    const rootDegree = type.intervals.indexOf(rootInterval) + 1;
-    if (!root.empty && !rootDegree) {
-        return NoChord;
-    }
-    const intervals = Array.from(type.intervals);
-    for (let i = 1; i < rootDegree; i++) {
-        const num = intervals[0][0];
-        const quality = intervals[0][1];
-        const newNum = parseInt(num, 10) + 7;
-        intervals.push(`${newNum}${quality}`);
-        intervals.shift();
-    }
-    const notes = tonic.empty
-        ? []
-        : intervals.map((i) => transpose$1(tonic, i));
-    typeName = type.aliases.indexOf(typeName) !== -1 ? typeName : type.aliases[0];
-    const symbol = `${tonic.empty ? "" : tonic.pc}${typeName}${root.empty || rootDegree <= 1 ? "" : "/" + root.pc}`;
-    const name = `${optionalTonic ? tonic.pc + " " : ""}${type.name}${rootDegree > 1 && optionalRoot ? " over " + root.pc : ""}`;
-    return {
-        ...type,
-        name,
-        symbol,
-        type: type.name,
-        root: root.name,
-        intervals,
-        rootDegree,
-        tonic: tonic.name,
-        notes,
-    };
-}
-const chord = deprecate("Chord.chord", "Chord.get", get);
-/**
- * Transpose a chord name
- *
- * @param {string} chordName - the chord name
- * @return {string} the transposed chord
- *
- * @example
- * transpose('Dm7', 'P4') // => 'Gm7
- */
-function transpose(chordName, interval) {
-    const [tonic, type] = tokenize(chordName);
-    if (!tonic) {
-        return chordName;
-    }
-    return transpose$1(tonic, interval) + type;
-}
-/**
- * Get all scales where the given chord fits
- *
- * @example
- * chordScales('C7b9')
- * // => ["phrygian dominant", "flamenco", "spanish heptatonic", "half-whole diminished", "chromatic"]
- */
-function chordScales(name) {
-    const s = get(name);
-    const isChordIncluded = isSupersetOf(s.chroma);
-    return all()
-        .filter((scale) => isChordIncluded(scale.chroma))
-        .map((scale) => scale.name);
-}
-/**
- * Get all chords names that are a superset of the given one
- * (has the same notes and at least one more)
- *
- * @function
- * @example
- * extended("CMaj7")
- * // => [ 'Cmaj#4', 'Cmaj7#9#11', 'Cmaj9', 'CM7add13', 'Cmaj13', 'Cmaj9#11', 'CM13#11', 'CM7b9' ]
- */
-function extended(chordName) {
-    const s = get(chordName);
-    const isSuperset = isSupersetOf(s.chroma);
-    return all$1()
-        .filter((chord) => isSuperset(chord.chroma))
-        .map((chord) => s.tonic + chord.aliases[0]);
-}
-/**
- * Find all chords names that are a subset of the given one
- * (has less notes but all from the given chord)
- *
- * @example
- */
-function reduced(chordName) {
-    const s = get(chordName);
-    const isSubset = isSubsetOf(s.chroma);
-    return all$1()
-        .filter((chord) => isSubset(chord.chroma))
-        .map((chord) => s.tonic + chord.aliases[0]);
-}
-var index = {
-    getChord,
-    get,
-    detect,
-    chordScales,
-    extended,
-    reduced,
-    tokenize,
-    transpose,
-    // deprecate
-    chord,
-};
-
-export { chord, chordScales, index as default, extended, get, getChord, reduced, tokenize, transpose };
-//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}