@libraz/libcantus 0.9.4 → 1.0.0

package/dist/chunk-YLEMGEFH.js

@@ -1,246 +0,0 @@
-import {
-  InvalidInputError,
-  assertFiniteNumber,
-  assertInteger,
-  assertNoteEvents,
-  assertPositiveInt,
-  assertRange,
-  assertTimeSignature,
-  barBeatsOf,
-  isAdditiveReading,
-  isCompoundNumerator,
-  pulseBeatsOf,
-  pulseCountOf
-} from "./chunk-XEBG3G53.js";
-
-// src/core/meter/index.ts
-var EPS = 1e-9;
-function isMultiple(value, unit) {
-  if (unit === 0) {
-    return false;
-  }
-  const ratio = value / unit;
-  return Math.abs(ratio - Math.round(ratio)) < EPS;
-}
-function parseTimeSignature(text) {
-  const match = /^\s*(\d+)\s*\/\s*(\d+)\s*$/.exec(text);
-  if (!match) {
-    throw new InvalidInputError(`Invalid time signature: ${text}`);
-  }
-  const numerator = Number.parseInt(match[1] ?? "", 10);
-  const denominator = Number.parseInt(match[2] ?? "", 10);
-  if (!Number.isSafeInteger(numerator) || !Number.isSafeInteger(denominator) || numerator <= 0 || denominator <= 0) {
-    throw new InvalidInputError(`Invalid time signature: ${text}`);
-  }
-  return assertTimeSignature({ numerator, denominator }, `time signature ${text}`);
-}
-function formatTimeSignature(ts, opts = {}) {
-  assertTimeSignature(ts);
-  if (opts.grouping === true && ts.grouping !== void 0) {
-    return `${ts.grouping.join("+")}/${ts.denominator}`;
-  }
-  return `${ts.numerator}/${ts.denominator}`;
-}
-function isCompound(ts) {
-  assertTimeSignature(ts);
-  return isCompoundNumerator(ts.numerator) && !isAdditiveReading(ts);
-}
-function beatsPerBar(ts) {
-  assertTimeSignature(ts);
-  return barBeatsOf(ts);
-}
-function pulsesPerBar(ts) {
-  assertTimeSignature(ts);
-  return pulseCountOf(ts);
-}
-function isGroupHead(grouping, pulseIndex) {
-  let acc = 0;
-  for (const g of grouping) {
-    if (acc === pulseIndex) {
-      return true;
-    }
-    acc += g;
-  }
-  return false;
-}
-function beatToBarPosition(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  assertTimeSignature(ts);
-  const barLen = barBeatsOf(ts);
-  const bar = Math.floor(beatInQuarters / barLen);
-  return { bar, beat: beatInQuarters - bar * barLen };
-}
-function pulseBeats(ts) {
-  assertTimeSignature(ts);
-  return pulseBeatsOf(ts);
-}
-function barPositionToPulse(pos, ts) {
-  assertFiniteNumber(pos.beat, "position.beat");
-  assertTimeSignature(ts);
-  return pos.beat / pulseBeatsOf(ts) + 1;
-}
-function formatBarPosition(beatInQuarters, ts, decimals = 2) {
-  const position = beatToBarPosition(beatInQuarters, ts);
-  const pulse = barPositionToPulse(position, ts);
-  const rounded = Number(pulse.toFixed(decimals));
-  return `${position.bar + 1}.${rounded}`;
-}
-function barPositionToBeat(pos, ts) {
-  assertInteger(pos.bar, "bar position bar");
-  assertFiniteNumber(pos.beat, "bar position beat");
-  assertTimeSignature(ts);
-  return pos.bar * barBeatsOf(ts) + pos.beat;
-}
-function metricWeight(beatInQuarters, ts) {
-  assertFiniteNumber(beatInQuarters, "beat");
-  assertTimeSignature(ts);
-  const barLen = barBeatsOf(ts);
-  const beat = beatInQuarters - Math.floor(beatInQuarters / barLen) * barLen;
-  const pulse = pulseBeatsOf(ts);
-  if (!isMultiple(beat, pulse)) {
-    return 0;
-  }
-  const pulses = pulseCountOf(ts);
-  const pulseIndex = Math.round(beat / pulse) % pulses;
-  if (pulseIndex === 0) {
-    return 3;
-  }
-  const grouping = ts.grouping;
-  if (grouping !== void 0) {
-    return isGroupHead(grouping, pulseIndex) ? 2 : 1;
-  }
-  if (pulses % 2 === 0 && pulseIndex === pulses / 2) {
-    return 2;
-  }
-  return 1;
-}
-function isStrongBeat(beatInQuarters, ts) {
-  return metricWeight(beatInQuarters, ts) >= 2;
-}
-function tuplet(totalBeats, count) {
-  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, "tuplet total beats");
-  assertPositiveInt(count, "tuplet count");
-  return new Array(count).fill(totalBeats / count);
-}
-
-// src/core/event-index/index.ts
-var EPS2 = 1e-9;
-function upperBound(values, beat) {
-  let low = 0;
-  let high = values.length;
-  while (low < high) {
-    const middle = Math.floor((low + high) / 2);
-    if ((values[middle]?.note.startBeat ?? Number.POSITIVE_INFINITY) <= beat) {
-      low = middle + 1;
-    } else {
-      high = middle;
-    }
-  }
-  return low;
-}
-function createNoteEventIndex(events, options = {}) {
-  assertNoteEvents(events, options.name ?? "note events", options);
-  const tieBreak = options.tieBreak ?? "highest";
-  const notes = events.map((note, originalIndex) => ({
-    note,
-    originalIndex,
-    endBeat: note.startBeat + note.durationBeat
-  })).sort((a, b) => a.note.startBeat - b.note.startBeat || a.originalIndex - b.originalIndex);
-  let prefixMaxEnd;
-  const maxEndUpTo = (index) => {
-    if (prefixMaxEnd === void 0) {
-      const prefix = [];
-      let maxEnd = Number.NEGATIVE_INFINITY;
-      for (const indexed of notes) {
-        maxEnd = Math.max(maxEnd, indexed.endBeat);
-        prefix.push(maxEnd);
-      }
-      prefixMaxEnd = prefix;
-    }
-    return prefixMaxEnd[index] ?? Number.NEGATIVE_INFINITY;
-  };
-  return {
-    notes,
-    at(beat) {
-      let index = upperBound(notes, beat + EPS2) - 1;
-      let best;
-      while (index >= 0) {
-        if (maxEndUpTo(index) <= beat + EPS2) {
-          break;
-        }
-        const indexed = notes[index];
-        index -= 1;
-        if (indexed === void 0 || indexed.note.durationBeat <= 0 || indexed.note.startBeat - EPS2 > beat || beat >= indexed.endBeat - EPS2) {
-          continue;
-        }
-        if (best === void 0) {
-          best = indexed;
-          if (tieBreak === "last") {
-            break;
-          }
-          continue;
-        }
-        if (Math.abs(indexed.note.startBeat - best.note.startBeat) >= EPS2) {
-          break;
-        }
-        const higher = indexed.note.pitch > best.note.pitch;
-        if (tieBreak === "highest" ? higher : !higher) {
-          best = indexed;
-        }
-      }
-      return best;
-    },
-    attacksAt(beat) {
-      let index = upperBound(notes, beat + EPS2) - 1;
-      while (index >= 0) {
-        const candidate = notes[index];
-        if (candidate === void 0 || Math.abs(candidate.note.startBeat - beat) >= EPS2) {
-          return false;
-        }
-        if (candidate.note.durationBeat > 0) {
-          return true;
-        }
-        index -= 1;
-      }
-      return false;
-    },
-    onsetsBetween(startBeat, endBeat) {
-      const result = [];
-      let index = upperBound(notes, startBeat + EPS2);
-      while (index < notes.length) {
-        const indexed = notes[index];
-        const onset = indexed?.note.startBeat;
-        if (indexed === void 0 || onset === void 0 || onset >= endBeat - EPS2) {
-          break;
-        }
-        index += 1;
-        if (indexed.note.durationBeat <= 0) {
-          continue;
-        }
-        const previous = result[result.length - 1];
-        if (previous === void 0 || Math.abs(previous - onset) >= EPS2) {
-          result.push(onset);
-        }
-      }
-      return result;
-    }
-  };
-}
-
-export {
-  parseTimeSignature,
-  formatTimeSignature,
-  isCompound,
-  beatsPerBar,
-  pulsesPerBar,
-  beatToBarPosition,
-  pulseBeats,
-  barPositionToPulse,
-  formatBarPosition,
-  barPositionToBeat,
-  metricWeight,
-  isStrongBeat,
-  tuplet,
-  createNoteEventIndex
-};
-//# sourceMappingURL=chunk-YLEMGEFH.js.map

