@tonaljs/scale 4.6.4 → 4.6.10

package/dist/index.d.ts

@@ -1,112 +1,114 @@
-import { NoteName } from "@tonaljs/core";
-import { names as scaleTypeNames, ScaleType } from "@tonaljs/scale-type";
-declare type ScaleName = string;
-declare type ScaleNameTokens = [string, string];
-export interface Scale extends ScaleType {
-    tonic: string | null;
-    type: string;
-    notes: NoteName[];
-}
-/**
- * Given a string with a scale name and (optionally) a tonic, split
- * that components.
- *
- * It retuns an array with the form [ name, tonic ] where tonic can be a
- * note name or null and name can be any arbitrary string
- * (this function doesn"t check if that scale name exists)
- *
- * @function
- * @param {string} name - the scale name
- * @return {Array} an array [tonic, name]
- * @example
- * tokenize("C mixolydean") // => ["C", "mixolydean"]
- * tokenize("anything is valid") // => ["", "anything is valid"]
- * tokenize() // => ["", ""]
- */
-export declare function tokenize(name: ScaleName): ScaleNameTokens;
-/**
- * Get all scale names
- * @function
- */
-export declare const names: typeof scaleTypeNames;
-/**
- * Get a Scale from a scale name.
- */
-export declare function get(src: ScaleName | ScaleNameTokens): Scale;
-export declare const scale: (this: unknown, ...args: unknown[]) => Scale;
-/**
- * Get all chords that fits a given scale
- *
- * @function
- * @param {string} name - the scale name
- * @return {Array<string>} - the chord names
- *
- * @example
- * scaleChords("pentatonic") // => ["5", "64", "M", "M6", "Madd9", "Msus2"]
- */
-export declare function scaleChords(name: string): string[];
-/**
- * Get all scales names that are a superset of the given one
- * (has the same notes and at least one more)
- *
- * @function
- * @param {string} name
- * @return {Array} a list of scale names
- * @example
- * extended("major") // => ["bebop", "bebop dominant", "bebop major", "chromatic", "ichikosucho"]
- */
-export declare function extended(name: string): string[];
-/**
- * Find all scales names that are a subset of the given one
- * (has less notes but all from the given scale)
- *
- * @function
- * @param {string} name
- * @return {Array} a list of scale names
- *
- * @example
- * reduced("major") // => ["ionian pentatonic", "major pentatonic", "ritusen"]
- */
-export declare function reduced(name: string): string[];
-/**
- * Given an array of notes, return the scale: a pitch class set starting from
- * the first note of the array
- *
- * @function
- * @param {string[]} notes
- * @return {string[]} pitch classes with same tonic
- * @example
- * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => ["C"]
- * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => ["D", "F#", "A", "C#"]
- */
-export declare function scaleNotes(notes: NoteName[]): string[];
-declare type ScaleMode = [string, string];
-/**
- * Find mode names of a scale
- *
- * @function
- * @param {string} name - scale name
- * @example
- * modeNames("C pentatonic") // => [
- *   ["C", "major pentatonic"],
- *   ["D", "egyptian"],
- *   ["E", "malkos raga"],
- *   ["G", "ritusen"],
- *   ["A", "minor pentatonic"]
- * ]
- */
-export declare function modeNames(name: string): ScaleMode[];
-export declare function rangeOf(scale: string | string[]): (fromNote: string, toNote: string) => (string | undefined)[];
-declare const _default: {
-    get: typeof get;
-    names: typeof scaleTypeNames;
-    extended: typeof extended;
-    modeNames: typeof modeNames;
-    reduced: typeof reduced;
-    scaleChords: typeof scaleChords;
-    scaleNotes: typeof scaleNotes;
-    tokenize: typeof tokenize;
-    rangeOf: typeof rangeOf;
-    scale: (this: unknown, ...args: unknown[]) => Scale;
-};
-export default _default;
+import { NoteName } from '@tonaljs/core';
+import { ScaleType, names as names$1 } from '@tonaljs/scale-type';
+
+type ScaleName = string;
+type ScaleNameTokens = [string, string];
+interface Scale extends ScaleType {
+    tonic: string | null;
+    type: string;
+    notes: NoteName[];
+}
+/**
+ * Given a string with a scale name and (optionally) a tonic, split
+ * that components.
+ *
+ * It retuns an array with the form [ name, tonic ] where tonic can be a
+ * note name or null and name can be any arbitrary string
+ * (this function doesn"t check if that scale name exists)
+ *
+ * @function
+ * @param {string} name - the scale name
+ * @return {Array} an array [tonic, name]
+ * @example
+ * tokenize("C mixolydean") // => ["C", "mixolydean"]
+ * tokenize("anything is valid") // => ["", "anything is valid"]
+ * tokenize() // => ["", ""]
+ */
+declare function tokenize(name: ScaleName): ScaleNameTokens;
+/**
+ * Get all scale names
+ * @function
+ */
+declare const names: typeof names$1;
+/**
+ * Get a Scale from a scale name.
+ */
+declare function get(src: ScaleName | ScaleNameTokens): Scale;
+declare const scale: (this: unknown, ...args: unknown[]) => Scale;
+/**
+ * Get all chords that fits a given scale
+ *
+ * @function
+ * @param {string} name - the scale name
+ * @return {Array<string>} - the chord names
+ *
+ * @example
+ * scaleChords("pentatonic") // => ["5", "64", "M", "M6", "Madd9", "Msus2"]
+ */
+declare function scaleChords(name: string): string[];
+/**
+ * Get all scales names that are a superset of the given one
+ * (has the same notes and at least one more)
+ *
+ * @function
+ * @param {string} name
+ * @return {Array} a list of scale names
+ * @example
+ * extended("major") // => ["bebop", "bebop dominant", "bebop major", "chromatic", "ichikosucho"]
+ */
+declare function extended(name: string): string[];
+/**
+ * Find all scales names that are a subset of the given one
+ * (has less notes but all from the given scale)
+ *
+ * @function
+ * @param {string} name
+ * @return {Array} a list of scale names
+ *
+ * @example
+ * reduced("major") // => ["ionian pentatonic", "major pentatonic", "ritusen"]
+ */
+declare function reduced(name: string): string[];
+/**
+ * Given an array of notes, return the scale: a pitch class set starting from
+ * the first note of the array
+ *
+ * @function
+ * @param {string[]} notes
+ * @return {string[]} pitch classes with same tonic
+ * @example
+ * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => ["C"]
+ * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => ["D", "F#", "A", "C#"]
+ */
+declare function scaleNotes(notes: NoteName[]): string[];
+type ScaleMode = [string, string];
+/**
+ * Find mode names of a scale
+ *
+ * @function
+ * @param {string} name - scale name
+ * @example
+ * modeNames("C pentatonic") // => [
+ *   ["C", "major pentatonic"],
+ *   ["D", "egyptian"],
+ *   ["E", "malkos raga"],
+ *   ["G", "ritusen"],
+ *   ["A", "minor pentatonic"]
+ * ]
+ */
+declare function modeNames(name: string): ScaleMode[];
+declare function rangeOf(scale: string | string[]): (fromNote: string, toNote: string) => (string | undefined)[];
+declare const _default: {
+    get: typeof get;
+    names: typeof names$1;
+    extended: typeof extended;
+    modeNames: typeof modeNames;
+    reduced: typeof reduced;
+    scaleChords: typeof scaleChords;
+    scaleNotes: typeof scaleNotes;
+    tokenize: typeof tokenize;
+    rangeOf: typeof rangeOf;
+    scale: (this: unknown, ...args: unknown[]) => Scale;
+};
+
+export { Scale, _default as default, extended, get, modeNames, names, rangeOf, reduced, scale, scaleChords, scaleNotes, tokenize };

