brand-music/dist/index.cjs

Strongly typed music theory library

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all2) => {
  for (var name in all2)
    __defProp(target, name, { get: all2[name], enumerable: true });
};
var __copyProps = (to, from9, except, desc) => {
  if (from9 && typeof from9 === "object" || typeof from9 === "function") {
    for (let key of __getOwnPropNames(from9))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from9[key], enumerable: !(desc = __getOwnPropDesc(from9, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  IntervalClass: () => IntervalClass_exports,
  MidiNoteNumber: () => MidiNoteNumber_exports2,
  PitchClass: () => PitchClass_exports2,
  PitchClassSet: () => PitchClassSet_exports,
  PitchInterval: () => PitchInterval_exports2,
  PitchIntervalClass: () => PitchIntervalClass_exports2,
  PitchIntervalClassSet: () => PitchIntervalClassSet_exports,
  Semitones: () => Semitones_exports2
});
module.exports = __toCommonJS(src_exports);

// src/IntervalClass.ts
var IntervalClass_exports = {};
__export(IntervalClass_exports, {
  ALL: () => ALL4,
  MAX: () => MAX4,
  MIN: () => MIN5,
  between: () => icBetweenPc,
  from: () => from6,
  fromIntClamp: () => fromIntClamp4,
  fromIntMod: () => fromIntMod4,
  fromNum: () => fromNum6,
  fromPic: () => icFromPic,
  fromUnknown: () => fromUnknown7,
  hasShape: () => hasShape6,
  mark: () => mark6,
  markNum: () => markNum6,
  markUnknown: () => markUnknown6
});

// src/internal/utils.ts
var mod = (a, n) => (a % n + n) % n;

// src/internal/refined/Literal.ts
var is = (start, end) => (v) => Number.isSafeInteger(v) && start <= v && v <= end;
var clamp = (start, end) => (v) => v < start ? start : v > end ? end : v;
var modded = (start, end) => (v) => {
  const size = end - start + 1;
  const zero = v - start;
  const m = mod(zero, size);
  return m + start;
};
var all = (start, end) => (
  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
  [...Array(end - start + 1)].map((_, i) => start + i)
);
var asInt = (v) => v;

// src/internal/MidiNoteNumber.ts
var min = 0;
var max = 127;
var hasShape = is(min, max);
var mark = (_v) => true;
var markNum = (v) => hasShape(v);
var markUnknown = (v) => hasShape(v);
var from = (v) => v;
var fromNum = (v) => markNum(v) ? v : void 0;
var fromIntClamp = (v) => from(clamp(min, max)(v));
var fromIntMod = (v) => from(modded(min, max)(v));
var fromUnknown = (v) => markUnknown(v) ? v : void 0;
var const_ = (v) => v;
var MIN = const_(min);
var MAX = const_(max);
var ALL = all(min, max).map(const_);
var C_1 = const_(0);
var C4 = const_(60);
var G9 = const_(127);

// src/internal/refined/Int.ts
var isInt = (v) => Number.isInteger(v);
var fromUnknown2 = (v) => isInt(v) ? v : void 0;
var makeChecked = (v) => fromUnknown2(v);
var makeRound = (v) => Math.round(v);
var makeTrunc = (v) => Math.trunc(v);
var add = (a, b) => a + b;
var addChecked = (a, b) => makeChecked(a + b);
var sub = (a, b) => a - b;
var subChecked = (a, b) => makeChecked(a - b);
var mul = (a, b) => a * b;
var mulChecked = (a, b) => makeChecked(a * b);
var mulRound = (a, b) => makeRound(a * b);
var mulTrunc = (a, b) => makeTrunc(a * b);
var divChecked = (a, b) => makeChecked(a * b);
var divRound = (a, b) => makeRound(a * b);
var divTrunc = (a, b) => makeTrunc(a * b);

// src/internal/PitchClass.ts
var min2 = 0;
var max2 = 11;
var hasShape2 = is(min2, max2);
var mark2 = (_v) => true;
var markNum2 = (v) => hasShape2(v);
var markUnknown2 = (v) => hasShape2(v);
var from2 = (v) => v;
var fromNum2 = (v) => markNum2(v) ? v : void 0;
var fromIntClamp2 = (v) => from2(clamp(min2, max2)(v));
var fromIntMod2 = (v) => from2(modded(min2, max2)(v));
var fromUnknown3 = (v) => is(min2, max2)(v) ? from2(v) : void 0;
var const_2 = (value) => value;
var MIN2 = const_2(min2);
var MAX2 = const_2(max2);
var ALL2 = all(min2, max2).map(const_2);
var invert = (v, index = 0) => fromIntMod2(sub(asInt(index), asInt(v)));

// src/internal/refined/NonNegative.ts
var isNonNegative = (v) => typeof v === "number" && v >= 0;
function makeAbs(v, edgeCases) {
  const caseNaN = edgeCases?.NaN ?? 0;
  if (Number.isNaN(v)) {
    return caseNaN;
  } else {
    return Math.abs(v);
  }
}

// src/internal/PitchInterval.ts
var hasShape3 = isInt;
var mark3 = (_v) => true;
var markNum3 = (v) => hasShape3(v);
var markUnknown3 = (v) => hasShape3(v);
var from3 = (v) => v;
var fromNum3 = (v) => markNum3(v) ? v : void 0;
var fromNumRound = (v) => from3(makeRound(v));
var fromNumTrunc = (v) => from3(makeTrunc(v));
var fromUnknown4 = (v) => markUnknown3(v) ? v : void 0;
var fromUndefinedable = (v) => v != null ? from3(v) : v;
var add2 = (a, b) => from3(add(a, b));
var addChecked2 = (a, b) => fromUndefinedable(addChecked(a, b));
var sub2 = (a, b) => from3(sub(a, b));
var subChecked2 = (a, b) => fromUndefinedable(subChecked(a, b));
var mul2 = (a, b) => from3(mul(a, b));
var mulChecked2 = (a, b) => fromUndefinedable(mulChecked(a, b));
var mulRound2 = (a, b) => from3(mulRound(a, b));
var mulTrunc2 = (a, b) => from3(mulTrunc(a, b));
var divChecked2 = (a, b) => fromUndefinedable(divChecked(a, b));
var divRound2 = (a, b) => from3(divRound(a, b));
var divTrunc2 = (a, b) => from3(divTrunc(a, b));
var octaves = (pi) => pi === 0 ? 0 : makeAbs(makeTrunc(pi / 12));
var direction = (pi) => pi < 0 ? -1 : pi > 0 ? 1 : 0;

// src/internal/PitchIntervalClass.ts
var min3 = 0;
var max3 = 11;
var hasShape4 = is(min3, max3);
var mark4 = (_v) => true;
var markNum4 = (v) => hasShape4(v);
var markUnknown4 = (v) => hasShape4(v);
var from4 = (v) => v;
var fromNum4 = (v) => markNum4(v) ? v : void 0;
var fromIntClamp3 = (v) => from4(clamp(min3, max3)(v));
var fromIntMod3 = (v) => from4(modded(min3, max3)(v));
var fromUnknown5 = (v) => markUnknown4(v) ? v : void 0;
var const_3 = (value) => value;
var MIN3 = const_3(min3);
var MAX3 = const_3(max3);
var ALL3 = all(min3, max3).map(const_3);
var invert2 = (v, index = 0) => fromIntMod3(sub(asInt(index), asInt(v)));

// src/internal/refined/NonNegativeInt.ts
var isNonNegativeInt = (v) => isInt(v) && isNonNegative(v);

// src/internal/Semitones.ts
var hasShape5 = isNonNegativeInt;
var mark5 = (_v) => true;
var markNum5 = (v) => hasShape5(v);
var markUnknown5 = (v) => hasShape5(v);
var from5 = (v) => v;
var fromNum5 = (v) => markNum5(v) ? v : void 0;
var fromIntAbs = (v) => from5(makeAbs(v));
var fromUnknown6 = (v) => markUnknown5(v) ? v : void 0;
var const_4 = (v) => v;
var MIN4 = const_4(0);
var octaves2 = (st) => st === 0 ? 0 : makeTrunc(st / 12);

// src/internal/conversion.ts
var icFromPic = (pic) => Math.min(pic, invert2(pic));
var icBetweenPc = (a, b) => icFromPic(picBetweenPc(a, b));
var mnnAdd = (value, interval) => add(asInt(value), asInt(interval));
var mnnTransposeChecked = (value, interval) => fromNum(mnnAdd(value, interval));
var mnnTransposeClamped = (value, interval) => fromIntClamp(mnnAdd(value, interval));
var mnnTransposeModded = (value, interval) => fromIntMod(mnnAdd(value, interval));
var pcTranspose = (value, interval) => fromIntMod2(add(asInt(value), asInt(interval)));
var pcFromMnn = (mnn) => fromIntMod2(asInt(mnn));
var piBetweenMnn = (from9, to) => from3(sub(asInt(to), asInt(from9)));
var picBetweenPc = (from9, to) => fromIntMod3(sub(asInt(to), asInt(from9)));
var picFromPi = (pi) => fromIntMod3(pi);
var picFromSemitones = (semitones) => fromIntMod3(semitones);
var stFromPi = (pi) => fromIntAbs(pi);
var stBetweenMnn = (a, b) => fromIntAbs(sub(asInt(a), asInt(b)));

// src/internal/IntervalClass.ts
var min4 = 0;
var max4 = 6;
var hasShape6 = is(min4, max4);
var mark6 = (_v) => true;
var markNum6 = (v) => hasShape6(v);
var markUnknown6 = (v) => hasShape6(v);
var from6 = (v) => v;
var fromNum6 = (v) => markNum6(v) ? v : void 0;
var fromIntClamp4 = (v) => from6(clamp(min4, max4)(v));
var fromIntMod4 = (v) => from6(modded(min4, max4)(v));
var fromUnknown7 = (v) => markUnknown6(v) ? v : void 0;
var const_5 = (value) => value;
var MIN5 = const_5(min4);
var MAX4 = const_5(max4);
var ALL4 = all(min4, max4).map(const_5);

// src/MidiNoteNumber.ts
var MidiNoteNumber_exports2 = {};
__export(MidiNoteNumber_exports2, {
  ALL: () => ALL,
  C4: () => C4,
  C_1: () => C_1,
  G9: () => G9,
  MAX: () => MAX,
  MIN: () => MIN,
  from: () => from,
  fromIntClamp: () => fromIntClamp,
  fromIntMod: () => fromIntMod,
  fromNum: () => fromNum,
  fromUnknown: () => fromUnknown,
  hasShape: () => hasShape,
  mark: () => mark,
  markNum: () => markNum,
  markUnknown: () => markUnknown,
  pc: () => pcFromMnn,
  pi: () => piBetweenMnn,
  semitones: () => stBetweenMnn,
  transposeChecked: () => mnnTransposeChecked,
  transposeClamped: () => mnnTransposeClamped,
  transposeModded: () => mnnTransposeModded
});

// src/PitchClass.ts
var PitchClass_exports2 = {};
__export(PitchClass_exports2, {
  ALL: () => ALL2,
  MAX: () => MAX2,
  MIN: () => MIN2,
  from: () => from2,
  fromIntClamp: () => fromIntClamp2,
  fromIntMod: () => fromIntMod2,
  fromMnn: () => pcFromMnn,
  fromNum: () => fromNum2,
  fromUnknown: () => fromUnknown3,
  hasShape: () => hasShape2,
  ic: () => icBetweenPc,
  invert: () => invert,
  mark: () => mark2,
  markNum: () => markNum2,
  markUnknown: () => markUnknown2,
  pic: () => picBetweenPc,
  transpose: () => pcTranspose
});

// src/PitchClassSet.ts
var PitchClassSet_exports = {};
__export(PitchClassSet_exports, {
  ALL: () => ALL6,
  EMPTY: () => EMPTY2,
  add: () => add4,
  difference: () => difference2,
  from: () => from7,
  fromRaw: () => fromRaw,
  fromRawMasked: () => fromRawMasked,
  fromRawUnknown: () => fromRawUnknown,
  has: () => has2,
  hasShape: () => hasShape7,
  intersection: () => intersection2,
  isSubset: () => isSubset2,
  isSuperset: () => isSuperset2,
  mark: () => mark7,
  markRaw: () => markRaw,
  markRawUnknown: () => markRawUnknown,
  remove: () => remove2,
  symmetricDifference: () => symmetricDifference2,
  toggle: () => toggle2,
  toggleAll: () => toggleAll,
  union: () => union2,
  values: () => values2
});

// src/internal/refined/TwelveBits.ts
var isTwelveBits = (v) => isNonNegativeInt(v) && v < 1 << 12;
var EMPTY = 0;
var ALL5 = 4095;
var masked = (v) => v & ALL5;
var one = (value) => 1 << value;
var fromValues = (...values4) => values4.map(one).reduce(union);
var values = (a) => all(0, 11).filter((value) => has(a, value));
var complement = (a) => masked(~a);
var union = (a, b) => a | b;
var intersection = (a, b) => a & b;
var symmetricDifference = (a, b) => a ^ b;
var difference = (a, b) => intersection(a, complement(b));
var has = (a, value) => Boolean(intersection(a, fromValues(value)));
var add3 = (a, value) => union(a, fromValues(value));
var remove = (a, value) => intersection(a, complement(fromValues(value)));
var toggle = (a, value) => symmetricDifference(a, fromValues(value));
var isSuperset = (a, of) => !intersection(complement(a), of);
var isSubset = (a, of) => isSuperset(of, a);

// src/internal/PitchClassSet.ts
var hasShape7 = isTwelveBits;
var mark7 = (_v) => true;
var markRaw = (v) => hasShape7(v);
var markRawUnknown = (v) => hasShape7(v);
var fromRaw = (v) => v;
var fromRawMasked = (v) => fromRaw(masked(v));
var fromRawUnknown = (v) => isTwelveBits(v) ? fromRaw(v) : void 0;
var EMPTY2 = fromRaw(EMPTY);
var ALL6 = fromRaw(ALL5);
var from7 = (...values4) => fromRaw(fromValues(...values4));
var toggleAll = (pcs) => fromRaw(complement(pcs));
var union2 = (a, b) => fromRaw(union(a, b));
var intersection2 = (a, b) => fromRaw(intersection(a, b));
var symmetricDifference2 = (a, b) => fromRaw(symmetricDifference(a, b));
var difference2 = (a, b) => fromRaw(difference(a, b));
var has2 = (pcs, pc) => has(pcs, pc);
var add4 = (pcs, pc) => fromRaw(add3(pcs, pc));
var remove2 = (pcs, pc) => fromRaw(remove(pcs, pc));
var toggle2 = (pcs, pc) => fromRaw(toggle(pcs, pc));
var isSuperset2 = (value, of) => isSuperset(value, of);
var isSubset2 = (value, of) => isSubset(value, of);
var values2 = (pcs) => values(pcs).map(from2);

// src/PitchInterval.ts
var PitchInterval_exports2 = {};
__export(PitchInterval_exports2, {
  add: () => add2,
  addChecked: () => addChecked2,
  between: () => piBetweenMnn,
  direction: () => direction,
  divChecked: () => divChecked2,
  divRound: () => divRound2,
  divTrunc: () => divTrunc2,
  from: () => from3,
  fromNum: () => fromNum3,
  fromNumRound: () => fromNumRound,
  fromNumTrunc: () => fromNumTrunc,
  fromUnknown: () => fromUnknown4,
  hasShape: () => hasShape3,
  mark: () => mark3,
  markNum: () => markNum3,
  markUnknown: () => markUnknown3,
  mul: () => mul2,
  mulChecked: () => mulChecked2,
  mulRound: () => mulRound2,
  mulTrunc: () => mulTrunc2,
  octaves: () => octaves,
  pic: () => picFromPi,
  semitones: () => stFromPi,
  sub: () => sub2,
  subChecked: () => subChecked2
});

// src/PitchIntervalClass.ts
var PitchIntervalClass_exports2 = {};
__export(PitchIntervalClass_exports2, {
  ALL: () => ALL3,
  MAX: () => MAX3,
  MIN: () => MIN3,
  between: () => picBetweenPc,
  from: () => from4,
  fromIntClamp: () => fromIntClamp3,
  fromIntMod: () => fromIntMod3,
  fromNum: () => fromNum4,
  fromPi: () => picFromPi,
  fromSemitones: () => picFromSemitones,
  fromUnknown: () => fromUnknown5,
  hasShape: () => hasShape4,
  ic: () => icFromPic,
  invert: () => invert2,
  mark: () => mark4,
  markNum: () => markNum4,
  markUnknown: () => markUnknown4
});

// src/PitchIntervalClassSet.ts
var PitchIntervalClassSet_exports = {};
__export(PitchIntervalClassSet_exports, {
  ALL: () => ALL7,
  EMPTY: () => EMPTY3,
  add: () => add5,
  difference: () => difference3,
  from: () => from8,
  fromRaw: () => fromRaw2,
  fromRawMasked: () => fromRawMasked2,
  fromRawUnknown: () => fromRawUnknown2,
  has: () => has3,
  hasShape: () => hasShape8,
  intersection: () => intersection3,
  isSubset: () => isSubset3,
  isSuperset: () => isSuperset3,
  mark: () => mark8,
  markRaw: () => markRaw2,
  markRawUnknown: () => markRawUnknown2,
  remove: () => remove3,
  symmetricDifference: () => symmetricDifference3,
  toggle: () => toggle3,
  toggleAll: () => toggleAll2,
  union: () => union3,
  values: () => values3
});

// src/internal/PitchIntervalClassSet.ts
var hasShape8 = isTwelveBits;
var mark8 = (_v) => true;
var markRaw2 = (v) => hasShape8(v);
var markRawUnknown2 = (v) => hasShape8(v);
var fromRaw2 = (v) => v;
var fromRawMasked2 = (v) => fromRaw2(masked(v));
var fromRawUnknown2 = (v) => isTwelveBits(v) ? fromRaw2(v) : void 0;
var EMPTY3 = fromRaw2(EMPTY);
var ALL7 = fromRaw2(ALL5);
var one2 = (pc) => 1 << pc;
var from8 = (...values4) => values4.map(one2).reduce(union3);
var toggleAll2 = (pcs) => ~pcs & ALL7;
var union3 = (a, b) => a | b;
var intersection3 = (a, b) => a & b;
var symmetricDifference3 = (a, b) => a ^ b;
var difference3 = (a, b) => intersection3(a, toggleAll2(b));
var has3 = (pcs, pc) => Boolean(intersection3(pcs, from8(pc)));
var add5 = (pcs, pc) => union3(pcs, from8(pc));
var remove3 = (pcs, pc) => intersection3(pcs, toggleAll2(from8(pc)));
var toggle3 = (pcs, pc) => symmetricDifference3(pcs, from8(pc));
var isSuperset3 = (value, of) => !intersection3(toggleAll2(value), of);
var isSubset3 = (value, of) => isSuperset3(of, value);
var values3 = (pics) => values(pics).map(from4);

// src/Semitones.ts
var Semitones_exports2 = {};
__export(Semitones_exports2, {
  MIN: () => MIN4,
  between: () => stBetweenMnn,
  from: () => from5,
  fromIntAbs: () => fromIntAbs,
  fromNum: () => fromNum5,
  fromPi: () => stFromPi,
  fromUnknown: () => fromUnknown6,
  hasShape: () => hasShape5,
  mark: () => mark5,
  markNum: () => markNum5,
  markUnknown: () => markUnknown5,
  octaves: () => octaves2,
  pic: () => picFromSemitones
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  IntervalClass,
  MidiNoteNumber,
  PitchClass,
  PitchClassSet,
  PitchInterval,
  PitchIntervalClass,
  PitchIntervalClassSet,
  Semitones
});
//# sourceMappingURL=index.cjs.map