package/dist/chunk-YLEMGEFH.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/meter/index.ts","../src/core/event-index/index.ts"],"sourcesContent":["/**\n * Meter and time signatures: bar/beat arithmetic, simple vs. compound meters,\n * metric-accent hierarchy, and tuplet subdivision.\n *\n * Positions and durations are measured in quarter-note beats, matching the rest\n * of the library's beat convention (four quarter-note beats per bar in 4/4).\n */\n\nimport { InvalidInputError } from '../errors/index.js';\nimport {\n  assertFiniteNumber,\n  assertInteger,\n  assertPositiveInt,\n  assertRange,\n  assertTimeSignature,\n} from '../validation/index.js';\nimport {\n  barBeatsOf,\n  isAdditiveReading,\n  isCompoundNumerator,\n  pulseBeatsOf,\n  pulseCountOf,\n} from './internal.js';\n\n/**\n * A time signature as a numerator over a note-value denominator.\n *\n * @category Rhythm & Meter\n */\nexport type TimeSignature = {\n  numerator: number;\n  denominator: number;\n  /**\n   * Optional additive grouping of the bar's main pulses, as the felt-beat\n   * lengths in pulses — e.g. `[2, 2, 3]` for a 2+2+3 reading of 7/8, or\n   * `[3, 2]` for 5/8. The entries must be positive integers summing to the\n   * numerator.\n   *\n   * A compound numerator accepts both readings. 9/8 groups its three dotted\n   * pulses as `[1, 1, 1]`, or reads additively as `[2, 2, 2, 3]` quavers; a\n   * grouping that sums to the numerator selects the additive reading, so\n   * aksak and other additive metres are expressible. {@link pulsesPerBar}\n   * and {@link isCompound} follow whichever reading the grouping selects.\n   *\n   * When present, the head pulse of each group (other than the downbeat) is\n   * treated as a secondary strong pulse by\n   * {@link metricWeight}/{@link isStrongBeat}; when absent, all main pulses\n   * are weighted equally as flat, evenly divided pulses.\n   */\n  grouping?: number[];\n};\n\n/**\n * A position expressed as a bar index and a quarter-note offset within the bar.\n *\n * @category Rhythm & Meter\n */\nexport type BarPosition = {\n  /** 0-based bar index. {@link formatBarPosition} renders it 1-based. */\n  bar: number;\n  /**\n   * Quarter-note offset from the start of the bar — not the felt beat. In 6/8\n   * the second felt beat is at `beat: 1.5`; {@link barPositionToPulse} converts\n   * to felt-beat numbering.\n   */\n  beat: number;\n};\n\nconst EPS = 1e-9;\n\n/** Whether `value` is an integer multiple of `unit` (within a float tolerance). */\nfunction isMultiple(value: number, unit: number): boolean {\n  if (unit === 0) {\n    return false;\n  }\n  const ratio = value / unit;\n  return Math.abs(ratio - Math.round(ratio)) < EPS;\n}\n\n/**\n * Parse a time signature such as `\"4/4\"` or `\"6/8\"`.\n *\n * @param text The signature text.\n * @returns The parsed time signature.\n * @throws If the text is not `n/d` with positive integers.\n * @example\n * ```ts\n * import { parseTimeSignature } from '@libraz/libcantus';\n * parseTimeSignature('6/8'); // { numerator: 6, denominator: 8 }\n * ```\n * @category Rhythm & Meter\n */\nexport function parseTimeSignature(text: string): TimeSignature {\n  const match = /^\\s*(\\d+)\\s*\\/\\s*(\\d+)\\s*$/.exec(text);\n  if (!match) {\n    throw new InvalidInputError(`Invalid time signature: ${text}`);\n  }\n  const numerator = Number.parseInt(match[1] ?? '', 10);\n  const denominator = Number.parseInt(match[2] ?? '', 10);\n  if (\n    !Number.isSafeInteger(numerator) ||\n    !Number.isSafeInteger(denominator) ||\n    numerator <= 0 ||\n    denominator <= 0\n  ) {\n    throw new InvalidInputError(`Invalid time signature: ${text}`);\n  }\n  // The same signature every consumer validates, validated here too: parsing\n  // a signature the rest of the library rejects only moves the failure.\n  return assertTimeSignature({ numerator, denominator }, `time signature ${text}`);\n}\n\n/**\n * Render a time signature as `\"n/d\"`, or as `\"a+b+c/d\"` when it carries an\n * additive grouping and `grouping` is requested.\n *\n * The plain form drops the grouping, so a round trip through it reads 7/8 as\n * flat rather than as 2+2+3; ask for the additive form to keep it.\n *\n * @param ts The time signature.\n * @param opts Set `grouping: true` to render an additive grouping.\n * @returns The formatted signature.\n * @example\n * ```ts\n * import { formatTimeSignature } from '@libraz/libcantus';\n * const aksak = { numerator: 7, denominator: 8, grouping: [2, 2, 3] };\n * formatTimeSignature(aksak); // '7/8'\n * formatTimeSignature(aksak, { grouping: true }); // '2+2+3/8'\n * ```\n * @category Rhythm & Meter\n */\nexport function formatTimeSignature(ts: TimeSignature, opts: { grouping?: boolean } = {}): string {\n  assertTimeSignature(ts);\n  if (opts.grouping === true && ts.grouping !== undefined) {\n    return `${ts.grouping.join('+')}/${ts.denominator}`;\n  }\n  return `${ts.numerator}/${ts.denominator}`;\n}\n\n/**\n * Whether a meter is compound: its main pulses each divide into three, as in\n * 6/8, 9/8, 12/8, or 6/4. Compound meters are those whose numerator is a\n * multiple of three greater than three, independent of the denominator. Meters\n * like 3/8 and 3/4 (simple triples, numerator 3) are not compound, and neither\n * is a signature whose {@link TimeSignature.grouping} selects the additive\n * reading (9/8 as 2+2+2+3).\n *\n * @param ts The time signature.\n * @returns True for compound meters.\n * @category Rhythm & Meter\n */\nexport function isCompound(ts: TimeSignature): boolean {\n  assertTimeSignature(ts);\n  return isCompoundNumerator(ts.numerator) && !isAdditiveReading(ts);\n}\n\n/**\n * Length of a bar in quarter-note beats.\n *\n * @param ts The time signature.\n * @returns The bar length in quarter notes.\n * @category Rhythm & Meter\n */\nexport function beatsPerBar(ts: TimeSignature): number {\n  assertTimeSignature(ts);\n  return barBeatsOf(ts);\n}\n\n/**\n * Number of main pulses (felt beats) per bar: the numerator for simple meters,\n * a third of it for compound meters.\n *\n * For additive/irregular meters such as 7/8 or 5/8 this counts the raw pulses\n * (7 and 5 respectively), which are otherwise felt as flat, evenly divided and\n * equally accented pulses. To recover a 2+2+3 or 3+2 felt-beat grouping, set\n * {@link TimeSignature.grouping}; {@link metricWeight} then accents each\n * group's head pulse.\n *\n * @param ts The time signature.\n * @returns The pulse count per bar.\n * @category Rhythm & Meter\n */\nexport function pulsesPerBar(ts: TimeSignature): number {\n  assertTimeSignature(ts);\n  return pulseCountOf(ts);\n}\n\n/** Whether `pulseIndex` is the head pulse of one of the additive groups. */\nfunction isGroupHead(grouping: number[], pulseIndex: number): boolean {\n  let acc = 0;\n  for (const g of grouping) {\n    if (acc === pulseIndex) {\n      return true;\n    }\n    acc += g;\n  }\n  return false;\n}\n\n/**\n * Convert an absolute quarter-note position to a bar index and in-bar offset.\n *\n * @param beatInQuarters Absolute position in quarter-note beats.\n * @param ts The time signature.\n * @returns The bar and in-bar quarter-note offset.\n * @example\n * ```ts\n * import { parseTimeSignature, beatToBarPosition } from '@libraz/libcantus';\n * const ts = parseTimeSignature('4/4');\n * beatToBarPosition(5, ts); // { bar: 1, beat: 1 }\n * ```\n * @category Rhythm & Meter\n */\nexport function beatToBarPosition(beatInQuarters: number, ts: TimeSignature): BarPosition {\n  assertFiniteNumber(beatInQuarters, 'beat');\n  assertTimeSignature(ts);\n  const barLen = barBeatsOf(ts);\n  const bar = Math.floor(beatInQuarters / barLen);\n  return { bar, beat: beatInQuarters - bar * barLen };\n}\n\n/**\n * Length of one felt beat (main pulse) in quarter-note beats.\n *\n * A quarter note in simple meters, a dotted quarter in compound ones, and one\n * denominator unit in an additive metre. Position displays, click tracks, and\n * score export are all written against this length.\n *\n * @param ts The time signature.\n * @returns The pulse length in quarter-note beats.\n * @example\n * ```ts\n * import { parseTimeSignature, pulseBeats } from '@libraz/libcantus';\n * pulseBeats(parseTimeSignature('6/8')); // 1.5\n * ```\n * @category Rhythm & Meter\n */\nexport function pulseBeats(ts: TimeSignature): number {\n  assertTimeSignature(ts);\n  return pulseBeatsOf(ts);\n}\n\n/**\n * The felt-beat number of a bar position, 1-based.\n *\n * {@link BarPosition.beat} is a quarter-note offset, so in 6/8 the second felt\n * beat reads as 1.5. This is the number a musician says and a position display\n * shows.\n *\n * @param pos The bar position.\n * @param ts The time signature.\n * @returns The 1-based felt-beat number, fractional between pulses.\n * @example\n * ```ts\n * import { barPositionToPulse, parseTimeSignature } from '@libraz/libcantus';\n * barPositionToPulse({ bar: 0, beat: 1.5 }, parseTimeSignature('6/8')); // 2\n * ```\n * @category Rhythm & Meter\n */\nexport function barPositionToPulse(pos: BarPosition, ts: TimeSignature): number {\n  assertFiniteNumber(pos.beat, 'position.beat');\n  assertTimeSignature(ts);\n  return pos.beat / pulseBeatsOf(ts) + 1;\n}\n\n/**\n * Render an absolute position as the `bar.beat` a DAW or a score shows:\n * 1-based bar, 1-based felt beat.\n *\n * @param beatInQuarters Absolute position in quarter-note beats.\n * @param ts The time signature.\n * @param decimals Digits of the fractional beat to keep.\n * @returns The formatted position, e.g. `'3.2'` for bar 3, felt beat 2.\n * @example\n * ```ts\n * import { formatBarPosition, parseTimeSignature } from '@libraz/libcantus';\n * formatBarPosition(7.5, parseTimeSignature('6/8')); // '3.2'\n * ```\n * @category Rhythm & Meter\n */\nexport function formatBarPosition(beatInQuarters: number, ts: TimeSignature, decimals = 2): string {\n  const position = beatToBarPosition(beatInQuarters, ts);\n  const pulse = barPositionToPulse(position, ts);\n  const rounded = Number(pulse.toFixed(decimals));\n  return `${position.bar + 1}.${rounded}`;\n}\n\n/**\n * Convert a bar index and in-bar offset back to an absolute quarter-note\n * position.\n *\n * @param pos The bar position.\n * @param ts The time signature.\n * @returns The absolute position in quarter-note beats.\n * @category Rhythm & Meter\n */\nexport function barPositionToBeat(pos: BarPosition, ts: TimeSignature): number {\n  assertInteger(pos.bar, 'bar position bar');\n  assertFiniteNumber(pos.beat, 'bar position beat');\n  assertTimeSignature(ts);\n  return pos.bar * barBeatsOf(ts) + pos.beat;\n}\n\n/**\n * Metric weight of a position within its bar, on a 0–3 scale:\n * 3 the downbeat, 2 a secondary strong pulse, 1 any other main pulse, and 0 an\n * off-pulse subdivision.\n *\n * The secondary strong pulse is the bar's midpoint in even simple/compound\n * meters. For an additive/irregular meter with {@link TimeSignature.grouping}\n * set (e.g. `[2, 2, 3]` for 7/8), each group's head pulse other than the\n * downbeat is the secondary strong pulse instead; without a grouping every\n * non-downbeat main pulse of such a meter weighs 1 (flat, evenly divided\n * pulses).\n *\n * @param beatInQuarters Absolute or in-bar quarter-note position.\n * @param ts The time signature.\n * @returns The metric weight (0–3).\n * @throws If the time signature is malformed, including a grouping that is not\n *   a positive-integer list summing to the pulse count or the numerator.\n * @example\n * ```ts\n * import { parseTimeSignature, metricWeight } from '@libraz/libcantus';\n * const ts = parseTimeSignature('4/4');\n * metricWeight(0, ts); // 3 (the downbeat)\n * ```\n * @category Rhythm & Meter\n */\nexport function metricWeight(beatInQuarters: number, ts: TimeSignature): number {\n  assertFiniteNumber(beatInQuarters, 'beat');\n  assertTimeSignature(ts);\n  const barLen = barBeatsOf(ts);\n  const beat = beatInQuarters - Math.floor(beatInQuarters / barLen) * barLen;\n  const pulse = pulseBeatsOf(ts);\n  if (!isMultiple(beat, pulse)) {\n    return 0;\n  }\n  const pulses = pulseCountOf(ts);\n  const pulseIndex = Math.round(beat / pulse) % pulses;\n  if (pulseIndex === 0) {\n    return 3;\n  }\n  const grouping = ts.grouping;\n  if (grouping !== undefined) {\n    return isGroupHead(grouping, pulseIndex) ? 2 : 1;\n  }\n  if (pulses % 2 === 0 && pulseIndex === pulses / 2) {\n    return 2;\n  }\n  return 1;\n}\n\n/**\n * Whether a position is metrically accented (weight 2 or more — a downbeat or a\n * secondary strong pulse).\n *\n * @param beatInQuarters Absolute or in-bar quarter-note position.\n * @param ts The time signature.\n * @returns True on strong beats.\n * @category Rhythm & Meter\n */\nexport function isStrongBeat(beatInQuarters: number, ts: TimeSignature): boolean {\n  return metricWeight(beatInQuarters, ts) >= 2;\n}\n\n/**\n * Subdivide a span into `count` equal tuplet durations (e.g. an eighth-note\n * triplet is `tuplet(1, 3)`).\n *\n * @param totalBeats Total span in quarter-note beats.\n * @param count Number of equal parts.\n * @returns `count` equal durations summing to `totalBeats`.\n * @throws If `count` is not a positive integer.\n * @category Rhythm & Meter\n */\nexport function tuplet(totalBeats: number, count: number): number[] {\n  assertRange(totalBeats, 0, Number.MAX_SAFE_INTEGER, 'tuplet total beats');\n  assertPositiveInt(count, 'tuplet count');\n  return new Array<number>(count).fill(totalBeats / count);\n}\n","import type { NoteEvent } from '../types.js';\nimport { assertNoteEvents } from '../validation/index.js';\n\n/**\n * A validated note retaining its position in the caller's original array.\n *\n * @category Core\n */\nexport type IndexedNoteEvent = {\n  note: NoteEvent;\n  originalIndex: number;\n  endBeat: number;\n};\n\n/**\n * Which note wins when several sound from the same onset.\n *\n * `'highest'` and `'lowest'` name a voice, so the answer does not depend on the\n * order the caller happened to store the chord in; `'last'` takes the one\n * latest in the input array.\n *\n * @category Core\n */\nexport type OnsetTieBreak = 'highest' | 'lowest' | 'last';\n\n/**\n * Binary-searchable, stable-sorted index over note onsets and active spans.\n *\n * @category Core\n */\nexport type NoteEventIndex = {\n  notes: IndexedNoteEvent[];\n  /**\n   * Latest-onset note sounding at `beat`. Simultaneous onsets are resolved by\n   * the index's {@link OnsetTieBreak}.\n   */\n  at: (beat: number) => IndexedNoteEvent | undefined;\n  /** Whether one or more sounding notes attack at `beat`. */\n  attacksAt: (beat: number) => boolean;\n  /** Unique sounding-note attack beats strictly inside `(startBeat, endBeat)`. */\n  onsetsBetween: (startBeat: number, endBeat: number) => number[];\n};\n\nconst EPS = 1e-9;\n\nfunction upperBound(values: IndexedNoteEvent[], beat: number): number {\n  let low = 0;\n  let high = values.length;\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2);\n    if ((values[middle]?.note.startBeat ?? Number.POSITIVE_INFINITY) <= beat) {\n      low = middle + 1;\n    } else {\n      high = middle;\n    }\n  }\n  return low;\n}\n\n/**\n * Validate and stable-sort note events once, then expose logarithmic onset and\n * active-note lookups. Non-positive-duration notes may be retained for callers\n * that intentionally filter them later, but never count as sounding.\n *\n * @category Core\n */\nexport function createNoteEventIndex(\n  events: readonly NoteEvent[],\n  options: {\n    allowNonPositiveDuration?: boolean;\n    tieBreak?: OnsetTieBreak;\n    budget?: number;\n    /** What the events are, for the validation error message. */\n    name?: string;\n  } = {},\n): NoteEventIndex {\n  assertNoteEvents(events, options.name ?? 'note events', options);\n  const tieBreak = options.tieBreak ?? 'highest';\n  const notes = events\n    .map((note, originalIndex) => ({\n      note,\n      originalIndex,\n      endBeat: note.startBeat + note.durationBeat,\n    }))\n    .sort((a, b) => a.note.startBeat - b.note.startBeat || a.originalIndex - b.originalIndex);\n  // Built on the first `at` call rather than up front: several callers use this\n  // only to validate and sort, and never ask what sounds at a beat.\n  let prefixMaxEnd: number[] | undefined;\n  const maxEndUpTo = (index: number): number => {\n    if (prefixMaxEnd === undefined) {\n      const prefix: number[] = [];\n      let maxEnd = Number.NEGATIVE_INFINITY;\n      for (const indexed of notes) {\n        maxEnd = Math.max(maxEnd, indexed.endBeat);\n        prefix.push(maxEnd);\n      }\n      prefixMaxEnd = prefix;\n    }\n    return prefixMaxEnd[index] ?? Number.NEGATIVE_INFINITY;\n  };\n\n  return {\n    notes,\n    at(beat) {\n      let index = upperBound(notes, beat + EPS) - 1;\n      let best: IndexedNoteEvent | undefined;\n      while (index >= 0) {\n        if (maxEndUpTo(index) <= beat + EPS) {\n          break;\n        }\n        const indexed = notes[index];\n        index -= 1;\n        if (\n          indexed === undefined ||\n          indexed.note.durationBeat <= 0 ||\n          indexed.note.startBeat - EPS > beat ||\n          beat >= indexed.endBeat - EPS\n        ) {\n          continue;\n        }\n        if (best === undefined) {\n          best = indexed;\n          if (tieBreak === 'last') {\n            break;\n          }\n          continue;\n        }\n        // Only notes from the same onset compete: a later onset always wins.\n        if (Math.abs(indexed.note.startBeat - best.note.startBeat) >= EPS) {\n          break;\n        }\n        const higher = indexed.note.pitch > best.note.pitch;\n        if (tieBreak === 'highest' ? higher : !higher) {\n          best = indexed;\n        }\n      }\n      return best;\n    },\n    attacksAt(beat) {\n      // Only a sounding note attacks: a zero-length artefact must not make\n      // `attacksAt(b)` true on a beat where `at(b)` finds nothing.\n      let index = upperBound(notes, beat + EPS) - 1;\n      while (index >= 0) {\n        const candidate = notes[index];\n        if (candidate === undefined || Math.abs(candidate.note.startBeat - beat) >= EPS) {\n          return false;\n        }\n        if (candidate.note.durationBeat > 0) {\n          return true;\n        }\n        index -= 1;\n      }\n      return false;\n    },\n    onsetsBetween(startBeat, endBeat) {\n      const result: number[] = [];\n      let index = upperBound(notes, startBeat + EPS);\n      while (index < notes.length) {\n        const indexed = notes[index];\n        const onset = indexed?.note.startBeat;\n        if (indexed === undefined || onset === undefined || onset >= endBeat - EPS) {\n          break;\n        }\n        index += 1;\n        if (indexed.note.durationBeat <= 0) {\n          continue;\n        }\n        const previous = result[result.length - 1];\n        if (previous === undefined || Math.abs(previous - onset) >= EPS) {\n          result.push(onset);\n        }\n      }\n      return result;\n    },\n  };\n}\n"],"mappings":"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","names":["EPS"]}

package/dist/chunk-ZEJR4TKL.cjs

@@ -1,173 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-var _chunkCAN76NCUcjs = require('./chunk-CAN76NCU.cjs');
-
-
-
-
-
-var _chunkFNDWXRRIcjs = require('./chunk-FNDWXRRI.cjs');
-
-
-var _chunk7MGZ7D62cjs = require('./chunk-7MGZ7D62.cjs');
-
-// src/generate/reharmony/index.ts
-function hasInterval(chord, semitone) {
-  return chord.intervals.some((iv) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, iv) === semitone);
-}
-function isDominantType(chord) {
-  return hasInterval(chord, 4) && hasInterval(chord, 10);
-}
-function isStableTarget(chord) {
-  const hasFifth = hasInterval(chord, 7);
-  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);
-  return hasFifth && hasThird && !isDominantType(chord);
-}
-function commonToneCount(a, b) {
-  const set = new Set(b);
-  return a.filter((pc) => set.has(pc)).length;
-}
-function triadQualityOf(chord) {
-  const semis = new Set(chord.intervals.map((interval) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, interval)));
-  const hasThird = semis.has(4) ? "maj" : semis.has(3) ? "min" : void 0;
-  if (hasThird === void 0) {
-    return chord.quality;
-  }
-  if (semis.has(6) && !semis.has(7)) {
-    return hasThird === "min" ? "dim" : "majb5";
-  }
-  if (semis.has(8) && !semis.has(7)) {
-    return "aug";
-  }
-  return hasThird;
-}
-function diatonicTriadsOf(key) {
-  const degrees = _chunkFNDWXRRIcjs.scaleTonesInDegreeOrder.call(void 0, key).length;
-  const triads = [];
-  for (let degree = 0; degree < degrees; degree += 1) {
-    triads.push(_chunkFNDWXRRIcjs.diatonicTriad.call(void 0, degree, key));
-  }
-  return triads;
-}
-function sameChord(a, b) {
-  return _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, a.rootPc) === _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, b.rootPc) && a.quality === b.quality;
-}
-var THIRD_OFFSETS = [3, 4, 8, 9];
-function substituteChord(chord, key, opts) {
-  const originalTriad = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, _chunkFNDWXRRIcjs.makeChord.call(void 0, chord.rootPc, triadQualityOf(chord)));
-  const candidates = [];
-  if (isDominantType(chord)) {
-    candidates.push({ chord: _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + 6), "dom7"), type: "tritone" });
-  }
-  if (isStableTarget(chord)) {
-    candidates.push({
-      chord: _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + 7), "dom7"),
-      type: "secondaryDominant"
-    });
-  }
-  for (const triad of diatonicTriadsOf(key)) {
-    const offset = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, triad.rootPc - chord.rootPc);
-    if (THIRD_OFFSETS.includes(offset) && commonToneCount(originalTriad, _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, triad)) === 2) {
-      candidates.push({ chord: triad, type: "relative" });
-    }
-  }
-  const targetFunction = _chunkCAN76NCUcjs.functionOf.call(void 0, chord, key);
-  for (const triad of diatonicTriadsOf(_chunkCAN76NCUcjs.parallelKey.call(void 0, key))) {
-    if (_chunkCAN76NCUcjs.functionOf.call(void 0, triad, key) === targetFunction && !_chunkCAN76NCUcjs.isDiatonic.call(void 0, triad, key)) {
-      candidates.push({ chord: triad, type: "borrowed" });
-    }
-  }
-  for (const offset of THIRD_OFFSETS) {
-    for (const quality of ["maj", "min"]) {
-      const mediant = _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc + offset), quality);
-      if (commonToneCount(originalTriad, _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, mediant)) === 1 && !_chunkCAN76NCUcjs.isDiatonic.call(void 0, mediant, key)) {
-        candidates.push({ chord: mediant, type: "chromaticMediant" });
-      }
-    }
-  }
-  const melodyPcs = _optionalChain([opts, 'optionalAccess', _ => _.melodyPcs, 'optionalAccess', _2 => _2.map, 'call', _3 => _3(_chunk7MGZ7D62cjs.pitchClassOf)]);
-  const seen = /* @__PURE__ */ new Set();
-  const results = [];
-  for (const candidate of candidates) {
-    if (sameChord(candidate.chord, chord)) {
-      continue;
-    }
-    const dedupeKey = `${_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, candidate.chord.rootPc)}:${candidate.chord.quality}`;
-    if (seen.has(dedupeKey)) {
-      continue;
-    }
-    seen.add(dedupeKey);
-    if (melodyPcs !== void 0) {
-      const pcs = new Set(_chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, candidate.chord));
-      if (!melodyPcs.every((pc) => pcs.has(pc))) {
-        continue;
-      }
-    }
-    results.push({
-      chord: candidate.chord,
-      type: candidate.type,
-      // A secondary dominant is named as the applied chord it is, so the
-      // numeral re-parses to the chord that was proposed rather than to a
-      // chromatic chord on the same root.
-      roman: _chunkCAN76NCUcjs.chordToRoman.call(void 0, candidate.chord, key, {
-        applied: candidate.type === "secondaryDominant"
-      }),
-      function: _chunkCAN76NCUcjs.functionOf.call(void 0, candidate.chord, key)
-    });
-  }
-  return results;
-}
-function modalInterchangePalette(key) {
-  const palette = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (chord) => {
-    const dedupeKey = `${_chunk7MGZ7D62cjs.pitchClassOf.call(void 0, chord.rootPc)}:${chord.quality}`;
-    if (seen.has(dedupeKey)) {
-      return;
-    }
-    seen.add(dedupeKey);
-    palette.push({
-      chord,
-      roman: _chunkCAN76NCUcjs.chordToRoman.call(void 0, chord, key),
-      source: _chunkCAN76NCUcjs.borrowedSource.call(void 0, chord, key)
-    });
-  };
-  for (const triad of diatonicTriadsOf(_chunkCAN76NCUcjs.parallelKey.call(void 0, key))) {
-    if (!_chunkCAN76NCUcjs.isDiatonic.call(void 0, triad, key)) {
-      add(triad);
-    }
-  }
-  const neapolitan = _chunkFNDWXRRIcjs.makeChord.call(void 0, _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc + 1), "maj");
-  if (!_chunkCAN76NCUcjs.isDiatonic.call(void 0, neapolitan, key)) {
-    add(neapolitan);
-  }
-  return palette;
-}
-function negativeHarmonyMirror(chord, key) {
-  const tonic = _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, key.rootPc);
-  const mirror = (p) => _chunk7MGZ7D62cjs.pitchClassOf.call(void 0, 2 * tonic + 7 - p);
-  const pcs = _chunkFNDWXRRIcjs.chordPitchClasses.call(void 0, chord).map(mirror);
-  const bassPc = chord.bassPc !== void 0 ? mirror(chord.bassPc) : void 0;
-  const pitches = bassPc !== void 0 ? [bassPc - 12, ...pcs] : pcs;
-  const detected = _chunkCAN76NCUcjs.detectChordBest.call(void 0, pitches);
-  if (detected) {
-    if (bassPc === void 0 && detected.bassPc !== void 0) {
-      return _chunkFNDWXRRIcjs.makeChord.call(void 0, detected.rootPc, detected.quality);
-    }
-    return detected;
-  }
-  const quality = chord.quality;
-  return _chunkFNDWXRRIcjs.makeChord.call(void 0, mirror(chord.rootPc), quality, bassPc);
-}
-
-
-
-
-
-exports.substituteChord = substituteChord; exports.modalInterchangePalette = modalInterchangePalette; exports.negativeHarmonyMirror = negativeHarmonyMirror;
-//# sourceMappingURL=chunk-ZEJR4TKL.cjs.map

