@libraz/libcantus 1.3.0 → 1.4.0

package/dist/{chunk-7KG3RTYS.js → chunk-VL5NXVCN.js}

@@ -1,7 +1,12 @@
+import {
+  canonicalNoteOrder,
+  soundingIndices
+} from "./chunk-TXFWSU5D.js";
 import {
   ARTICULATIONS,
   BEAT_EPS,
   InvalidInputError,
+  assertArray,
   assertFiniteNumber,
   assertInteger,
   assertMidiPitch,
@@ -10,7 +15,7 @@ import {
   assertPositiveInt,
   assertRange,
   describeRejected
-} from "./chunk-AGOVW7U6.js";
+} from "./chunk-YYVXRV3V.js";
 
 // src/core/instrument/profile.ts
 var LIMBS = Object.freeze(["rightHand", "leftHand", "rightFoot", "leftFoot"]);
@@ -80,11 +85,22 @@ function assertProfile(profile) {
   for (const key of voices) {
     assertMidiPitch(Number(key), `${profile.name} reach pitch`);
   }
+  for (const key of voices) {
+    const label = `${profile.name} reach[${key}]`;
+    for (const [index, limb] of assertArray(
+      profile.reach[key],
+      label
+    ).entries()) {
+      assertOneOf(limb, LIMBS, `${label}[${index}]`);
+    }
+  }
   if (voices.every((key) => reachOf(profile, Number(key)).length === 0)) {
     throw new InvalidInputError(`${profile.name} must have at least one voice within reach`);
   }
-  for (const pitch of profile.overdub ?? []) {
-    assertMidiPitch(pitch, `${profile.name} overdub pitch`);
+  if (profile.overdub !== void 0) {
+    for (const pitch of assertArray(profile.overdub, `${profile.name} overdub`)) {
+      assertMidiPitch(pitch, `${profile.name} overdub pitch`);
+    }
   }
 }
 function reachOf(profile, pitch) {
@@ -180,38 +196,32 @@ var MIN_DIFFICULTY = 1;
 var MAX_DIFFICULTY = 5;
 var STRING_CROSSING_COST = 2;
 var SIMULTANEITY_BEATS = 1 / 128;
+var LEGATO_OVERLAP_BEATS = 1 / 16;
 function playability(notes, profile, bpm) {
   assertNoteEvents(notes, "playability notes", { allowNonPositiveDuration: true });
   if (bpm !== void 0) {
     assertRange(bpm, Number.MIN_VALUE, 1e3, "playability bpm");
   }
   const instrument = toInstrumentProfile(profile, "playability profile");
-  const order = 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;
-  });
   const state = {
     notes,
-    order,
+    order: canonicalNoteOrder(notes),
     placements: notes.map((_, index) => ({ note: index })),
     issues: [],
     movement: 0,
     secondsPerBeat: bpm === void 0 ? void 0 : 60 / bpm
   };
+  const attacks = timelineOf(state);
   if (instrument.kind === "stringed") {
     checkExistence(state, instrument, (pitch) => soundsIn(instrument, pitch));
-    placeOnNeck(state, instrument);
+    placeOnNeck(state, instrument, attacks);
   } else {
     const kit = readKit(instrument);
     checkExistence(state, instrument, (pitch) => limbsFor(kit, pitch).length > 0);
-    placeOnKit(state, kit);
+    placeOnKit(state, kit, attacks);
   }
   return {
-    difficulty: difficultyOf(state, bpm),
+    difficulty: difficultyOf(state, attacks, bpm),
     issues: state.issues,
     placements: state.placements
   };
@@ -245,110 +255,228 @@ function checkExistence(state, profile, sounds) {
     }
   }
 }
