@tonaljs/note/dist/index.js

Parse and manipulate music notes in scientific notation

"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 name2 in all)
    __defProp(target, name2, { get: all[name2], 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);

// index.ts
var index_exports = {};
__export(index_exports, {
  accidentals: () => accidentals,
  ascending: () => ascending,
  chroma: () => chroma,
  default: () => index_default,
  descending: () => descending,
  distance: () => distance,
  enharmonic: () => enharmonic,
  freq: () => freq,
  fromFreq: () => fromFreq,
  fromFreqSharps: () => fromFreqSharps,
  fromMidi: () => fromMidi,
  fromMidiSharps: () => fromMidiSharps,
  get: () => get,
  midi: () => midi,
  name: () => name,
  names: () => names,
  octave: () => octave,
  pitchClass: () => pitchClass,
  simplify: () => simplify,
  sortedNames: () => sortedNames,
  sortedUniqNames: () => sortedUniqNames,
  tr: () => tr,
  trBy: () => trBy,
  trFifths: () => trFifths,
  trFrom: () => trFrom,
  transpose: () => transpose,
  transposeBy: () => transposeBy,
  transposeFifths: () => transposeFifths,
  transposeFrom: () => transposeFrom,
  transposeOctaves: () => transposeOctaves
});
module.exports = __toCommonJS(index_exports);
var import_midi = require("@tonaljs/midi");
var import_pitch_distance = require("@tonaljs/pitch-distance");
var import_pitch_note = require("@tonaljs/pitch-note");
var NAMES = ["C", "D", "E", "F", "G", "A", "B"];
var toName = (n) => n.name;
var onlyNotes = (array) => array.map(import_pitch_note.note).filter((n) => !n.empty);
function names(array) {
  if (array === void 0) {
    return NAMES.slice();
  } else if (!Array.isArray(array)) {
    return [];
  } else {
    return onlyNotes(array).map(toName);
  }
}
var get = import_pitch_note.note;
var name = (note) => get(note).name;
var pitchClass = (note) => get(note).pc;
var accidentals = (note) => get(note).acc;
var octave = (note) => get(note).oct;
var midi = (note) => get(note).midi;
var freq = (note) => get(note).freq;
var chroma = (note) => get(note).chroma;
function fromMidi(midi2) {
  return (0, import_midi.midiToNoteName)(midi2);
}
function fromFreq(freq2) {
  return (0, import_midi.midiToNoteName)((0, import_midi.freqToMidi)(freq2));
}
function fromFreqSharps(freq2) {
  return (0, import_midi.midiToNoteName)((0, import_midi.freqToMidi)(freq2), { sharps: true });
}
function fromMidiSharps(midi2) {
  return (0, import_midi.midiToNoteName)(midi2, { sharps: true });
}
var distance = import_pitch_distance.distance;
var transpose = import_pitch_distance.transpose;
var tr = import_pitch_distance.transpose;
var transposeBy = (interval) => (note) => transpose(note, interval);
var trBy = transposeBy;
var transposeFrom = (note) => (interval) => transpose(note, interval);
var trFrom = transposeFrom;
function transposeFifths(noteName, fifths) {
  return transpose(noteName, [fifths, 0]);
}
var trFifths = transposeFifths;
function transposeOctaves(noteName, octaves) {
  return transpose(noteName, [0, octaves]);
}
var ascending = (a, b) => a.height - b.height;
var descending = (a, b) => b.height - a.height;
function sortedNames(notes, comparator) {
  comparator = comparator || ascending;
  return onlyNotes(notes).sort(comparator).map(toName);
}
function sortedUniqNames(notes) {
  return sortedNames(notes, ascending).filter(
    (n, i, a) => i === 0 || n !== a[i - 1]
  );
}
var simplify = (noteName) => {
  const note = get(noteName);
  if (note.empty) {
    return "";
  }
  return (0, import_midi.midiToNoteName)(note.midi || note.chroma, {
    sharps: note.alt > 0,
    pitchClass: note.midi === null
  });
};
function enharmonic(noteName, destName) {
  const src = get(noteName);
  if (src.empty) {
    return "";
  }
  const dest = get(
    destName || (0, import_midi.midiToNoteName)(src.midi || src.chroma, {
      sharps: src.alt < 0,
      pitchClass: true
    })
  );
  if (dest.empty || dest.chroma !== src.chroma) {
    return "";
  }
  if (src.oct === void 0) {
    return dest.pc;
  }
  const srcChroma = src.chroma - src.alt;
  const destChroma = dest.chroma - dest.alt;
  const destOctOffset = srcChroma > 11 || destChroma < 0 ? -1 : srcChroma < 0 || destChroma > 11 ? 1 : 0;
  const destOct = src.oct + destOctOffset;
  return dest.pc + destOct;
}
var index_default = {
  names,
  get,
  name,
  pitchClass,
  accidentals,
  octave,
  midi,
  ascending,
  descending,
  distance,
  sortedNames,
  sortedUniqNames,
  fromMidi,
  fromMidiSharps,
  freq,
  fromFreq,
  fromFreqSharps,
  chroma,
  transpose,
  tr,
  transposeBy,
  trBy,
  transposeFrom,
  trFrom,
  transposeFifths,
  transposeOctaves,
  trFifths,
  simplify,
  enharmonic
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  accidentals,
  ascending,
  chroma,
  descending,
  distance,
  enharmonic,
  freq,
  fromFreq,
  fromFreqSharps,
  fromMidi,
  fromMidiSharps,
  get,
  midi,
  name,
  names,
  octave,
  pitchClass,
  simplify,
  sortedNames,
  sortedUniqNames,
  tr,
  trBy,
  trFifths,
  trFrom,
  transpose,
  transposeBy,
  transposeFifths,
  transposeFrom,
  transposeOctaves
});
//# sourceMappingURL=index.js.map