package/dist/index.js

@@ -1,250 +1,162 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@tonaljs/chord-type'), require('@tonaljs/collection'), require('@tonaljs/core'), require('@tonaljs/note'), require('@tonaljs/pcset'), require('@tonaljs/scale-type')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@tonaljs/chord-type', '@tonaljs/collection', '@tonaljs/core', '@tonaljs/note', '@tonaljs/pcset', '@tonaljs/scale-type'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Scale = {}, global.chordType, global.collection, global.core, global.note, global.pcset, global.scaleType));
-}(this, (function (exports, chordType, collection, core, note, 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 NoScale = {
-        empty: true,
-        name: "",
-        type: "",
-        tonic: null,
-        setNum: NaN,
-        chroma: "",
-        normalized: "",
-        aliases: [],
-        notes: [],
-        intervals: [],
-    };
-    /**
-     * Given a string with a scale name and (optionally) a tonic, split
-     * that components.
-     *
-     * It retuns an array with the form [ name, tonic ] where tonic can be a
-     * note name or null and name can be any arbitrary string
-     * (this function doesn"t check if that scale name exists)
-     *
-     * @function
-     * @param {string} name - the scale name
-     * @return {Array} an array [tonic, name]
-     * @example
-     * tokenize("C mixolydean") // => ["C", "mixolydean"]
-     * tokenize("anything is valid") // => ["", "anything is valid"]
-     * tokenize() // => ["", ""]
-     */
-    function tokenize(name) {
-        if (typeof name !== "string") {
-            return ["", ""];
-        }
-        var i = name.indexOf(" ");
-        var tonic = core.note(name.substring(0, i));
-        if (tonic.empty) {
-            var n = core.note(name);
-            return n.empty ? ["", name] : [n.name, ""];
-        }
-        var type = name.substring(tonic.name.length + 1);
-        return [tonic.name, type.length ? type : ""];
-    }
-    /**
-     * Get all scale names
-     * @function
-     */
-    var names = scaleType.names;
-    /**
-     * Get a Scale from a scale name.
-     */
-    function get(src) {
-        var tokens = Array.isArray(src) ? src : tokenize(src);
-        var tonic = core.note(tokens[0]).name;
-        var st = scaleType.get(tokens[1]);
-        if (st.empty) {
-            return NoScale;
-        }
-        var type = st.name;
-        var notes = tonic
-            ? st.intervals.map(function (i) { return core.transpose(tonic, i); })
-            : [];
-        var name = tonic ? tonic + " " + type : type;
-        return __assign(__assign({}, st), { name: name, type: type, tonic: tonic, notes: notes });
-    }
-    var scale = core.deprecate("Scale.scale", "Scale.get", get);
-    /**
-     * Get all chords that fits a given scale
-     *
-     * @function
-     * @param {string} name - the scale name
-     * @return {Array<string>} - the chord names
-     *
-     * @example
-     * scaleChords("pentatonic") // => ["5", "64", "M", "M6", "Madd9", "Msus2"]
-     */
-    function scaleChords(name) {
-        var s = get(name);
-        var inScale = pcset.isSubsetOf(s.chroma);
-        return chordType.all()
-            .filter(function (chord) { return inScale(chord.chroma); })
-            .map(function (chord) { return chord.aliases[0]; });
-    }
-    /**
-     * Get all scales names that are a superset of the given one
-     * (has the same notes and at least one more)
-     *
-     * @function
-     * @param {string} name
-     * @return {Array} a list of scale names
-     * @example
-     * extended("major") // => ["bebop", "bebop dominant", "bebop major", "chromatic", "ichikosucho"]
-     */
-    function extended(name) {
-        var s = get(name);
-        var isSuperset = pcset.isSupersetOf(s.chroma);
-        return scaleType.all()
-            .filter(function (scale) { return isSuperset(scale.chroma); })
-            .map(function (scale) { return scale.name; });
-    }
-    /**
-     * Find all scales names that are a subset of the given one
-     * (has less notes but all from the given scale)
-     *
-     * @function
-     * @param {string} name
-     * @return {Array} a list of scale names
-     *
-     * @example
-     * reduced("major") // => ["ionian pentatonic", "major pentatonic", "ritusen"]
-     */
-    function reduced(name) {
-        var isSubset = pcset.isSubsetOf(get(name).chroma);
-        return scaleType.all()
-            .filter(function (scale) { return isSubset(scale.chroma); })
-            .map(function (scale) { return scale.name; });
-    }
-    /**
-     * Given an array of notes, return the scale: a pitch class set starting from
-     * the first note of the array
-     *
-     * @function
-     * @param {string[]} notes
-     * @return {string[]} pitch classes with same tonic
-     * @example
-     * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => ["C"]
-     * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => ["D", "F#", "A", "C#"]
-     */
-    function scaleNotes(notes) {
-        var pcset = notes.map(function (n) { return core.note(n).pc; }).filter(function (x) { return x; });
-        var tonic = pcset[0];
-        var scale = note.sortedUniqNames(pcset);
-        return collection.rotate(scale.indexOf(tonic), scale);
-    }
-    /**
-     * Find mode names of a scale
-     *
-     * @function
-     * @param {string} name - scale name
-     * @example
-     * modeNames("C pentatonic") // => [
-     *   ["C", "major pentatonic"],
-     *   ["D", "egyptian"],
-     *   ["E", "malkos raga"],
-     *   ["G", "ritusen"],
-     *   ["A", "minor pentatonic"]
-     * ]
-     */
-    function modeNames(name) {
-        var s = get(name);
-        if (s.empty) {
-            return [];
-        }
-        var tonics = s.tonic ? s.notes : s.intervals;
-        return pcset.modes(s.chroma)
-            .map(function (chroma, i) {
-            var modeName = get(chroma).name;
-            return modeName ? [tonics[i], modeName] : ["", ""];
-        })
-            .filter(function (x) { return x[0]; });
-    }
-    function getNoteNameOf(scale) {
-        var names = Array.isArray(scale) ? scaleNotes(scale) : get(scale).notes;
-        var chromas = names.map(function (name) { return core.note(name).chroma; });
-        return function (noteOrMidi) {
-            var currNote = typeof noteOrMidi === "number"
-                ? core.note(note.fromMidi(noteOrMidi))
-                : core.note(noteOrMidi);
-            var height = currNote.height;
-            if (height === undefined)
-                return undefined;
-            var chroma = height % 12;
-            var position = chromas.indexOf(chroma);
-            if (position === -1)
-                return undefined;
-            return note.enharmonic(currNote.name, names[position]);
-        };
-    }
-    function rangeOf(scale) {
-        var getName = getNoteNameOf(scale);
-        return function (fromNote, toNote) {
-            var from = core.note(fromNote).height;
-            var to = core.note(toNote).height;
-            if (from === undefined || to === undefined)
-                return [];
-            return collection.range(from, to)
-                .map(getName)
-                .filter(function (x) { return x; });
-        };
-    }
-    var index = {
-        get: get,
-        names: names,
-        extended: extended,
-        modeNames: modeNames,
-        reduced: reduced,
-        scaleChords: scaleChords,
-        scaleNotes: scaleNotes,
-        tokenize: tokenize,
-        rangeOf: rangeOf,
-        // deprecated
-        scale: scale,
-    };
-
-    exports['default'] = index;
-    exports.extended = extended;
-    exports.get = get;
-    exports.modeNames = modeNames;
-    exports.names = names;
-    exports.rangeOf = rangeOf;
-    exports.reduced = reduced;
-    exports.scale = scale;
-    exports.scaleChords = scaleChords;
-    exports.scaleNotes = scaleNotes;
-    exports.tokenize = tokenize;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
-//# sourceMappingURL=index.js.map
+// index.ts
+var scale_exports = {};
+__export(scale_exports, {
+  default: () => scale_default,
+  extended: () => extended,
+  get: () => get,
+  modeNames: () => modeNames,
+  names: () => names,
+  rangeOf: () => rangeOf,
+  reduced: () => reduced,
+  scale: () => scale,
+  scaleChords: () => scaleChords,
+  scaleNotes: () => scaleNotes,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(scale_exports);
+var import_chord_type = require("@tonaljs/chord-type");
+var import_collection = require("@tonaljs/collection");
+var import_core = require("@tonaljs/core");
+var import_note = require("@tonaljs/note");
+var import_pcset = require("@tonaljs/pcset");
+var import_scale_type = require("@tonaljs/scale-type");
+var NoScale = {
+  empty: true,
+  name: "",
+  type: "",
+  tonic: null,
+  setNum: NaN,
+  chroma: "",
+  normalized: "",
+  aliases: [],
+  notes: [],
+  intervals: []
+};
+function tokenize(name) {
+  if (typeof name !== "string") {
+    return ["", ""];
+  }
+  const i = name.indexOf(" ");
+  const tonic = (0, import_core.note)(name.substring(0, i));
+  if (tonic.empty) {
+    const n = (0, import_core.note)(name);
+    return n.empty ? ["", name] : [n.name, ""];
+  }
+  const type = name.substring(tonic.name.length + 1);
+  return [tonic.name, type.length ? type : ""];
+}
+var names = import_scale_type.names;
+function get(src) {
+  const tokens = Array.isArray(src) ? src : tokenize(src);
+  const tonic = (0, import_core.note)(tokens[0]).name;
+  const st = (0, import_scale_type.get)(tokens[1]);
+  if (st.empty) {
+    return NoScale;
+  }
+  const type = st.name;
+  const notes = tonic ? st.intervals.map((i) => (0, import_core.transpose)(tonic, i)) : [];
+  const name = tonic ? tonic + " " + type : type;
+  return { ...st, name, type, tonic, notes };
+}
+var scale = (0, import_core.deprecate)("Scale.scale", "Scale.get", get);
+function scaleChords(name) {
+  const s = get(name);
+  const inScale = (0, import_pcset.isSubsetOf)(s.chroma);
+  return (0, import_chord_type.all)().filter((chord) => inScale(chord.chroma)).map((chord) => chord.aliases[0]);
+}
+function extended(name) {
+  const s = get(name);
+  const isSuperset = (0, import_pcset.isSupersetOf)(s.chroma);
+  return (0, import_scale_type.all)().filter((scale2) => isSuperset(scale2.chroma)).map((scale2) => scale2.name);
+}
+function reduced(name) {
+  const isSubset = (0, import_pcset.isSubsetOf)(get(name).chroma);
+  return (0, import_scale_type.all)().filter((scale2) => isSubset(scale2.chroma)).map((scale2) => scale2.name);
+}
+function scaleNotes(notes) {
+  const pcset = notes.map((n) => (0, import_core.note)(n).pc).filter((x) => x);
+  const tonic = pcset[0];
+  const scale2 = (0, import_note.sortedUniqNames)(pcset);
+  return (0, import_collection.rotate)(scale2.indexOf(tonic), scale2);
+}
+function modeNames(name) {
+  const s = get(name);
+  if (s.empty) {
+    return [];
+  }
+  const tonics = s.tonic ? s.notes : s.intervals;
+  return (0, import_pcset.modes)(s.chroma).map((chroma, i) => {
+    const modeName = get(chroma).name;
+    return modeName ? [tonics[i], modeName] : ["", ""];
+  }).filter((x) => x[0]);
+}
+function getNoteNameOf(scale2) {
+  const names2 = Array.isArray(scale2) ? scaleNotes(scale2) : get(scale2).notes;
+  const chromas = names2.map((name) => (0, import_core.note)(name).chroma);
+  return (noteOrMidi) => {
+    const currNote = typeof noteOrMidi === "number" ? (0, import_core.note)((0, import_note.fromMidi)(noteOrMidi)) : (0, import_core.note)(noteOrMidi);
+    const height = currNote.height;
+    if (height === void 0)
+      return void 0;
+    const chroma = height % 12;
+    const position = chromas.indexOf(chroma);
+    if (position === -1)
+      return void 0;
+    return (0, import_note.enharmonic)(currNote.name, names2[position]);
+  };
+}
+function rangeOf(scale2) {
+  const getName = getNoteNameOf(scale2);
+  return (fromNote, toNote) => {
+    const from = (0, import_core.note)(fromNote).height;
+    const to = (0, import_core.note)(toNote).height;
+    if (from === void 0 || to === void 0)
+      return [];
+    return (0, import_collection.range)(from, to).map(getName).filter((x) => x);
+  };
+}
+var scale_default = {
+  get,
+  names,
+  extended,
+  modeNames,
+  reduced,
+  scaleChords,
+  scaleNotes,
+  tokenize,
+  rangeOf,
+  scale
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extended,
+  get,
+  modeNames,
+  names,
+  rangeOf,
+  reduced,
+  scale,
+  scaleChords,
+  scaleNotes,
+  tokenize
+});
+//# 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":["/**\n * References:\n * - https://www.researchgate.net/publication/327567188_An_Algorithm_for_Spelling_the_Pitches_of_Any_Musical_Scale\n * @module scale\n */\nimport { all as chordTypes } from \"@tonaljs/chord-type\";\nimport { rotate, range as nums } from \"@tonaljs/collection\";\nimport { deprecate, note, NoteName, transpose } from \"@tonaljs/core\";\nimport { sortedUniqNames, fromMidi, enharmonic } from \"@tonaljs/note\";\nimport { isSubsetOf, isSupersetOf, modes } from \"@tonaljs/pcset\";\nimport {\n  all as scaleTypes,\n  get as getScaleType,\n  names as scaleTypeNames,\n  ScaleType,\n} from \"@tonaljs/scale-type\";\n\ntype ScaleName = string;\ntype ScaleNameTokens = [string, string]; // [TONIC, SCALE TYPE]\n\nexport interface Scale extends ScaleType {\n  tonic: string | null;\n  type: string;\n  notes: NoteName[];\n}\n\nconst NoScale: Scale = {\n  empty: true,\n  name: \"\",\n  type: \"\",\n  tonic: null,\n  setNum: NaN,\n  chroma: \"\",\n  normalized: \"\",\n  aliases: [],\n  notes: [],\n  intervals: [],\n};\n\n/**\n * Given a string with a scale name and (optionally) a tonic, split\n * that components.\n *\n * It retuns an array with the form [ name, tonic ] where tonic can be a\n * note name or null and name can be any arbitrary string\n * (this function doesn\"t check if that scale name exists)\n *\n * @function\n * @param {string} name - the scale name\n * @return {Array} an array [tonic, name]\n * @example\n * tokenize(\"C mixolydean\") // => [\"C\", \"mixolydean\"]\n * tokenize(\"anything is valid\") // => [\"\", \"anything is valid\"]\n * tokenize() // => [\"\", \"\"]\n */\nexport function tokenize(name: ScaleName): ScaleNameTokens {\n  if (typeof name !== \"string\") {\n    return [\"\", \"\"];\n  }\n  const i = name.indexOf(\" \");\n  const tonic = note(name.substring(0, i));\n  if (tonic.empty) {\n    const n = note(name);\n    return n.empty ? [\"\", name] : [n.name, \"\"];\n  }\n\n  const type = name.substring(tonic.name.length + 1);\n  return [tonic.name, type.length ? type : \"\"];\n}\n\n/**\n * Get all scale names\n * @function\n */\nexport const names = scaleTypeNames;\n\n/**\n * Get a Scale from a scale name.\n */\nexport function get(src: ScaleName | ScaleNameTokens): Scale {\n  const tokens = Array.isArray(src) ? src : tokenize(src);\n  const tonic = note(tokens[0]).name;\n  const st = getScaleType(tokens[1]);\n  if (st.empty) {\n    return NoScale;\n  }\n\n  const type = st.name;\n  const notes: string[] = tonic\n    ? st.intervals.map((i) => transpose(tonic, i))\n    : [];\n\n  const name = tonic ? tonic + \" \" + type : type;\n\n  return { ...st, name, type, tonic, notes };\n}\n\nexport const scale = deprecate(\"Scale.scale\", \"Scale.get\", get);\n\n/**\n * Get all chords that fits a given scale\n *\n * @function\n * @param {string} name - the scale name\n * @return {Array<string>} - the chord names\n *\n * @example\n * scaleChords(\"pentatonic\") // => [\"5\", \"64\", \"M\", \"M6\", \"Madd9\", \"Msus2\"]\n */\nexport function scaleChords(name: string): string[] {\n  const s = get(name);\n  const inScale = isSubsetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => inScale(chord.chroma))\n    .map((chord) => chord.aliases[0]);\n}\n/**\n * Get all scales names that are a superset of the given one\n * (has the same notes and at least one more)\n *\n * @function\n * @param {string} name\n * @return {Array} a list of scale names\n * @example\n * extended(\"major\") // => [\"bebop\", \"bebop dominant\", \"bebop major\", \"chromatic\", \"ichikosucho\"]\n */\nexport function extended(name: string): string[] {\n  const s = get(name);\n  const isSuperset = isSupersetOf(s.chroma);\n  return scaleTypes()\n    .filter((scale) => isSuperset(scale.chroma))\n    .map((scale) => scale.name);\n}\n\n/**\n * Find all scales names that are a subset of the given one\n * (has less notes but all from the given scale)\n *\n * @function\n * @param {string} name\n * @return {Array} a list of scale names\n *\n * @example\n * reduced(\"major\") // => [\"ionian pentatonic\", \"major pentatonic\", \"ritusen\"]\n */\nexport function reduced(name: string): string[] {\n  const isSubset = isSubsetOf(get(name).chroma);\n  return scaleTypes()\n    .filter((scale) => isSubset(scale.chroma))\n    .map((scale) => scale.name);\n}\n\n/**\n * Given an array of notes, return the scale: a pitch class set starting from\n * the first note of the array\n *\n * @function\n * @param {string[]} notes\n * @return {string[]} pitch classes with same tonic\n * @example\n * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => [\"C\"]\n * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => [\"D\", \"F#\", \"A\", \"C#\"]\n */\nexport function scaleNotes(notes: NoteName[]) {\n  const pcset: string[] = notes.map((n) => note(n).pc).filter((x) => x);\n  const tonic = pcset[0];\n  const scale = sortedUniqNames(pcset);\n  return rotate(scale.indexOf(tonic), scale);\n}\n\ntype ScaleMode = [string, string];\n/**\n * Find mode names of a scale\n *\n * @function\n * @param {string} name - scale name\n * @example\n * modeNames(\"C pentatonic\") // => [\n *   [\"C\", \"major pentatonic\"],\n *   [\"D\", \"egyptian\"],\n *   [\"E\", \"malkos raga\"],\n *   [\"G\", \"ritusen\"],\n *   [\"A\", \"minor pentatonic\"]\n * ]\n */\nexport function modeNames(name: string): ScaleMode[] {\n  const s = get(name);\n  if (s.empty) {\n    return [];\n  }\n\n  const tonics = s.tonic ? s.notes : s.intervals;\n  return modes(s.chroma)\n    .map((chroma: string, i: number): ScaleMode => {\n      const modeName = get(chroma).name;\n      return modeName ? [tonics[i], modeName] : [\"\", \"\"];\n    })\n    .filter((x) => x[0]);\n}\n\nfunction getNoteNameOf(scale: string | string[]) {\n  const names = Array.isArray(scale) ? scaleNotes(scale) : get(scale).notes;\n  const chromas = names.map((name) => note(name).chroma);\n\n  return (noteOrMidi: string | number): string | undefined => {\n    const currNote =\n      typeof noteOrMidi === \"number\"\n        ? note(fromMidi(noteOrMidi))\n        : note(noteOrMidi);\n    const height = currNote.height;\n\n    if (height === undefined) return undefined;\n    const chroma = height % 12;\n    const position = chromas.indexOf(chroma);\n    if (position === -1) return undefined;\n    return enharmonic(currNote.name, names[position]);\n  };\n}\n\nexport function rangeOf(scale: string | string[]) {\n  const getName = getNoteNameOf(scale);\n  return (fromNote: string, toNote: string) => {\n    const from = note(fromNote).height;\n    const to = note(toNote).height;\n    if (from === undefined || to === undefined) return [];\n\n    return nums(from, to)\n      .map(getName)\n      .filter((x) => x);\n  };\n}\n\nexport default {\n  get,\n  names,\n  extended,\n  modeNames,\n  reduced,\n  scaleChords,\n  scaleNotes,\n  tokenize,\n  rangeOf,\n  // deprecated\n  scale,\n};\n"],"mappings":"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","names":["scaleTypeNames","getScaleType","chordTypes","scaleTypes","scale","names","nums"]}

package/dist/index.mjs

@@ -0,0 +1,132 @@
+// index.ts
+import { all as chordTypes } from "@tonaljs/chord-type";
+import { rotate, range as nums } from "@tonaljs/collection";
+import { deprecate, note, transpose } from "@tonaljs/core";
+import { sortedUniqNames, fromMidi, enharmonic } from "@tonaljs/note";
+import { isSubsetOf, isSupersetOf, modes } from "@tonaljs/pcset";
+import {
+  all as scaleTypes,
+  get as getScaleType,
+  names as scaleTypeNames
+} from "@tonaljs/scale-type";
+var NoScale = {
+  empty: true,
+  name: "",
+  type: "",
+  tonic: null,
+  setNum: NaN,
+  chroma: "",
+  normalized: "",
+  aliases: [],
+  notes: [],
+  intervals: []
+};
+function tokenize(name) {
+  if (typeof name !== "string") {
+    return ["", ""];
+  }
+  const i = name.indexOf(" ");
+  const tonic = note(name.substring(0, i));
+  if (tonic.empty) {
+    const n = note(name);
+    return n.empty ? ["", name] : [n.name, ""];
+  }
+  const type = name.substring(tonic.name.length + 1);
+  return [tonic.name, type.length ? type : ""];
+}
+var names = scaleTypeNames;
+function get(src) {
+  const tokens = Array.isArray(src) ? src : tokenize(src);
+  const tonic = note(tokens[0]).name;
+  const st = getScaleType(tokens[1]);
+  if (st.empty) {
+    return NoScale;
+  }
+  const type = st.name;
+  const notes = tonic ? st.intervals.map((i) => transpose(tonic, i)) : [];
+  const name = tonic ? tonic + " " + type : type;
+  return { ...st, name, type, tonic, notes };
+}
+var scale = deprecate("Scale.scale", "Scale.get", get);
+function scaleChords(name) {
+  const s = get(name);
+  const inScale = isSubsetOf(s.chroma);
+  return chordTypes().filter((chord) => inScale(chord.chroma)).map((chord) => chord.aliases[0]);
+}
+function extended(name) {
+  const s = get(name);
+  const isSuperset = isSupersetOf(s.chroma);
+  return scaleTypes().filter((scale2) => isSuperset(scale2.chroma)).map((scale2) => scale2.name);
+}
+function reduced(name) {
+  const isSubset = isSubsetOf(get(name).chroma);
+  return scaleTypes().filter((scale2) => isSubset(scale2.chroma)).map((scale2) => scale2.name);
+}
+function scaleNotes(notes) {
+  const pcset = notes.map((n) => note(n).pc).filter((x) => x);
+  const tonic = pcset[0];
+  const scale2 = sortedUniqNames(pcset);
+  return rotate(scale2.indexOf(tonic), scale2);
+}
+function modeNames(name) {
+  const s = get(name);
+  if (s.empty) {
+    return [];
+  }
+  const tonics = s.tonic ? s.notes : s.intervals;
+  return modes(s.chroma).map((chroma, i) => {
+    const modeName = get(chroma).name;
+    return modeName ? [tonics[i], modeName] : ["", ""];
+  }).filter((x) => x[0]);
+}
+function getNoteNameOf(scale2) {
+  const names2 = Array.isArray(scale2) ? scaleNotes(scale2) : get(scale2).notes;
+  const chromas = names2.map((name) => note(name).chroma);
+  return (noteOrMidi) => {
+    const currNote = typeof noteOrMidi === "number" ? note(fromMidi(noteOrMidi)) : note(noteOrMidi);
+    const height = currNote.height;
+    if (height === void 0)
+      return void 0;
+    const chroma = height % 12;
+    const position = chromas.indexOf(chroma);
+    if (position === -1)
+      return void 0;
+    return enharmonic(currNote.name, names2[position]);
+  };
+}
+function rangeOf(scale2) {
+  const getName = getNoteNameOf(scale2);
+  return (fromNote, toNote) => {
+    const from = note(fromNote).height;
+    const to = note(toNote).height;
+    if (from === void 0 || to === void 0)
+      return [];
+    return nums(from, to).map(getName).filter((x) => x);
+  };
+}
+var scale_default = {
+  get,
+  names,
+  extended,
+  modeNames,
+  reduced,
+  scaleChords,
+  scaleNotes,
+  tokenize,
+  rangeOf,
+  scale
+};
+export {
+  scale_default as default,
+  extended,
+  get,
+  modeNames,
+  names,
+  rangeOf,
+  reduced,
+  scale,
+  scaleChords,
+  scaleNotes,
+  tokenize
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\n * References:\n * - https://www.researchgate.net/publication/327567188_An_Algorithm_for_Spelling_the_Pitches_of_Any_Musical_Scale\n * @module scale\n */\nimport { all as chordTypes } from \"@tonaljs/chord-type\";\nimport { rotate, range as nums } from \"@tonaljs/collection\";\nimport { deprecate, note, NoteName, transpose } from \"@tonaljs/core\";\nimport { sortedUniqNames, fromMidi, enharmonic } from \"@tonaljs/note\";\nimport { isSubsetOf, isSupersetOf, modes } from \"@tonaljs/pcset\";\nimport {\n  all as scaleTypes,\n  get as getScaleType,\n  names as scaleTypeNames,\n  ScaleType,\n} from \"@tonaljs/scale-type\";\n\ntype ScaleName = string;\ntype ScaleNameTokens = [string, string]; // [TONIC, SCALE TYPE]\n\nexport interface Scale extends ScaleType {\n  tonic: string | null;\n  type: string;\n  notes: NoteName[];\n}\n\nconst NoScale: Scale = {\n  empty: true,\n  name: \"\",\n  type: \"\",\n  tonic: null,\n  setNum: NaN,\n  chroma: \"\",\n  normalized: \"\",\n  aliases: [],\n  notes: [],\n  intervals: [],\n};\n\n/**\n * Given a string with a scale name and (optionally) a tonic, split\n * that components.\n *\n * It retuns an array with the form [ name, tonic ] where tonic can be a\n * note name or null and name can be any arbitrary string\n * (this function doesn\"t check if that scale name exists)\n *\n * @function\n * @param {string} name - the scale name\n * @return {Array} an array [tonic, name]\n * @example\n * tokenize(\"C mixolydean\") // => [\"C\", \"mixolydean\"]\n * tokenize(\"anything is valid\") // => [\"\", \"anything is valid\"]\n * tokenize() // => [\"\", \"\"]\n */\nexport function tokenize(name: ScaleName): ScaleNameTokens {\n  if (typeof name !== \"string\") {\n    return [\"\", \"\"];\n  }\n  const i = name.indexOf(\" \");\n  const tonic = note(name.substring(0, i));\n  if (tonic.empty) {\n    const n = note(name);\n    return n.empty ? [\"\", name] : [n.name, \"\"];\n  }\n\n  const type = name.substring(tonic.name.length + 1);\n  return [tonic.name, type.length ? type : \"\"];\n}\n\n/**\n * Get all scale names\n * @function\n */\nexport const names = scaleTypeNames;\n\n/**\n * Get a Scale from a scale name.\n */\nexport function get(src: ScaleName | ScaleNameTokens): Scale {\n  const tokens = Array.isArray(src) ? src : tokenize(src);\n  const tonic = note(tokens[0]).name;\n  const st = getScaleType(tokens[1]);\n  if (st.empty) {\n    return NoScale;\n  }\n\n  const type = st.name;\n  const notes: string[] = tonic\n    ? st.intervals.map((i) => transpose(tonic, i))\n    : [];\n\n  const name = tonic ? tonic + \" \" + type : type;\n\n  return { ...st, name, type, tonic, notes };\n}\n\nexport const scale = deprecate(\"Scale.scale\", \"Scale.get\", get);\n\n/**\n * Get all chords that fits a given scale\n *\n * @function\n * @param {string} name - the scale name\n * @return {Array<string>} - the chord names\n *\n * @example\n * scaleChords(\"pentatonic\") // => [\"5\", \"64\", \"M\", \"M6\", \"Madd9\", \"Msus2\"]\n */\nexport function scaleChords(name: string): string[] {\n  const s = get(name);\n  const inScale = isSubsetOf(s.chroma);\n  return chordTypes()\n    .filter((chord) => inScale(chord.chroma))\n    .map((chord) => chord.aliases[0]);\n}\n/**\n * Get all scales names that are a superset of the given one\n * (has the same notes and at least one more)\n *\n * @function\n * @param {string} name\n * @return {Array} a list of scale names\n * @example\n * extended(\"major\") // => [\"bebop\", \"bebop dominant\", \"bebop major\", \"chromatic\", \"ichikosucho\"]\n */\nexport function extended(name: string): string[] {\n  const s = get(name);\n  const isSuperset = isSupersetOf(s.chroma);\n  return scaleTypes()\n    .filter((scale) => isSuperset(scale.chroma))\n    .map((scale) => scale.name);\n}\n\n/**\n * Find all scales names that are a subset of the given one\n * (has less notes but all from the given scale)\n *\n * @function\n * @param {string} name\n * @return {Array} a list of scale names\n *\n * @example\n * reduced(\"major\") // => [\"ionian pentatonic\", \"major pentatonic\", \"ritusen\"]\n */\nexport function reduced(name: string): string[] {\n  const isSubset = isSubsetOf(get(name).chroma);\n  return scaleTypes()\n    .filter((scale) => isSubset(scale.chroma))\n    .map((scale) => scale.name);\n}\n\n/**\n * Given an array of notes, return the scale: a pitch class set starting from\n * the first note of the array\n *\n * @function\n * @param {string[]} notes\n * @return {string[]} pitch classes with same tonic\n * @example\n * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => [\"C\"]\n * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => [\"D\", \"F#\", \"A\", \"C#\"]\n */\nexport function scaleNotes(notes: NoteName[]) {\n  const pcset: string[] = notes.map((n) => note(n).pc).filter((x) => x);\n  const tonic = pcset[0];\n  const scale = sortedUniqNames(pcset);\n  return rotate(scale.indexOf(tonic), scale);\n}\n\ntype ScaleMode = [string, string];\n/**\n * Find mode names of a scale\n *\n * @function\n * @param {string} name - scale name\n * @example\n * modeNames(\"C pentatonic\") // => [\n *   [\"C\", \"major pentatonic\"],\n *   [\"D\", \"egyptian\"],\n *   [\"E\", \"malkos raga\"],\n *   [\"G\", \"ritusen\"],\n *   [\"A\", \"minor pentatonic\"]\n * ]\n */\nexport function modeNames(name: string): ScaleMode[] {\n  const s = get(name);\n  if (s.empty) {\n    return [];\n  }\n\n  const tonics = s.tonic ? s.notes : s.intervals;\n  return modes(s.chroma)\n    .map((chroma: string, i: number): ScaleMode => {\n      const modeName = get(chroma).name;\n      return modeName ? [tonics[i], modeName] : [\"\", \"\"];\n    })\n    .filter((x) => x[0]);\n}\n\nfunction getNoteNameOf(scale: string | string[]) {\n  const names = Array.isArray(scale) ? scaleNotes(scale) : get(scale).notes;\n  const chromas = names.map((name) => note(name).chroma);\n\n  return (noteOrMidi: string | number): string | undefined => {\n    const currNote =\n      typeof noteOrMidi === \"number\"\n        ? note(fromMidi(noteOrMidi))\n        : note(noteOrMidi);\n    const height = currNote.height;\n\n    if (height === undefined) return undefined;\n    const chroma = height % 12;\n    const position = chromas.indexOf(chroma);\n    if (position === -1) return undefined;\n    return enharmonic(currNote.name, names[position]);\n  };\n}\n\nexport function rangeOf(scale: string | string[]) {\n  const getName = getNoteNameOf(scale);\n  return (fromNote: string, toNote: string) => {\n    const from = note(fromNote).height;\n    const to = note(toNote).height;\n    if (from === undefined || to === undefined) return [];\n\n    return nums(from, to)\n      .map(getName)\n      .filter((x) => x);\n  };\n}\n\nexport default {\n  get,\n  names,\n  extended,\n  modeNames,\n  reduced,\n  scaleChords,\n  scaleNotes,\n  tokenize,\n  rangeOf,\n  // deprecated\n  scale,\n};\n"],"mappings":"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","names":["scale","names"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonaljs/scale",
-  "version": "4.6.4",
+  "version": "4.6.10",
   "description": "Musical scales and its relations",
   "keywords": [
     "scale",
@@ -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-type": "^4.6.2",
-    "@tonaljs/collection": "^4.6.2",
-    "@tonaljs/core": "^4.6.2",
-    "@tonaljs/note": "^4.6.2",
-    "@tonaljs/pcset": "^4.6.2",
-    "@tonaljs/scale-type": "^4.6.4"
+    "@tonaljs/chord-type": "^4.6.10",
+    "@tonaljs/collection": "^4.6.10",
+    "@tonaljs/core": "^4.6.10",
+    "@tonaljs/note": "^4.6.10",
+    "@tonaljs/pcset": "^4.6.10",
+    "@tonaljs/scale-type": "^4.6.10"
   },
   "author": "danigb@gmail.com",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7bb82dd7ce7d97b6a8768041fc4abceeb2542211"
+  "scripts": {
+    "build": "tsup index.ts --sourcemap --dts --format esm,cjs"
+  }
 }

package/dist/index.es.js

@@ -1,216 +0,0 @@
-import { all } from '@tonaljs/chord-type';
-import { rotate, range } from '@tonaljs/collection';
-import { deprecate, note, transpose } from '@tonaljs/core';
-import { sortedUniqNames, fromMidi, enharmonic } from '@tonaljs/note';
-import { isSubsetOf, isSupersetOf, modes } from '@tonaljs/pcset';
-import { names as names$1, get as get$1, all as all$1 } from '@tonaljs/scale-type';
-
-/**
- * References:
- * - https://www.researchgate.net/publication/327567188_An_Algorithm_for_Spelling_the_Pitches_of_Any_Musical_Scale
- * @module scale
- */
-const NoScale = {
-    empty: true,
-    name: "",
-    type: "",
-    tonic: null,
-    setNum: NaN,
-    chroma: "",
-    normalized: "",
-    aliases: [],
-    notes: [],
-    intervals: [],
-};
-/**
- * Given a string with a scale name and (optionally) a tonic, split
- * that components.
- *
- * It retuns an array with the form [ name, tonic ] where tonic can be a
- * note name or null and name can be any arbitrary string
- * (this function doesn"t check if that scale name exists)
- *
- * @function
- * @param {string} name - the scale name
- * @return {Array} an array [tonic, name]
- * @example
- * tokenize("C mixolydean") // => ["C", "mixolydean"]
- * tokenize("anything is valid") // => ["", "anything is valid"]
- * tokenize() // => ["", ""]
- */
-function tokenize(name) {
-    if (typeof name !== "string") {
-        return ["", ""];
-    }
-    const i = name.indexOf(" ");
-    const tonic = note(name.substring(0, i));
-    if (tonic.empty) {
-        const n = note(name);
-        return n.empty ? ["", name] : [n.name, ""];
-    }
-    const type = name.substring(tonic.name.length + 1);
-    return [tonic.name, type.length ? type : ""];
-}
-/**
- * Get all scale names
- * @function
- */
-const names = names$1;
-/**
- * Get a Scale from a scale name.
- */
-function get(src) {
-    const tokens = Array.isArray(src) ? src : tokenize(src);
-    const tonic = note(tokens[0]).name;
-    const st = get$1(tokens[1]);
-    if (st.empty) {
-        return NoScale;
-    }
-    const type = st.name;
-    const notes = tonic
-        ? st.intervals.map((i) => transpose(tonic, i))
-        : [];
-    const name = tonic ? tonic + " " + type : type;
-    return { ...st, name, type, tonic, notes };
-}
-const scale = deprecate("Scale.scale", "Scale.get", get);
-/**
- * Get all chords that fits a given scale
- *
- * @function
- * @param {string} name - the scale name
- * @return {Array<string>} - the chord names
- *
- * @example
- * scaleChords("pentatonic") // => ["5", "64", "M", "M6", "Madd9", "Msus2"]
- */
-function scaleChords(name) {
-    const s = get(name);
-    const inScale = isSubsetOf(s.chroma);
-    return all()
-        .filter((chord) => inScale(chord.chroma))
-        .map((chord) => chord.aliases[0]);
-}
-/**
- * Get all scales names that are a superset of the given one
- * (has the same notes and at least one more)
- *
- * @function
- * @param {string} name
- * @return {Array} a list of scale names
- * @example
- * extended("major") // => ["bebop", "bebop dominant", "bebop major", "chromatic", "ichikosucho"]
- */
-function extended(name) {
-    const s = get(name);
-    const isSuperset = isSupersetOf(s.chroma);
-    return all$1()
-        .filter((scale) => isSuperset(scale.chroma))
-        .map((scale) => scale.name);
-}
-/**
- * Find all scales names that are a subset of the given one
- * (has less notes but all from the given scale)
- *
- * @function
- * @param {string} name
- * @return {Array} a list of scale names
- *
- * @example
- * reduced("major") // => ["ionian pentatonic", "major pentatonic", "ritusen"]
- */
-function reduced(name) {
-    const isSubset = isSubsetOf(get(name).chroma);
-    return all$1()
-        .filter((scale) => isSubset(scale.chroma))
-        .map((scale) => scale.name);
-}
-/**
- * Given an array of notes, return the scale: a pitch class set starting from
- * the first note of the array
- *
- * @function
- * @param {string[]} notes
- * @return {string[]} pitch classes with same tonic
- * @example
- * scaleNotes(['C4', 'c3', 'C5', 'C4', 'c4']) // => ["C"]
- * scaleNotes(['D4', 'c#5', 'A5', 'F#6']) // => ["D", "F#", "A", "C#"]
- */
-function scaleNotes(notes) {
-    const pcset = notes.map((n) => note(n).pc).filter((x) => x);
-    const tonic = pcset[0];
-    const scale = sortedUniqNames(pcset);
-    return rotate(scale.indexOf(tonic), scale);
-}
-/**
- * Find mode names of a scale
- *
- * @function
- * @param {string} name - scale name
- * @example
- * modeNames("C pentatonic") // => [
- *   ["C", "major pentatonic"],
- *   ["D", "egyptian"],
- *   ["E", "malkos raga"],
- *   ["G", "ritusen"],
- *   ["A", "minor pentatonic"]
- * ]
- */
-function modeNames(name) {
-    const s = get(name);
-    if (s.empty) {
-        return [];
-    }
-    const tonics = s.tonic ? s.notes : s.intervals;
-    return modes(s.chroma)
-        .map((chroma, i) => {
-        const modeName = get(chroma).name;
-        return modeName ? [tonics[i], modeName] : ["", ""];
-    })
-        .filter((x) => x[0]);
-}
-function getNoteNameOf(scale) {
-    const names = Array.isArray(scale) ? scaleNotes(scale) : get(scale).notes;
-    const chromas = names.map((name) => note(name).chroma);
-    return (noteOrMidi) => {
-        const currNote = typeof noteOrMidi === "number"
-            ? note(fromMidi(noteOrMidi))
-            : note(noteOrMidi);
-        const height = currNote.height;
-        if (height === undefined)
-            return undefined;
-        const chroma = height % 12;
-        const position = chromas.indexOf(chroma);
-        if (position === -1)
-            return undefined;
-        return enharmonic(currNote.name, names[position]);
-    };
-}
-function rangeOf(scale) {
-    const getName = getNoteNameOf(scale);
-    return (fromNote, toNote) => {
-        const from = note(fromNote).height;
-        const to = note(toNote).height;
-        if (from === undefined || to === undefined)
-            return [];
-        return range(from, to)
-            .map(getName)
-            .filter((x) => x);
-    };
-}
-var index = {
-    get,
-    names,
-    extended,
-    modeNames,
-    reduced,
-    scaleChords,
-    scaleNotes,
-    tokenize,
-    rangeOf,
-    // deprecated
-    scale,
-};
-
-export { index as default, extended, get, modeNames, names, rangeOf, reduced, scale, scaleChords, scaleNotes, tokenize };
-//# sourceMappingURL=index.es.js.map

package/dist/index.es.js.map

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