@libraz/libcantus 1.3.0 → 1.4.0

package/dist/{chunk-35NBV2FT.cjs → chunk-KMYGRFZ6.cjs}

@@ -3,7 +3,9 @@
 
 
 
-var _chunkS5BKZZGMcjs = require('./chunk-S5BKZZGM.cjs');
+
+
+var _chunkS3QELJUEcjs = require('./chunk-S3QELJUE.cjs');
 
 // src/core/event-index/index.ts
 function upperBound(values, beat) {
@@ -11,7 +13,7 @@ function upperBound(values, beat) {
   let high = values.length;
   while (low < high) {
     const middle = Math.floor((low + high) / 2);
-    if ((_nullishCoalesce(_optionalChain([values, 'access', _ => _[middle], 'optionalAccess', _2 => _2.note, 'access', _3 => _3.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
+    if ((_nullishCoalesce(_optionalChain([values, 'access', _2 => _2[middle], 'optionalAccess', _3 => _3.note, 'access', _4 => _4.startBeat]), () => ( Number.POSITIVE_INFINITY))) <= beat) {
       low = middle + 1;
     } else {
       high = middle;
@@ -25,9 +27,9 @@ function sortedNoteEvents(events) {
   return sorted;
 }
 function createNoteEventIndex(events, options = {}) {
-  const asked = _chunkS5BKZZGMcjs.assertOptions.call(void 0, options, "options");
-  _chunkS5BKZZGMcjs.assertNoteEvents.call(void 0, events, _nullishCoalesce(asked.name, () => ( "note events")), asked);
-  const tieBreak = _nullishCoalesce(asked.tieBreak, () => ( "highest"));
+  const asked = _chunkS3QELJUEcjs.assertOptions.call(void 0, options, "options");
+  _chunkS3QELJUEcjs.assertNoteEvents.call(void 0, events, _nullishCoalesce(asked.name, () => ( "note events")), asked);
+  const tieBreak = asked.tieBreak === void 0 || asked.tieBreak === null ? "highest" : _chunkS3QELJUEcjs.assertOneOf.call(void 0, asked.tieBreak, ["highest", "lowest", "last"], "options.tieBreak");
   const notes = Object.freeze(
     events.map(
       (note, originalIndex) => Object.freeze({
@@ -47,7 +49,7 @@ function createNoteEventIndex(events, options = {}) {
     while (treeSize < notes.length) treeSize *= 2;
     const tree = new Array(treeSize * 2).fill(Number.NEGATIVE_INFINITY);
     for (let index = 0; index < notes.length; index += 1) {
-      tree[treeSize + index] = _nullishCoalesce(_optionalChain([notes, 'access', _4 => _4[index], 'optionalAccess', _5 => _5.endBeat]), () => ( Number.NEGATIVE_INFINITY));
+      tree[treeSize + index] = _nullishCoalesce(_optionalChain([notes, 'access', _5 => _5[index], 'optionalAccess', _6 => _6.endBeat]), () => ( Number.NEGATIVE_INFINITY));
     }
     for (let index = treeSize - 1; index > 0; index -= 1) {
       tree[index] = Math.max(
@@ -61,7 +63,7 @@ function createNoteEventIndex(events, options = {}) {
   const latestActiveIndex = (exclusive, beat) => {
     const tree = endTree();
     const find = (node, start, end) => {
-      if (start >= exclusive || (_nullishCoalesce(tree[node], () => ( Number.NEGATIVE_INFINITY))) <= beat + _chunkS5BKZZGMcjs.BEAT_EPS) {
+      if (start >= exclusive || (_nullishCoalesce(tree[node], () => ( Number.NEGATIVE_INFINITY))) <= beat + _chunkS3QELJUEcjs.BEAT_EPS) {
         return -1;
       }
       if (end - start === 1) return start < notes.length ? start : -1;
@@ -74,22 +76,25 @@ function createNoteEventIndex(events, options = {}) {
   return {
     notes,
     at(beat) {
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, beat, "beat");
-      const index = latestActiveIndex(upperBound(notes, beat + _chunkS5BKZZGMcjs.BEAT_EPS), beat);
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, beat, "beat");
+      const index = latestActiveIndex(upperBound(notes, beat + _chunkS3QELJUEcjs.BEAT_EPS), beat);
       if (index < 0) return void 0;
-      const onset = _optionalChain([notes, 'access', _6 => _6[index], 'optionalAccess', _7 => _7.note, 'access', _8 => _8.startBeat]);
+      const onset = _nullishCoalesce(_optionalChain([notes, 'access', _7 => _7[index], 'optionalAccess', _8 => _8.note, 'access', _9 => _9.startBeat]), () => ( 0));
       let best;
       for (let candidateIndex = index; candidateIndex >= 0; candidateIndex -= 1) {
         const indexed = notes[candidateIndex];
-        if (indexed !== void 0 && indexed.note.startBeat !== onset) break;
-        if (indexed === void 0 || indexed.note.durationBeat <= 0 || indexed.note.startBeat - _chunkS5BKZZGMcjs.BEAT_EPS > beat || beat >= indexed.endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+        if (indexed !== void 0 && Math.abs(indexed.note.startBeat - onset) >= _chunkS3QELJUEcjs.BEAT_EPS) break;
+        if (indexed === void 0 || indexed.note.durationBeat <= 0 || indexed.note.startBeat - _chunkS3QELJUEcjs.BEAT_EPS > beat || beat >= indexed.endBeat - _chunkS3QELJUEcjs.BEAT_EPS) {
           continue;
         }
         if (best === void 0) {
           best = indexed;
           continue;
         }
-        if (tieBreak === "last") continue;
+        if (tieBreak === "last") {
+          if (indexed.originalIndex > best.originalIndex) best = indexed;
+          continue;
+        }
         const difference = indexed.note.pitch - best.note.pitch;
         const wins = difference === 0 ? indexed.originalIndex < best.originalIndex : difference > 0 === (tieBreak === "highest");
         if (wins) {
@@ -99,11 +104,11 @@ function createNoteEventIndex(events, options = {}) {
       return best;
     },
     attacksAt(beat) {
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, beat, "beat");
-      let index = upperBound(notes, beat + _chunkS5BKZZGMcjs.BEAT_EPS) - 1;
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, beat, "beat");
+      let index = upperBound(notes, beat + _chunkS3QELJUEcjs.BEAT_EPS) - 1;
       while (index >= 0) {
         const candidate = notes[index];
-        if (candidate === void 0 || Math.abs(candidate.note.startBeat - beat) >= _chunkS5BKZZGMcjs.BEAT_EPS) {
+        if (candidate === void 0 || Math.abs(candidate.note.startBeat - beat) >= _chunkS3QELJUEcjs.BEAT_EPS) {
           return false;
         }
         if (candidate.note.durationBeat > 0) {
@@ -114,14 +119,14 @@ function createNoteEventIndex(events, options = {}) {
       return false;
     },
     onsetsBetween(startBeat, endBeat) {
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, startBeat, "startBeat");
-      _chunkS5BKZZGMcjs.assertFiniteNumber.call(void 0, endBeat, "endBeat");
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, startBeat, "startBeat");
+      _chunkS3QELJUEcjs.assertFiniteNumber.call(void 0, endBeat, "endBeat");
       const result = [];
-      let index = upperBound(notes, startBeat + _chunkS5BKZZGMcjs.BEAT_EPS);
+      let index = upperBound(notes, startBeat + _chunkS3QELJUEcjs.BEAT_EPS);
       while (index < notes.length) {
         const indexed = notes[index];
-        const onset = _optionalChain([indexed, 'optionalAccess', _9 => _9.note, 'access', _10 => _10.startBeat]);
-        if (indexed === void 0 || onset === void 0 || onset >= endBeat - _chunkS5BKZZGMcjs.BEAT_EPS) {
+        const onset = _optionalChain([indexed, 'optionalAccess', _10 => _10.note, 'access', _11 => _11.startBeat]);
+        if (indexed === void 0 || onset === void 0 || onset >= endBeat - _chunkS3QELJUEcjs.BEAT_EPS) {
           break;
         }
         index += 1;
@@ -129,7 +134,7 @@ function createNoteEventIndex(events, options = {}) {
           continue;
         }
         const previous = result[result.length - 1];
-        if (previous === void 0 || Math.abs(previous - onset) >= _chunkS5BKZZGMcjs.BEAT_EPS) {
+        if (previous === void 0 || Math.abs(previous - onset) >= _chunkS3QELJUEcjs.BEAT_EPS) {
           result.push(onset);
         }
       }
@@ -138,8 +143,26 @@ function createNoteEventIndex(events, options = {}) {
   };
 }
 
+// src/core/event-index/order.ts
+function canonicalNoteOrder(notes) {
+  return notes.map((_, index) => index).sort((a, b) => {
+    const left = notes[a];
+    const right = notes[b];
+    if (!left || !right) {
+      return a - b;
+    }
+    return left.startBeat - right.startBeat || left.pitch - right.pitch || a - b;
+  });
+}
+function soundingIndices(notes) {
+  const sounding = new Set(_chunkS3QELJUEcjs.dropSilentNotes.call(void 0, notes));
+  return notes.flatMap((note, index) => sounding.has(note) ? [index] : []);
+}
+
+
+
 
 
 
-exports.sortedNoteEvents = sortedNoteEvents; exports.createNoteEventIndex = createNoteEventIndex;
-//# sourceMappingURL=chunk-35NBV2FT.cjs.map
+exports.sortedNoteEvents = sortedNoteEvents; exports.createNoteEventIndex = createNoteEventIndex; exports.canonicalNoteOrder = canonicalNoteOrder; exports.soundingIndices = soundingIndices;
+//# sourceMappingURL=chunk-KMYGRFZ6.cjs.map

package/dist/chunk-KMYGRFZ6.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/libcantus/libcantus/ts/dist/chunk-KMYGRFZ6.cjs","../src/core/event-index/index.ts","../src/core/event-index/order.ts"],"names":[],"mappings":"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","file":"/home/runner/work/libcantus/libcantus/ts/dist/chunk-KMYGRFZ6.cjs","sourcesContent":[null,"import { BEAT_EPS } from '../meter/internal.js';\nimport type { NoteEvent } from '../types.js';\nimport {\n  assertFiniteNumber,\n  assertNoteEvents,\n  assertOneOf,\n  assertOptions,\n} 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  readonly note: Readonly<NoteEvent>;\n  readonly originalIndex: number;\n  readonly 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. Two notes of the same pitch name no voice apart,\n * so both voice tie-breaks settle a unison on the lower `originalIndex` and\n * name the same note.\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: readonly IndexedNoteEvent[];\n  /**\n   * Latest-onset note sounding at `beat`. Simultaneous onsets are resolved by\n   * the index's {@link OnsetTieBreak}.\n   *\n   * @throws If `beat` is not finite.\n   */\n  at: (beat: number) => IndexedNoteEvent | undefined;\n  /**\n   * Whether one or more sounding notes attack at `beat`.\n   *\n   * @throws If `beat` is not finite.\n   */\n  attacksAt: (beat: number) => boolean;\n  /**\n   * Unique sounding-note attack beats strictly inside `(startBeat, endBeat)`.\n   *\n   * @throws If either bound is not finite.\n   */\n  onsetsBetween: (startBeat: number, endBeat: number) => number[];\n};\n\nfunction upperBound(values: readonly 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 * Copy note events and put them in stable onset order.\n *\n * The order is the one {@link createNoteEventIndex} numbers its notes in, so a\n * pass may read the sequence here and the index there and see the same notes in\n * the same places. What it does not build is the index itself: a caller that\n * only walks the notes in time order would otherwise pay for a segment tree and\n * a wrapper per note that it never queries.\n *\n * The events are copied, so the sequence is the caller's own and two entries\n * that arrived as one shared object stay two.\n *\n * @param events The events to order; already validated by the caller.\n * @returns The copies, earliest onset first, ties in input order.\n */\nexport function sortedNoteEvents(events: readonly NoteEvent[]): NoteEvent[] {\n  const sorted = events.map((note) => ({ ...note }));\n  // Array sort is stable, so events sharing an onset keep the order they were\n  // given in — the tie-break the index spells out as `originalIndex`.\n  sorted.sort((a, b) => a.startBeat - b.startBeat);\n  return sorted;\n}\n\n/**\n * How an index reads the events it is built from.\n *\n * @category Core\n */\nexport type NoteEventIndexOptions = {\n  allowNonPositiveDuration?: boolean;\n  tieBreak?: OnsetTieBreak;\n  budget?: number;\n  /** What the events are, for the validation error message. */\n  name?: string;\n};\n\n/**\n * Validate and stable-sort note events once, then expose onset and active-note\n * lookups that cost `O(log n + k)`, where `k` is how many notes share the onset\n * the answer comes from. Non-positive-duration notes may be retained for\n * callers that intentionally filter them later, but never count as sounding.\n *\n * @category Core\n */\nexport function createNoteEventIndex(\n  events: readonly NoteEvent[],\n  options: NoteEventIndexOptions = {},\n): NoteEventIndex {\n  const asked = assertOptions(options, 'options');\n  assertNoteEvents(events, asked.name ?? 'note events', asked);\n  const tieBreak: OnsetTieBreak =\n    asked.tieBreak === undefined || asked.tieBreak === null\n      ? 'highest'\n      : assertOneOf(asked.tieBreak, ['highest', 'lowest', 'last'], 'options.tieBreak');\n  // Each wrapper is frozen, not only the array and the note inside it: `endBeat`\n  // is what the active-note search is built from, so a host that writes to it\n  // would leave the index answering from a span nothing else knows about.\n  const notes = Object.freeze(\n    events\n      .map((note, originalIndex) =>\n        Object.freeze({\n          note: Object.freeze({ ...note }),\n          originalIndex,\n          endBeat: note.startBeat + note.durationBeat,\n        }),\n      )\n      .sort((a, b) => a.note.startBeat - b.note.startBeat || a.originalIndex - b.originalIndex),\n  );\n  // Segment-tree maxima find the latest active onset in logarithmic time even\n  // when an early, very long note would defeat a prefix-max backwards scan.\n  //\n  // It is built on the first `at` query rather than on construction: the onset\n  // queries answer from the sorted notes alone, so a caller that never asks\n  // which note is sounding would otherwise pay for a structure it never reads.\n  let maxEndTree: number[] | undefined;\n  let treeSize = 0;\n  const endTree = (): number[] => {\n    if (maxEndTree !== undefined) {\n      return maxEndTree;\n    }\n    treeSize = 1;\n    while (treeSize < notes.length) treeSize *= 2;\n    const tree = new Array<number>(treeSize * 2).fill(Number.NEGATIVE_INFINITY);\n    for (let index = 0; index < notes.length; index += 1) {\n      tree[treeSize + index] = notes[index]?.endBeat ?? Number.NEGATIVE_INFINITY;\n    }\n    for (let index = treeSize - 1; index > 0; index -= 1) {\n      tree[index] = Math.max(\n        tree[index * 2] ?? Number.NEGATIVE_INFINITY,\n        tree[index * 2 + 1] ?? Number.NEGATIVE_INFINITY,\n      );\n    }\n    maxEndTree = tree;\n    return tree;\n  };\n  const latestActiveIndex = (exclusive: number, beat: number): number => {\n    const tree = endTree();\n    const find = (node: number, start: number, end: number): number => {\n      if (start >= exclusive || (tree[node] ?? Number.NEGATIVE_INFINITY) <= beat + BEAT_EPS) {\n        return -1;\n      }\n      if (end - start === 1) return start < notes.length ? start : -1;\n      const mid = Math.floor((start + end) / 2);\n      const right = find(node * 2 + 1, mid, end);\n      return right >= 0 ? right : find(node * 2, start, mid);\n    };\n    return find(1, 0, treeSize);\n  };\n\n  return {\n    notes,\n    at(beat) {\n      // A query beat comes from wherever the host got it — a scrub position, a\n      // parsed field — so it is checked like any other entry argument. `NaN`\n      // compares false against every bound, which would read as an open window\n      // rather than as the missing value it is.\n      assertFiniteNumber(beat, 'beat');\n      const index = latestActiveIndex(upperBound(notes, beat + BEAT_EPS), beat);\n      if (index < 0) return undefined;\n      const onset = notes[index]?.note.startBeat ?? 0;\n      let best: IndexedNoteEvent | undefined;\n      for (let candidateIndex = index; candidateIndex >= 0; candidateIndex -= 1) {\n        const indexed = notes[candidateIndex];\n        if (indexed !== undefined && Math.abs(indexed.note.startBeat - onset) >= BEAT_EPS) break;\n        if (\n          indexed === undefined ||\n          indexed.note.durationBeat <= 0 ||\n          indexed.note.startBeat - BEAT_EPS > beat ||\n          beat >= indexed.endBeat - BEAT_EPS\n        ) {\n          continue;\n        }\n        if (best === undefined) {\n          best = indexed;\n          continue;\n        }\n        // Onsets inside one BEAT_EPS group are not in input order, so 'last' compares indices.\n        if (tieBreak === 'last') {\n          if (indexed.originalIndex > best.originalIndex) best = indexed;\n          continue;\n        }\n        const difference = indexed.note.pitch - best.note.pitch;\n        // Equal pitches name no voice apart, so they are settled on the lower\n        // original index rather than on whichever end of the array the scan\n        // happens to reach last — otherwise `'highest'` and `'lowest'` would\n        // answer a unison differently.\n        const wins =\n          difference === 0\n            ? indexed.originalIndex < best.originalIndex\n            : difference > 0 === (tieBreak === 'highest');\n        if (wins) {\n          best = indexed;\n        }\n      }\n      return best;\n    },\n    attacksAt(beat) {\n      assertFiniteNumber(beat, '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 + BEAT_EPS) - 1;\n      while (index >= 0) {\n        const candidate = notes[index];\n        if (candidate === undefined || Math.abs(candidate.note.startBeat - beat) >= 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      assertFiniteNumber(startBeat, 'startBeat');\n      assertFiniteNumber(endBeat, 'endBeat');\n      const result: number[] = [];\n      let index = upperBound(notes, startBeat + BEAT_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 - BEAT_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) >= BEAT_EPS) {\n          result.push(onset);\n        }\n      }\n      return result;\n    },\n  };\n}\n","import type { NoteEvent } from '../types.js';\nimport { dropSilentNotes } from '../validation/index.js';\n\n/**\n * Indices of the notes in canonical order: by onset, then by pitch, then by\n * position in the array.\n *\n * Every pass that reads a note against the one before or after it walks the\n * notes in this order, so two listings of the same notes give the same answer.\n *\n * @param notes Validated note events.\n * @returns Every index of `notes`, once.\n */\nexport function canonicalNoteOrder(notes: readonly NoteEvent[]): number[] {\n  return notes\n    .map((_, index) => index)\n    .sort((a, b) => {\n      const left = notes[a];\n      const right = notes[b];\n      if (!left || !right) {\n        return a - b;\n      }\n      return left.startBeat - right.startBeat || left.pitch - right.pitch || a - b;\n    });\n}\n\n/**\n * Indices of the notes {@link dropSilentNotes} keeps, in input order.\n *\n * For a pass that reports one entry per input note and so cannot drop the\n * silent ones from the array itself.\n *\n * @param notes Validated note events.\n * @returns The indices of the notes with a positive duration, ascending.\n */\nexport function soundingIndices(notes: readonly NoteEvent[]): number[] {\n  const sounding = new Set(dropSilentNotes(notes));\n  return notes.flatMap((note, index) => (sounding.has(note) ? [index] : []));\n}\n"]}