package/dist/chunk-ZEJR4TKL.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["/home/runner/work/libcantus/libcantus/dist/chunk-ZEJR4TKL.cjs","../src/generate/reharmony/index.ts"],"names":[],"mappings":"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","file":"/home/runner/work/libcantus/libcantus/dist/chunk-ZEJR4TKL.cjs","sourcesContent":[null,"/**\n * Reharmonization: chord substitution, modal-interchange palettes, and negative\n * harmony. These transforms take an existing chord (or a key) and propose\n * alternative harmonies that preserve a chosen relationship — a shared function,\n * a common tone, a tonicizing dominant, or a reflection across the key axis.\n *\n * Roots are pitch classes (0..11); no spelled key signature is required.\n */\n\nimport { detectChordBest } from '../../analyze/detect/index.js';\nimport {\n  type BorrowedSource,\n  borrowedSource,\n  chordToRoman,\n  functionOf,\n  type HarmonicFunction,\n  isDiatonic,\n  parallelKey,\n} from '../../analyze/functional/index.js';\nimport { pitchClassOf as mod12 } from '../../core/pitch/index.js';\nimport type { KeyScale } from '../../core/types.js';\nimport {\n  type Chord,\n  type ChordQuality,\n  chordPitchClasses,\n  diatonicTriad,\n  makeChord,\n} from '../../theory/chord/index.js';\nimport { scaleTonesInDegreeOrder } from '../../theory/scale/index.js';\n\n/**\n * The kind of substitution relationship a candidate realizes.\n *\n * @category Reharmonization\n */\nexport type SubstitutionType =\n  | 'tritone'\n  | 'relative'\n  | 'borrowed'\n  | 'chromaticMediant'\n  | 'secondaryDominant';\n\n/**\n * A proposed chord substitution with its relationship, numeral, and function.\n *\n * @category Reharmonization\n */\nexport type Substitution = {\n  chord: Chord;\n  type: SubstitutionType;\n  roman: string;\n  function: HarmonicFunction;\n};\n\n/**\n * Options controlling which substitutions {@link substituteChord} returns.\n *\n * @category Reharmonization\n */\nexport type SubstituteOptions = {\n  /**\n   * Melody pitch classes that must remain chord tones. When given, only\n   * substitutions whose pitch classes contain every listed pitch class are\n   * kept, so the melody stays consonant against the new harmony.\n   */\n  melodyPcs?: number[];\n};\n\n/** Whether the chord's template carries a given interval (mod 12). */\nfunction hasInterval(chord: Chord, semitone: number): boolean {\n  return chord.intervals.some((iv) => mod12(iv) === semitone);\n}\n\n/** Whether a chord is a dominant type: a major third with a minor seventh. */\nfunction isDominantType(chord: Chord): boolean {\n  return hasInterval(chord, 4) && hasInterval(chord, 10);\n}\n\n/**\n * A chord that can be tonicized: it has a perfect fifth and a third but is not\n * itself a dominant seventh (which is an unstable, tonicizing sonority rather\n * than a stable target).\n */\nfunction isStableTarget(chord: Chord): boolean {\n  const hasFifth = hasInterval(chord, 7);\n  const hasThird = hasInterval(chord, 3) || hasInterval(chord, 4);\n  return hasFifth && hasThird && !isDominantType(chord);\n}\n\n/** Count the pitch classes shared between two pitch-class sets. */\nfunction commonToneCount(a: number[], b: number[]): number {\n  const set = new Set(b);\n  return a.filter((pc) => set.has(pc)).length;\n}\n\n/** The plain triad quality underlying a chord's own quality. */\nfunction triadQualityOf(chord: Chord): ChordQuality {\n  const semis = new Set(chord.intervals.map((interval) => mod12(interval)));\n  const hasThird = semis.has(4) ? 'maj' : semis.has(3) ? 'min' : undefined;\n  if (hasThird === undefined) {\n    return chord.quality; // sus, power, and other non-tertian chords stand alone\n  }\n  if (semis.has(6) && !semis.has(7)) {\n    return hasThird === 'min' ? 'dim' : 'majb5';\n  }\n  if (semis.has(8) && !semis.has(7)) {\n    return 'aug';\n  }\n  return hasThird;\n}\n\n/** The diatonic triads of a key, one per scale degree. */\nfunction diatonicTriadsOf(key: KeyScale): Chord[] {\n  const degrees = scaleTonesInDegreeOrder(key).length;\n  const triads: Chord[] = [];\n  for (let degree = 0; degree < degrees; degree += 1) {\n    triads.push(diatonicTriad(degree, key));\n  }\n  return triads;\n}\n\n/** Whether two chords share the same root pitch class and quality. */\nfunction sameChord(a: Chord, b: Chord): boolean {\n  return mod12(a.rootPc) === mod12(b.rootPc) && a.quality === b.quality;\n}\n\n/** Root offsets (semitones) that form a third above or below a root. */\nconst THIRD_OFFSETS = [3, 4, 8, 9] as const;\n\n/**\n * Propose substitutions for a chord within a key.\n *\n * Candidates are generated by several relationships and deduplicated against the\n * original chord and each other:\n *\n * - `tritone`: for a dominant-type chord, the dominant seventh a tritone away.\n * - `secondaryDominant`: for a stable target, the dominant seventh a fifth\n *   above its root (tonicizing it).\n * - `relative`: a diatonic triad a third away that shares two common tones.\n * - `borrowed`: a triad from the parallel mode with the same harmonic function.\n * - `chromaticMediant`: a major/minor triad a third away sharing one common\n *   tone.\n *\n * Each result carries its Roman numeral and harmonic function in `key`. When\n * `opts.melodyPcs` is given, only substitutions whose pitch classes contain all\n * of those pitch classes are returned.\n *\n * @param chord The chord to reharmonize.\n * @param key The prevailing key.\n * @param opts Optional melody-preservation constraint.\n * @returns The deduplicated substitution candidates.\n * @example\n * ```ts\n * import { substituteChord, makeChord, majorKey } from '@libraz/libcantus';\n * const subs = substituteChord(makeChord(7, 'dom7'), majorKey(0));\n * // includes the tritone sub Db7 (rootPc 1, quality 'dom7')\n * ```\n * @category Reharmonization\n */\nexport function substituteChord(\n  chord: Chord,\n  key: KeyScale,\n  opts?: SubstituteOptions,\n): Substitution[] {\n  // The relative test counts common tones against the chord's triad, not its\n  // full pitch-class set: an exact count of two would otherwise be decided by\n  // how many tensions the input carries, so C proposes both Em and Am while\n  // Cmaj7 proposes only Am — penalising the candidate that overlaps *more*.\n  const originalTriad = chordPitchClasses(makeChord(chord.rootPc, triadQualityOf(chord)));\n  const candidates: { chord: Chord; type: SubstitutionType }[] = [];\n\n  // Tritone substitution: only for dominant-type chords.\n  if (isDominantType(chord)) {\n    candidates.push({ chord: makeChord(mod12(chord.rootPc + 6), 'dom7'), type: 'tritone' });\n  }\n\n  // Secondary dominant: the V7 tonicizing a stable target.\n  if (isStableTarget(chord)) {\n    candidates.push({\n      chord: makeChord(mod12(chord.rootPc + 7), 'dom7'),\n      type: 'secondaryDominant',\n    });\n  }\n\n  // Relative: a diatonic triad a third away sharing two common tones.\n  for (const triad of diatonicTriadsOf(key)) {\n    const offset = mod12(triad.rootPc - chord.rootPc);\n    if (\n      (THIRD_OFFSETS as readonly number[]).includes(offset) &&\n      commonToneCount(originalTriad, chordPitchClasses(triad)) === 2\n    ) {\n      candidates.push({ chord: triad, type: 'relative' });\n    }\n  }\n\n  // Borrowed: a parallel-mode triad sharing the original's harmonic function.\n  const targetFunction = functionOf(chord, key);\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (functionOf(triad, key) === targetFunction && !isDiatonic(triad, key)) {\n      candidates.push({ chord: triad, type: 'borrowed' });\n    }\n  }\n\n  // Chromatic mediants: major/minor triads a third away sharing one common tone.\n  for (const offset of THIRD_OFFSETS) {\n    for (const quality of ['maj', 'min'] as const) {\n      const mediant = makeChord(mod12(chord.rootPc + offset), quality);\n      if (\n        commonToneCount(originalTriad, chordPitchClasses(mediant)) === 1 &&\n        !isDiatonic(mediant, key)\n      ) {\n        candidates.push({ chord: mediant, type: 'chromaticMediant' });\n      }\n    }\n  }\n\n  const melodyPcs = opts?.melodyPcs?.map(mod12);\n  const seen = new Set<string>();\n  const results: Substitution[] = [];\n  for (const candidate of candidates) {\n    if (sameChord(candidate.chord, chord)) {\n      continue;\n    }\n    const dedupeKey = `${mod12(candidate.chord.rootPc)}:${candidate.chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      continue;\n    }\n    seen.add(dedupeKey);\n    if (melodyPcs !== undefined) {\n      const pcs = new Set(chordPitchClasses(candidate.chord));\n      if (!melodyPcs.every((pc) => pcs.has(pc))) {\n        continue;\n      }\n    }\n    results.push({\n      chord: candidate.chord,\n      type: candidate.type,\n      // A secondary dominant is named as the applied chord it is, so the\n      // numeral re-parses to the chord that was proposed rather than to a\n      // chromatic chord on the same root.\n      roman: chordToRoman(candidate.chord, key, {\n        applied: candidate.type === 'secondaryDominant',\n      }),\n      function: functionOf(candidate.chord, key),\n    });\n  }\n  return results;\n}\n\n/**\n * A borrowed chord in the modal-interchange palette of a key.\n *\n * @category Reharmonization\n */\nexport type BorrowedChord = {\n  chord: Chord;\n  roman: string;\n  source: BorrowedSource;\n};\n\n/**\n * The modal-interchange palette of a key.\n *\n * Lists the diatonic triads of the {@link parallelKey} that are not diatonic to\n * `key` (the classic borrowed chords such as `iv`, `bVI`, and `bVII` in a major\n * key), plus the Neapolitan (a major triad on the flat second degree). Each\n * carries its Roman numeral and {@link borrowedSource} relative to `key`.\n *\n * @param key The prevailing key.\n * @returns The borrowed-chord palette.\n * @category Reharmonization\n */\nexport function modalInterchangePalette(key: KeyScale): BorrowedChord[] {\n  const palette: BorrowedChord[] = [];\n  const seen = new Set<string>();\n  const add = (chord: Chord) => {\n    const dedupeKey = `${mod12(chord.rootPc)}:${chord.quality}`;\n    if (seen.has(dedupeKey)) {\n      return;\n    }\n    seen.add(dedupeKey);\n    palette.push({\n      chord,\n      roman: chordToRoman(chord, key),\n      source: borrowedSource(chord, key),\n    });\n  };\n\n  for (const triad of diatonicTriadsOf(parallelKey(key))) {\n    if (!isDiatonic(triad, key)) {\n      add(triad);\n    }\n  }\n  // The Neapolitan (major triad on b2) sits outside both parallel modes, so it\n  // is added explicitly — unless b2 is already diatonic (e.g. in a Phrygian key,\n  // where it is a native chord rather than a borrowing).\n  const neapolitan = makeChord(mod12(key.rootPc + 1), 'maj');\n  if (!isDiatonic(neapolitan, key)) {\n    add(neapolitan);\n  }\n  return palette;\n}\n\n/**\n * Reflect a chord across the tonic–dominant axis of a key (negative harmony).\n *\n * Every pitch class `p` maps to `(2*T + 7 - p) mod 12`, where `T` is the key\n * tonic — the reflection that swaps the tonic with the dominant. The mirrored\n * pitch classes (including the bass, if set) are reassembled into a chord by\n * {@link detectChordBest}; when no chord is recognized, the mirrored root and\n * the original quality are used as a fallback.\n *\n * @param chord The chord to reflect.\n * @param key The prevailing key.\n * @returns The negative-harmony counterpart of the chord.\n * @example\n * ```ts\n * import { negativeHarmonyMirror, makeChord, majorKey } from '@libraz/libcantus';\n * negativeHarmonyMirror(makeChord(7, 'maj'), majorKey(0));\n * // G major reflected across C's axis => F minor (rootPc 5, quality 'min')\n * ```\n * @category Reharmonization\n */\nexport function negativeHarmonyMirror(chord: Chord, key: KeyScale): Chord {\n  const tonic = mod12(key.rootPc);\n  const mirror = (p: number) => mod12(2 * tonic + 7 - p);\n  const pcs = chordPitchClasses(chord).map(mirror);\n  const bassPc = chord.bassPc !== undefined ? mirror(chord.bassPc) : undefined;\n  // Place the mirrored bass an octave below so it is recognized as the lowest\n  // note and preserved through detection.\n  const pitches = bassPc !== undefined ? [bassPc - 12, ...pcs] : pcs;\n  const detected = detectChordBest(pitches);\n  if (detected) {\n    // Without an input bass the mirrored tones are octave-less, so detection may\n    // read the lowest pitch class as a slash bass and report a spurious\n    // inversion. Restore the recognized chord to root position in that case.\n    if (bassPc === undefined && detected.bassPc !== undefined) {\n      return makeChord(detected.rootPc, detected.quality);\n    }\n    return detected;\n  }\n  const quality: ChordQuality = chord.quality;\n  return makeChord(mirror(chord.rootPc), quality, bassPc);\n}\n"]}