-function isSimultaneous(anchorBeat, startBeat) {
-  return startBeat - anchorBeat <= SIMULTANEITY_BEATS + BEAT_EPS;
+function isReleased(endBeat, beat) {
+  return endBeat <= beat + LEGATO_OVERLAP_BEATS + BEAT_EPS;
 }
-function soundingGroups(state) {
-  const groups = [];
+function timelineOf(state) {
+  const sounding = new Set(soundingIndices(state.notes));
+  const attacks = [];
   let active = [];
-  let cursor = 0;
-  let anchor;
+  let current;
   for (const index of state.order) {
     const note = state.notes[index];
-    if (!note) {
+    if (!note || !sounding.has(index)) {
       continue;
     }
-    if (anchor !== void 0 && isSimultaneous(anchor, note.startBeat)) {
-      continue;
+    if (!current || note.startBeat - current.startBeat > SIMULTANEITY_BEATS + BEAT_EPS) {
+      const at = note.startBeat;
+      active = active.filter((held) => !isReleased(held.endBeat, at));
+      current = { startBeat: at, members: [], held: [...active] };
+      attacks.push(current);
     }
-    const at = note.startBeat;
-    anchor = at;
-    active = active.filter((member) => {
-      const held = state.notes[member];
-      return held !== void 0 && held.startBeat + held.durationBeat > at + BEAT_EPS;
-    });
-    while (cursor < state.order.length) {
-      const candidateIndex = state.order[cursor];
-      const candidate = candidateIndex === void 0 ? void 0 : state.notes[candidateIndex];
-      if (!candidate || !isSimultaneous(at, candidate.startBeat)) {
-        break;
+    const timed = {
+      index,
+      startBeat: note.startBeat,
+      endBeat: note.startBeat + note.durationBeat,
+      attackBeat: current.startBeat
+    };
+    current.members.push(timed);
+    active.push(timed);
+  }
+  for (const attack of attacks) {
+    attack.members.sort(
+      (a, b) => (state.notes[a.index]?.pitch ?? 0) - (state.notes[b.index]?.pitch ?? 0) || a.index - b.index
+    );
+  }
+  return attacks;
+}
+var MAX_JOINT_PLACEMENT_NOTES = 12;
+var MAX_PLACEMENT_SEARCH_NODES = 2e4;
+function fitsHand(frets, maxStretch) {
+  let low = Number.POSITIVE_INFINITY;
+  let high = Number.NEGATIVE_INFINITY;
+  let count = 0;
+  for (const fret of frets) {
+    if (fret > 0) {
+      low = Math.min(low, fret);
+      high = Math.max(high, fret);
+      count += 1;
+    }
+  }
+  return count < 2 || high - low <= maxStretch;
+}
+function placeGreedily(members, previous, freeAt, heldBy) {
+  const free = [...freeAt];
+  const held = [...heldBy];
+  const picks = [];
+  const conflicts = [];
+  let from = previous;
+  for (const member of members) {
+    const open = member.candidates.filter(
+      (candidate) => isReleased(free[candidate.string] ?? Number.NEGATIVE_INFINITY, member.attackBeat)
+    );
+    if (open.length === 0) {
+      conflicts.push({
+        member,
+        blocked: member.candidates.map((candidate) => held[candidate.string]).filter((value) => value !== void 0)
+      });
+    }
+    const pool = open.length > 0 ? open : member.candidates;
+    const origin = from;
+    const chosen = pool.reduce(
+      (best, candidate) => fingeringCost(candidate, origin) < fingeringCost(best, origin) ? candidate : best
+    );
+    picks.push(chosen);
+    free[chosen.string] = Number.POSITIVE_INFINITY;
+    held[chosen.string] = member.index;
+    from = movedTo(from, chosen);
+  }
+  return { picks, conflicts };
+}
+function searchPlacement(members, previous, freeAt, heldFrets, maxStretch) {
+  const free = [...freeAt];
+  const frets = heldFrets === void 0 ? void 0 : [...heldFrets];
+  const picks = [];
+  let best;
+  let bestCost = Number.POSITIVE_INFINITY;
+  let nodes = 0;
+  const visit = (depth, from, cost) => {
+    if (cost >= bestCost || nodes >= MAX_PLACEMENT_SEARCH_NODES) {
+      return;
+    }
+    const member = members[depth];
+    if (member === void 0) {
+      best = [...picks];
+      bestCost = cost;
+      return;
+    }
+    for (const candidate of member.candidates) {
+      const previousFree = free[candidate.string] ?? Number.NEGATIVE_INFINITY;
+      if (!isReleased(previousFree, member.attackBeat)) {
+        continue;
+      }
+      nodes += 1;
+      if (frets !== void 0) {
+        frets.push(candidate.fret);
+        if (!fitsHand(frets, maxStretch)) {
+          frets.pop();
+          continue;
+        }
       }
-      if (candidateIndex !== void 0 && candidate.startBeat + candidate.durationBeat > at + BEAT_EPS) {
-        active.push(candidateIndex);
+      free[candidate.string] = Number.POSITIVE_INFINITY;
+      picks.push(candidate);
+      visit(depth + 1, movedTo(from, candidate), cost + fingeringCost(candidate, from));
+      picks.pop();
+      free[candidate.string] = previousFree;
+      if (frets !== void 0) {
+        frets.pop();
       }
-      cursor += 1;
     }
-    groups.push({ startBeat: at, members: [...active] });
+  };
+  visit(0, previous, 0);
+  return best;
+}
+function placeAttack(members, previous, freeAt, heldBy, heldFrets, maxStretch) {
+  const greedy = placeGreedily(members, previous, freeAt, heldBy);
+  const soundingFrets = [...heldFrets, ...greedy.picks.map((pick) => pick.fret)];
+  if (greedy.conflicts.length === 0 && fitsHand(soundingFrets, maxStretch)) {
+    return greedy;
+  }
+  if (members.length > MAX_JOINT_PLACEMENT_NOTES) {
+    return greedy;
+  }
+  const fitted = searchPlacement(members, previous, freeAt, heldFrets, maxStretch);
+  if (fitted !== void 0) {
+    return { picks: fitted, conflicts: [] };
+  }
+  if (greedy.conflicts.length > 0) {
+    const loose = searchPlacement(members, previous, freeAt, void 0, maxStretch);
+    if (loose !== void 0) {
+      return { picks: loose, conflicts: [] };
+    }
   }
-  return groups;
+  return greedy;
 }
-function placeOnNeck(state, profile) {
+function placeOnNeck(state, profile, attacks) {
   const stringFreeAt = profile.tuning.map(() => Number.NEGATIVE_INFINITY);
   const stringHeldBy = profile.tuning.map(() => void 0);
-  let previous;
-  let previousIndex;
-  for (const index of state.order) {
-    const note = state.notes[index];
-    const placement = state.placements[index];
-    if (!note || !placement) {
-      continue;
-    }
-    const candidates = fingeringsIn(profile, note.pitch);
-    if (candidates.length === 0) {
-      continue;
-    }
-    const free = candidates.filter(
-      (candidate) => (stringFreeAt[candidate.string] ?? 0) <= note.startBeat + BEAT_EPS
-    );
-    if (free.length === 0) {
-      const blocked = candidates.map((candidate) => stringHeldBy[candidate.string]).filter((held) => held !== void 0);
-      state.issues.push({
-        type: "stringConflict",
-        layer: 2,
-        notes: [.../* @__PURE__ */ new Set([...blocked, index])].sort((a, b) => a - b),
-        startBeat: note.startBeat,
-        impossible: true,
-        message: `MIDI ${note.pitch} needs a string already sounding on ${profile.name}`
-      });
+  let origin = {};
+  let hand;
+  for (const attack of attacks) {
+    const members = [];
+    for (const timed of attack.members) {
+      const note = state.notes[timed.index];
+      const candidates = note === void 0 ? [] : fingeringsIn(profile, note.pitch);
+      if (candidates.length > 0) {
+        members.push({ ...timed, candidates });
+      }
     }
-    const pool = free.length > 0 ? free : candidates;
-    const chosen = pool.reduce(
-      (best, candidate) => fingeringCost(candidate, previous) < fingeringCost(best, previous) ? candidate : best
+    const heldFrets = attack.held.map((held) => state.placements[held.index]?.fingering?.fret).filter((fret) => fret !== void 0);
+    const { picks, conflicts } = placeAttack(
+      members,
+      origin,
+      stringFreeAt,
+      stringHeldBy,
+      heldFrets,
+      profile.maxStretch
     );
-    placement.fingering = chosen;
-    stringFreeAt[chosen.string] = note.startBeat + note.durationBeat;
-    stringHeldBy[chosen.string] = index;
-    state.movement += 1;
-    if (previous) {
-      state.movement += Math.abs(chosen.fret - previous.fret) + Math.abs(chosen.string - previous.string);
-      checkShiftSpeed(state, profile, previousIndex, index, previous, chosen);
+    let shifted = hand;
+    members.forEach((member, k) => {
+      const chosen = picks[k];
+      const placement = state.placements[member.index];
+      if (!chosen || !placement) {
+        return;
+      }
+      const conflict = conflicts.find((entry) => entry.member === member);
+      const note = state.notes[member.index];
+      if (conflict && note) {
+        state.issues.push({
+          type: "stringConflict",
+          layer: 2,
+          notes: [.../* @__PURE__ */ new Set([...conflict.blocked, member.index])].sort((a, b) => a - b),
+          startBeat: member.startBeat,
+          impossible: true,
+          message: `MIDI ${note.pitch} needs a string already sounding on ${profile.name}`
+        });
+      }
+      placement.fingering = chosen;
+      stringFreeAt[chosen.string] = member.endBeat;
+      stringHeldBy[chosen.string] = member.index;
+      state.movement += 1;
+      if (origin.string !== void 0) {
+        state.movement += Math.abs(chosen.string - origin.string);
+      }
+      origin = movedTo(origin, chosen);
+      if (chosen.fret > 0) {
+        shifted = { note: member, fingering: chosen };
+      }
+    });
+    if (hand && shifted && shifted !== hand) {
+      state.movement += Math.abs(shifted.fingering.fret - hand.fingering.fret);
+      checkShiftSpeed(state, profile, hand, shifted);
     }
-    previous = chosen;
-    previousIndex = index;
+    hand = shifted;
   }
-  for (const group of soundingGroups(state)) {
-    checkStretch(state, profile, group);
-    checkPolyphony(state, profile, group);
+  for (const attack of attacks) {
+    checkStretch(state, profile, attack);
+    checkPolyphony(state, profile, { startBeat: attack.startBeat, members: soundingAt(attack) });
   }
 }
-function fingeringCost(candidate, previous) {
-  if (!previous) {
-    return candidate.fret + candidate.string / 100;
-  }
-  return Math.abs(candidate.fret - previous.fret) + STRING_CROSSING_COST * Math.abs(candidate.string - previous.string) + candidate.string / 100;
+function movedTo(origin, chosen) {
+  return { string: chosen.string, fret: chosen.fret > 0 ? chosen.fret : origin.fret };
+}
+function fingeringCost(candidate, origin) {
+  const stopped = candidate.fret === 0 ? 0 : origin.fret === void 0 ? candidate.fret : Math.abs(candidate.fret - origin.fret);
+  const crossing = origin.string === void 0 ? 0 : STRING_CROSSING_COST * Math.abs(candidate.string - origin.string);
+  return stopped + crossing + candidate.string / 100;
 }
-function checkShiftSpeed(state, profile, fromIndex, toIndex, from, to) {
+function checkShiftSpeed(state, profile, from, to) {
   const secondsPerBeat = state.secondsPerBeat;
-  if (secondsPerBeat === void 0 || fromIndex === void 0) {
-    return;
-  }
-  const previousNote = state.notes[fromIndex];
-  const note = state.notes[toIndex];
-  if (!previousNote || !note) {
+  if (secondsPerBeat === void 0) {
     return;
   }
-  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
-  const shift = Math.abs(to.fret - from.fret);
+  const seconds = (to.note.attackBeat - from.note.attackBeat) * secondsPerBeat;
+  const shift = Math.abs(to.fingering.fret - from.fingering.fret);
   if (seconds <= BEAT_EPS || shift === 0) {
     return;
   }
@@ -356,15 +484,19 @@ function checkShiftSpeed(state, profile, fromIndex, toIndex, from, to) {
     state.issues.push({
       type: "tooFast",
       layer: 3,
-      notes: [fromIndex, toIndex].sort((a, b) => a - b),
-      startBeat: note.startBeat,
+      notes: [from.note.index, to.note.index].sort((a, b) => a - b),
+      startBeat: to.note.startBeat,
       impossible: false,
       message: `a ${shift}-fret shift in ${seconds.toFixed(3)}s is beyond ${profile.name}`
     });
   }
 }
-function checkStretch(state, profile, group) {
-  const frets = group.members.map((member) => state.placements[member]?.fingering).filter(
+function soundingAt(attack) {
+  return [...attack.held, ...attack.members].map((timed) => timed.index);
+}
+function checkStretch(state, profile, attack) {
+  const sounding = soundingAt(attack);
+  const frets = sounding.map((member) => state.placements[member]?.fingering).filter(
     (fingering) => fingering !== void 0 && fingering.fret > 0
   ).map((fingering) => fingering.fret);
   if (frets.length < 2) {
@@ -375,8 +507,8 @@ function checkStretch(state, profile, group) {
     state.issues.push({
       type: "stretchTooWide",
       layer: 2,
-      notes: [...group.members].sort((a, b) => a - b),
-      startBeat: group.startBeat,
+      notes: sounding.sort((a, b) => a - b),
+      startBeat: attack.startBeat,
       impossible: true,
       message: `a ${span}-fret stretch exceeds the ${profile.maxStretch} frets one hand spans on ${profile.name}`
     });
@@ -413,10 +545,10 @@ function limbsFor(kit, pitch) {
 function passesAt(state, kit, members) {
   const played = { id: "kit", members: [] };
   const overdubs = /* @__PURE__ */ new Map();
-  for (const index of members) {
-    const pitch = state.notes[index]?.pitch;
+  for (const member of members) {
+    const pitch = state.notes[member.index]?.pitch;
     if (pitch === void 0 || !kit.overdub.has(pitch)) {
-      played.members.push(index);
+      played.members.push(member);
       continue;
     }
     let pass = overdubs.get(pitch);
@@ -424,7 +556,7 @@ function passesAt(state, kit, members) {
       pass = { id: `overdub ${pitch}`, members: [] };
       overdubs.set(pitch, pass);
     }
-    pass.members.push(index);
+    pass.members.push(member);
   }
   return [played, ...overdubs.values()];
 }
@@ -432,13 +564,13 @@ function placePass(state, kit, pass, memory) {
   const taken = /* @__PURE__ */ new Set();
   let conflicted = false;
   const members = [...pass.members].sort((a, b) => {
-    const left = limbsFor(kit, state.notes[a]?.pitch);
-    const right = limbsFor(kit, state.notes[b]?.pitch);
-    return left.length - right.length || a - b;
+    const left = limbsFor(kit, state.notes[a.index]?.pitch);
+    const right = limbsFor(kit, state.notes[b.index]?.pitch);
+    return left.length - right.length || a.index - b.index;
   });
-  for (const index of members) {
-    const note = state.notes[index];
-    const placement = state.placements[index];
+  for (const member of members) {
+    const note = state.notes[member.index];
+    const placement = state.placements[member.index];
     if (!note || !placement) {
       continue;
     }
@@ -460,23 +592,24 @@ function placePass(state, kit, pass, memory) {
     memory.limbForVoice.set(note.pitch, chosen);
     state.movement += 1;
     const strokeKey = `${pass.id} ${chosen}`;
-    const previousIndex = memory.lastStroke.get(strokeKey);
-    if (previousIndex !== void 0) {
-      const previousNote = state.notes[previousIndex];
+    const previousStroke = memory.lastStroke.get(strokeKey);
+    if (previousStroke !== void 0) {
+      const previousNote = state.notes[previousStroke.index];
       if (previousNote && previousNote.pitch !== note.pitch) {
         state.movement += 1;
       }
-      checkStrokeSpeed(state, kit.profile, previousIndex, index, chosen);
+      checkStrokeSpeed(state, kit.profile, previousStroke, member, chosen);
     }
-    memory.lastStroke.set(strokeKey, index);
+    memory.lastStroke.set(strokeKey, member);
   }
   return conflicted;
 }
-function placeOnKit(state, kit) {
+function placeOnKit(state, kit, attacks) {
   const memory = { limbForVoice: /* @__PURE__ */ new Map(), lastStroke: /* @__PURE__ */ new Map() };
-  for (const group of onsetGroups(state)) {
+  for (const attack of attacks) {
+    const strokes = attack.members.map((member) => member.index);
     let conflicted = false;
-    for (const pass of passesAt(state, kit, group.members)) {
+    for (const pass of passesAt(state, kit, attack.members)) {
       if (!placePass(state, kit, pass, memory)) {
         continue;
       }
@@ -484,65 +617,43 @@ function placeOnKit(state, kit) {
       state.issues.push({
         type: "limbConflict",
         layer: 2,
-        notes: [...pass.members].sort((a, b) => a - b),
-        startBeat: group.startBeat,
+        notes: pass.members.map((member) => member.index).sort((a, b) => a - b),
+        startBeat: attack.startBeat,
         impossible: true,
         message: `${pass.members.length} simultaneous strokes cannot be shared among the limbs of ${kit.profile.name}`
       });
     }
     if (!conflicted) {
-      checkPolyphony(state, kit.profile, group);
+      checkPolyphony(state, kit.profile, { startBeat: attack.startBeat, members: strokes });
     }
   }
 }
-function checkStrokeSpeed(state, profile, fromIndex, toIndex, limb) {
+function checkStrokeSpeed(state, profile, from, to, limb) {
   const secondsPerBeat = state.secondsPerBeat;
   if (secondsPerBeat === void 0) {
     return;
   }
-  const previousNote = state.notes[fromIndex];
-  const note = state.notes[toIndex];
-  if (!previousNote || !note) {
-    return;
-  }
-  const seconds = (note.startBeat - previousNote.startBeat) * secondsPerBeat;
+  const seconds = (to.attackBeat - from.attackBeat) * secondsPerBeat;
   if (seconds <= BEAT_EPS || seconds >= MIN_LIMB_STROKE_SECONDS) {
     return;
   }
   state.issues.push({
     type: "tooFast",
     layer: 3,
-    notes: [fromIndex, toIndex].sort((a, b) => a - b),
-    startBeat: note.startBeat,
+    notes: [from.index, to.index].sort((a, b) => a - b),
+    startBeat: to.startBeat,
     impossible: false,
     message: `${limb} strikes twice ${seconds.toFixed(3)}s apart on ${profile.name}`
   });
 }
-function onsetGroups(state) {
-  const groups = [];
-  let current;
-  for (const index of state.order) {
-    const note = state.notes[index];
-    if (!note || note.durationBeat <= 0) {
-      continue;
-    }
-    if (!current || !isSimultaneous(current.startBeat, note.startBeat)) {
-      current = { startBeat: note.startBeat, members: [] };
-      groups.push(current);
-    }
-    current.members.push(index);
-  }
-  return groups;
-}
-function difficultyOf(state, bpm) {
+function difficultyOf(state, attacks, bpm) {
   let first = Number.POSITIVE_INFINITY;
   let last = Number.NEGATIVE_INFINITY;
-  for (const note of state.notes) {
-    if (!note) {
-      continue;
+  for (const attack of attacks) {
+    for (const member of attack.members) {
+      first = Math.min(first, member.startBeat);
+      last = Math.max(last, member.endBeat);
     }
-    first = Math.min(first, note.startBeat);
-    last = Math.max(last, note.startBeat + Math.max(0, note.durationBeat));
   }
   const spanBeats = last - first;
   if (!Number.isFinite(spanBeats) || spanBeats <= BEAT_EPS) {
@@ -668,6 +779,20 @@ function hashPath(domain, root, path) {
   }
   return fmix32(hash);
 }
+var stepBytes = new DataView(new ArrayBuffer(8));
+function scaleUnitDraw(unit, lo, hi) {
+  const value = lo + unit * (hi - lo);
+  if (value < hi || lo === hi) {
+    return value;
+  }
+  if (hi === 0) {
+    return -Number.MIN_VALUE;
+  }
+  stepBytes.setFloat64(0, hi);
+  const bits = stepBytes.getBigUint64(0);
+  stepBytes.setBigUint64(0, hi > 0 ? bits - 1n : bits + 1n);
+  return stepBytes.getFloat64(0);
+}
 
 // src/core/random/positional.ts
 function createPositionalRng(seed) {
@@ -744,7 +869,7 @@ function createRng(seed) {
         );
       }
       assertFiniteNumber(hi - lo, "float span");
-      return lo + next() * (hi - lo);
+      return scaleUnitDraw(next(), lo, hi);
     }
   };
 }
@@ -766,6 +891,7 @@ export {
   BASS_5_STRING,
   GUITAR_STANDARD,
   GUITAR_DROP_D,
+  scaleUnitDraw,
   createPositionalRng,
   includeAt,
   deriveSeed,
@@ -774,4 +900,4 @@ export {
   resolveAlgorithmVersion,
   createRng
 };
-//# sourceMappingURL=chunk-7KG3RTYS.js.map
+//# sourceMappingURL=chunk-VL5NXVCN.js.map