spessasynth_lib 3.16.5 → 3.20.0

package/@types/index.d.ts

@@ -2,11 +2,12 @@ import { Sequencer } from './sequencer/sequencer.js';
 import { Synthetizer } from './synthetizer/synthetizer.js';
 import { DEFAULT_PERCUSSION } from './synthetizer/synthetizer.js';
 import { VOICE_CAP } from './synthetizer/synthetizer.js';
-import { SoundFont2 } from './soundfont/soundfont.js';
+import { loadSoundFont } from "./soundfont/load_soundfont.js";
 import { trimSoundfont } from "./soundfont/basic_soundfont/write_sf2/soundfont_trimmer.js";
 import { modulatorSources } from "./soundfont/read_sf2/modulators.js";
 import { encodeVorbis } from "./utils/encode_vorbis.js";
 import { MIDI } from './midi_parser/midi_loader.js';
+import { MIDIBuilder } from "./midi_parser/midi_builder.js";
 import { IndexedByteArray } from './utils/indexed_array.js';
 import { writeMIDIFile } from './midi_parser/midi_writer.js';
 import { writeRMIDI } from './midi_parser/rmidi_writer.js';
@@ -22,8 +23,8 @@ import { SpessaSynthWarn } from './utils/loggin.js';
 import { SpessaSynthGroupCollapsed } from './utils/loggin.js';
 import { midiControllers } from './midi_parser/midi_message.js';
 import { messageTypes } from './midi_parser/midi_message.js';
-import { MIDIDeviceHandler } from './midi_handler/midi_handler.js';
-import { WebMidiLinkHandler } from './midi_handler/web_midi_link.js';
+import { MIDIDeviceHandler } from "./external_midi/midi_handler.js";
+import { WebMidiLinkHandler } from "./external_midi/web_midi_link.js";
 import { arrayToHexString } from './utils/other.js';
 import { consoleColors } from './utils/other.js';
 import { formatTitle } from './utils/other.js';
@@ -32,4 +33,4 @@ import { readBytesAsUintBigEndian } from './utils/byte_functions/big_endian.js';
 import { NON_CC_INDEX_OFFSET } from './synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.js';
 import { ALL_CHANNELS_OR_DIFFERENT_ACTION } from './synthetizer/worklet_system/message_protocol/worklet_message.js';
 import { WORKLET_URL_ABSOLUTE } from './synthetizer/worklet_url.js';
-export { Sequencer, Synthetizer, DEFAULT_PERCUSSION, VOICE_CAP, SoundFont2, trimSoundfont, modulatorSources, encodeVorbis, MIDI, IndexedByteArray, writeMIDIFile, writeRMIDI, applySnapshotToMIDI, modifyMIDI, audioBufferToWav, SpessaSynthLogging, SpessaSynthGroup, SpessaSynthTable, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn, SpessaSynthGroupCollapsed, midiControllers, messageTypes, MIDIDeviceHandler, WebMidiLinkHandler, arrayToHexString, consoleColors, formatTitle, formatTime, readBytesAsUintBigEndian, NON_CC_INDEX_OFFSET, ALL_CHANNELS_OR_DIFFERENT_ACTION, WORKLET_URL_ABSOLUTE };
+export { Sequencer, Synthetizer, DEFAULT_PERCUSSION, VOICE_CAP, loadSoundFont, trimSoundfont, modulatorSources, encodeVorbis, MIDI, MIDIBuilder, IndexedByteArray, writeMIDIFile, writeRMIDI, applySnapshotToMIDI, modifyMIDI, audioBufferToWav, SpessaSynthLogging, SpessaSynthGroup, SpessaSynthTable, SpessaSynthGroupEnd, SpessaSynthInfo, SpessaSynthWarn, SpessaSynthGroupCollapsed, midiControllers, messageTypes, MIDIDeviceHandler, WebMidiLinkHandler, arrayToHexString, consoleColors, formatTitle, formatTime, readBytesAsUintBigEndian, NON_CC_INDEX_OFFSET, ALL_CHANNELS_OR_DIFFERENT_ACTION, WORKLET_URL_ABSOLUTE };

package/@types/midi_parser/basic_midi.d.ts

@@ -0,0 +1,125 @@
+export class BasicMIDI {
+    /**
+     * The time division of the sequence
+     * @type {number}
+     */
+    timeDivision: number;
+    /**
+     * The duration of the sequence, in seconds
+     * @type {number}
+     */
+    duration: number;
+    /**
+     * The tempo changes in the sequence, ordered from last to first
+     * @type {{ticks: number, tempo: number}[]}
+     */
+    tempoChanges: {
+        ticks: number;
+        tempo: number;
+    }[];
+    /**
+     * Contains the copyright strings
+     * @type {string}
+     */
+    copyright: string;
+    /**
+     * The amount of tracks in the sequence
+     * @type {number}
+     */
+    tracksAmount: number;
+    /**
+     * The lyrics of the sequence as binary chunks
+     * @type {Uint8Array[]}
+     */
+    lyrics: Uint8Array[];
+    /**
+     * First note on of the MIDI file
+     * @type {number}
+     */
+    firstNoteOn: number;
+    /**
+     * The MIDI's key range
+     * @type {{min: number, max: number}}
+     */
+    keyRange: {
+        min: number;
+        max: number;
+    };
+    /**
+     * The last voice (note on, off, cc change etc.) event tick
+     * @type {number}
+     */
+    lastVoiceEventTick: number;
+    /**
+     * Midi port numbers for each track
+     * @type {number[]}
+     */
+    midiPorts: number[];
+    /**
+     * Channel offsets for each port, using the SpessaSynth method
+     * @type {number[]}
+     */
+    midiPortChannelOffsets: number[];
+    /**
+     * All channels that each track uses
+     * @type {Set<number>[]}
+     */
+    usedChannelsOnTrack: Set<number>[];
+    /**
+     * The loop points (in ticks) of the sequence
+     * @type {{start: number, end: number}}
+     */
+    loop: {
+        start: number;
+        end: number;
+    };
+    /**
+     * The sequence's name
+     * @type {string}
+     */
+    midiName: string;
+    /**
+     * The file name of the sequence, if provided in the MIDI class
+     * @type {string}
+     */
+    fileName: string;
+    /**
+     * The raw, encoded MIDI name.
+     * @type {Uint8Array}
+     */
+    rawMidiName: Uint8Array;
+    /**
+     * The MIDI's embedded soundfont
+     * @type {ArrayBuffer|undefined}
+     */
+    embeddedSoundFont: ArrayBuffer | undefined;
+    /**
+     * The MIDI file's format
+     * @type {number}
+     */
+    format: number;
+    /**
+     * The RMID Info data if RMID, otherwise undefined
+     * @type {Object<string, IndexedByteArray>}
+     */
+    RMIDInfo: {
+        [x: string]: IndexedByteArray;
+    };
+    /**
+     * The bank offset for RMIDI
+     * @type {number}
+     */
+    bankOffset: number;
+    /**
+     * The actual track data of the MIDI file
+     * @type {MidiMessage[][]}
+     */
+    tracks: MidiMessage[][];
+    /**
+     * Coverts ticks to time in seconds
+     * @param ticks {number}
+     * @returns {number}
+     * @protected
+     */
+    protected _ticksToSeconds(ticks: number): number;
+}

package/@types/midi_parser/midi_builder.d.ts

@@ -0,0 +1,69 @@
+export class MIDIBuilder extends BasicMIDI {
+    /**
+     * @param name {string} The MIDI's name
+     * @param timeDivision {number} the file's time division
+     * @param initialTempo {number} the file's initial tempo
+     */
+    constructor(name: string, timeDivision?: number, initialTempo?: number);
+    encoder: TextEncoder;
+    /**
+     * Updates all internal values
+     */
+    flush(): void;
+    /**
+     * Adds a new "set tempo" message
+     * @param ticks {number} the tick number of the event
+     * @param tempo {number} the tempo in beats per minute (BPM)
+     */
+    addSetTempo(ticks: number, tempo: number): void;
+    /**
+     * Adds a new MIDI track
+     * @param name {string} the new track's name
+     * @param port {number} the new track's port
+     */
+    addNewTrack(name: string, port?: number): void;
+    /**
+     * Adds a new MIDI Event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param event {number} the MIDI event number
+     * @param eventData {Uint8Array|Iterable<number>} the raw event data
+     */
+    addEvent(ticks: number, track: number, event: number, eventData: Uint8Array | Iterable<number>): void;
+    /**
+     * Adds a new Note On event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the keypress
+     * @param velocity {number} the velocity of the keypress
+     */
+    addNoteOn(ticks: number, track: number, channel: number, midiNote: number, velocity: number): void;
+    /**
+     * Adds a new Note Off event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param midiNote {number} the midi note of the key release
+     */
+    addNoteOff(ticks: number, track: number, channel: number, midiNote: number): void;
+    /**
+     * Adds a new Controller Change event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track number to use
+     * @param channel {number} the channel to use
+     * @param controllerNumber {number} the MIDI CC to use
+     * @param controllerValue {number} the new CC value
+     */
+    addControllerChange(ticks: number, track: number, channel: number, controllerNumber: number, controllerValue: number): void;
+    /**
+     * Adds a new Pitch Wheel event
+     * @param ticks {number} the tick time of the event
+     * @param track {number} the track to use
+     * @param channel {number} the channel to use
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+     */
+    addPitchWheel(ticks: number, track: number, channel: number, MSB: number, LSB: number): void;
+}
+import { BasicMIDI } from './basic_midi.js';

package/@types/midi_parser/midi_data.d.ts

@@ -4,9 +4,9 @@
  */
 export class MidiData {
     /**
-     * @param midi {MIDI}
+     * @param midi {BasicMIDI}
      */
-    constructor(midi: MIDI);
+    constructor(midi: BasicMIDI);
     /**
      * The time division of the sequence
      * @type {number}

package/@types/midi_parser/midi_editor.d.ts

@@ -5,7 +5,7 @@
 export function getGsOn(ticks: number): MidiMessage;
 /**
  * Allows easy editing of the file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @param desiredProgramChanges {{
  *     channel: number,
  *     program: number,
@@ -23,7 +23,7 @@ export function getGsOn(ticks: number): MidiMessage;
  *     keyShift: number
  * }[]} the channels to transpose. if keyShift is float, rpn fine tuning will be applied as well. Note that the channel may be more than 16, function will adjust midi ports automatically
  */
-export function modifyMIDI(midi: MIDI, desiredProgramChanges?: {
+export function modifyMIDI(midi: BasicMIDI, desiredProgramChanges?: {
     channel: number;
     program: number;
     bank: number;
@@ -38,8 +38,8 @@ export function modifyMIDI(midi: MIDI, desiredProgramChanges?: {
 }[]): void;
 /**
  * Modifies the sequence according to the locked presets and controllers in the given snapshot
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @param snapshot {SynthesizerSnapshot}
  */
-export function applySnapshotToMIDI(midi: MIDI, snapshot: SynthesizerSnapshot): void;
+export function applySnapshotToMIDI(midi: BasicMIDI, snapshot: SynthesizerSnapshot): void;
 import { MidiMessage } from './midi_message.js';

package/@types/midi_parser/midi_loader.d.ts

@@ -2,104 +2,14 @@
  * midi_loader.js
  * purpose: parses a midi file for the seqyencer, including things like marker or CC 2/4 loop detection, copyright detection etc.
  */
-export class MIDI {
+export class MIDI extends BasicMIDI {
     /**
      * Parses a given midi file
      * @param arrayBuffer {ArrayBuffer}
      * @param fileName {string} optional, replaces the decoded title if empty
      */
     constructor(arrayBuffer: ArrayBuffer, fileName?: string);
-    /**
-     * If the RMI file has an embedded sf2 in it, it will appeear here, otherwise undefined
-     * @type {ArrayBuffer}
-     */
-    embeddedSoundFont: ArrayBuffer;
-    /**
-     * The RMID Info data if RMID, otherwise undefined
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo: {
-        [x: string]: IndexedByteArray;
-    };
-    /**
-     * The bank offset for RMIDI
-     * @type {number}
-     */
-    bankOffset: number;
-    /**
-     * Contains the copyright strings
-     * @type {string}
-     */
-    copyright: string;
-    /**
-     * The MIDI name
-     * @type {string}
-     */
-    midiName: string;
-    rawMidiName: Uint8Array;
-    format: number;
-    tracksAmount: number;
-    timeDivision: number;
-    /**
-     * The MIDI's key range
-     * @type {{min: number, max: number}}
-     */
-    keyRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * Contains the lyrics as binary chunks
-     * @type {Uint8Array[]}
-     */
-    lyrics: Uint8Array[];
-    /**
-     * Contains all the tempo changes in the file. (Ordered from last to first)
-     * @type {{
-     *     ticks: number,
-     *     tempo: number
-     * }[]}
-     */
-    tempoChanges: {
-        ticks: number;
-        tempo: number;
-    }[];
-    lastVoiceEventTick: number;
-    /**
-     * Midi port numbers for each tracks
-     * @type {number[]}
-     */
-    midiPorts: number[];
-    /**
-     * Channel offsets for each port, using the SpessaSynth method
-     * @type {number[]}
-     */
-    midiPortChannelOffsets: number[];
-    /**
-     * All channels that each track uses. Note: these channels range from 0 to 15, excluding the port offsets!
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack: Set<number>[];
-    /**
-     * Read all the tracks
-     * @type {MidiMessage[][]}
-     */
-    tracks: MidiMessage[][];
-    firstNoteOn: number;
-    /**
-     *
-     * @type {{start: number, end: number}}
-     */
-    loop: {
-        start: number;
-        end: number;
-    };
-    fileName: string;
-    /**
-     * The total playback time, in seconds
-     * @type {number}
-     */
-    duration: number;
+    rawMidiName: any;
     /**
      * @param fileByteArray {IndexedByteArray}
      * @returns {{type: string, size: number, data: IndexedByteArray}}
@@ -109,13 +19,6 @@ export class MIDI {
         size: number;
         data: IndexedByteArray;
     };
-    /**
-     * Coverts ticks to time in seconds
-     * @param ticks {number}
-     * @returns {number}
-     * @private
-     */
-    private _ticksToSeconds;
 }
+import { BasicMIDI } from './basic_midi.js';
 import { IndexedByteArray } from '../utils/indexed_array.js';
-import { MidiMessage } from './midi_message.js';

package/@types/midi_parser/midi_writer.d.ts

@@ -1,6 +1,6 @@
 /**
  * Exports the midi as a .mid file
- * @param midi {MIDI}
+ * @param midi {BasicMIDI}
  * @returns {Uint8Array} the binary .mid file data
  */
-export function writeMIDIFile(midi: MIDI): Uint8Array;
+export function writeMIDIFile(midi: BasicMIDI): Uint8Array;

package/@types/midi_parser/rmidi_writer.d.ts

@@ -14,15 +14,15 @@
 /**
  * Writes an RMIDI file
  * @param soundfontBinary {Uint8Array}
- * @param mid {MIDI}
- * @param soundfont {SoundFont2}
+ * @param mid {BasicMIDI}
+ * @param soundfont {BasicSoundFont}
  * @param bankOffset {number} the bank offset for RMIDI
  * @param encoding {string} the encoding of the RMIDI info chunk
  * @param metadata {RMIDMetadata} the metadata of the file. Optional. If provided, the encoding is forced to utf-8/
  * @param correctBankOffset {boolean}
  * @returns {IndexedByteArray}
  */
-export function writeRMIDI(soundfontBinary: Uint8Array, mid: MIDI, soundfont: SoundFont2, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata, correctBankOffset?: boolean): IndexedByteArray;
+export function writeRMIDI(soundfontBinary: Uint8Array, mid: BasicMIDI, soundfont: BasicSoundFont, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata, correctBankOffset?: boolean): IndexedByteArray;
 export type RMIDINFOChunks = string;
 export namespace RMIDINFOChunks {
     let name: string;

package/@types/midi_parser/used_keys_loaded.d.ts

@@ -1,9 +1,9 @@
 /**
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @param soundfont {{getPreset: function(number, number): BasicPreset}}
  * @returns {Object<string, Set<string>>}
  */
-export function getUsedProgramsAndKeys(mid: MIDI, soundfont: {
+export function getUsedProgramsAndKeys(mid: BasicMIDI, soundfont: {
     getPreset: (arg0: number, arg1: number) => BasicPreset;
 }): {
     [x: string]: Set<string>;

package/@types/sequencer/sequencer.d.ts

@@ -194,7 +194,7 @@ export type MidFile = {
      */
     altName: string | undefined;
 };
-export type MIDIFile = MIDI | MidFile;
+export type MIDIFile = BasicMIDI | MidFile;
 export type SequencerOptions = {
     /**
      * - if true, the sequencer will skip to the first note

package/@types/soundfont/basic_soundfont/basic_sample.d.ts

@@ -42,12 +42,12 @@ export class BasicSample {
      */
     sampleType: number;
     /**
-     * Relative to start of the sample, bytes
+     * Relative to start of the sample, bytes assuming 16 bit
      * @type {number}
      */
     sampleLoopStartIndex: number;
     /**
-     * Relative to start of the sample, in bytes
+     * Relative to start of the sample, in bytes assuming 16 bit
      * @type {number}
      */
     sampleLoopEndIndex: number;

package/@types/soundfont/basic_soundfont/basic_zone.d.ts

@@ -5,30 +5,30 @@
  */
 export class BasicZone {
     /**
-     * The zone's generators
-     * @type {Generator[]}
+     * The zone's velocity range
+     * @type {SoundFontRange}
      */
-    generators: Generator[];
+    velRange: SoundFontRange;
     /**
-     * The zone's modulators
-     * @type {Modulator[]}
+     * The zone's key range
+     * @type {SoundFontRange}
      */
-    modulators: Modulator[];
+    keyRange: SoundFontRange;
     /**
      * Indicates if the zone is global
      * @type {boolean}
      */
     isGlobal: boolean;
     /**
-     * The zone's key range
-     * @type {SoundFontRange}
+     * The zone's generators
+     * @type {Generator[]}
      */
-    keyRange: SoundFontRange;
+    generators: Generator[];
     /**
-     * The zone's velocity range
-     * @type {SoundFontRange}
+     * The zone's modulators
+     * @type {Modulator[]}
      */
-    velRange: SoundFontRange;
+    modulators: Modulator[];
 }
 export type SoundFontRange = {
     /**

package/@types/soundfont/basic_soundfont/basic_zones.d.ts

@@ -4,6 +4,10 @@ export class BasicInstrumentZone extends BasicZone {
      * @type {BasicSample|undefined}
      */
     sample: BasicSample | undefined;
+    /**
+     * The zone's use count
+     * @type {number}
+     */
     useCount: number;
     deleteZone(): void;
 }

package/@types/soundfont/basic_soundfont/riff_chunk.d.ts

@@ -18,6 +18,12 @@ export function writeRIFFChunk(chunk: RiffChunk, prepend?: IndexedByteArray): In
  * @returns {IndexedByteArray}
  */
 export function writeRIFFOddSize(header: string, data: Uint8Array, addZeroByte?: boolean): IndexedByteArray;
+/**
+ * @param collection {RiffChunk[]}
+ * @param type {string}
+ * @returns {RiffChunk|undefined}
+ */
+export function findRIFFListType(collection: RiffChunk[], type: string): RiffChunk | undefined;
 /**
  * riff_chunk.js
  * reads a riff read and stores it as a class

package/@types/soundfont/basic_soundfont/write_sf2/soundfont_trimmer.d.ts

@@ -1,6 +1,6 @@
 /**
  * @param soundfont {BasicSoundFont}
- * @param mid {MIDI}
+ * @param mid {BasicMIDI}
  * @returns {Uint8Array}
  */
-export function trimSoundfont(soundfont: BasicSoundFont, mid: MIDI): Uint8Array;
+export function trimSoundfont(soundfont: BasicSoundFont, mid: BasicMIDI): Uint8Array;

package/@types/soundfont/dls/articulator_converter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param source {number}
+ * @param control {number}
+ * @param destination {number}
+ * @param transform {number}
+ * @param value {number}
+ * @returns {Modulator|undefined}
+ */
+export function getSF2ModulatorFromArticulator(source: number, control: number, destination: number, transform: number, value: number): Modulator | undefined;
+import { Modulator } from '../read_sf2/modulators.js';

package/@types/soundfont/dls/dls_destinations.d.ts

@@ -0,0 +1,29 @@
+export type DLSDestinations = number;
+export namespace DLSDestinations {
+    let none: number;
+    let gain: number;
+    let reserved: number;
+    let pitch: number;
+    let pan: number;
+    let keyNum: number;
+    let chorusSend: number;
+    let reverbSend: number;
+    let modLfoFreq: number;
+    let modLfoDelay: number;
+    let vibLfoFreq: number;
+    let vibLfoDelay: number;
+    let volEnvAttack: number;
+    let volEnvDecay: number;
+    let volEnvRelease: number;
+    let volEnvSustain: number;
+    let volEnvDelay: number;
+    let volEnvHold: number;
+    let modEnvAttack: number;
+    let modEnvDecay: number;
+    let modEnvRelease: number;
+    let modEnvSustain: number;
+    let modEnvDelay: number;
+    let modEnvHold: number;
+    let filterCutoff: number;
+    let filterQ: number;
+}

package/@types/soundfont/dls/dls_preset.d.ts

@@ -0,0 +1,13 @@
+export class DLSPreset extends BasicPreset {
+    /**
+     * Creates a new DLS preset
+     * @param ulBank {number}
+     * @param ulInstrument {number}
+     */
+    constructor(ulBank: number, ulInstrument: number);
+    DLSInstrument: BasicInstrument;
+    presetZones: BasicPresetZone[];
+}
+import { BasicPreset } from '../basic_soundfont/basic_preset.js';
+import { BasicInstrument } from '../basic_soundfont/basic_instrument.js';
+import { BasicPresetZone } from '../basic_soundfont/basic_zones.js';

package/@types/soundfont/dls/dls_sample.d.ts

@@ -0,0 +1,18 @@
+export class DLSSample extends BasicSample {
+    /**
+     * @param name {string}
+     * @param rate {number}
+     * @param pitch {number}
+     * @param pitchCorrection {number}
+     * @param loopStart {number} sample data points
+     * @param loopEnd {number} sample data points
+     * @param data {Float32Array}
+     */
+    constructor(name: string, rate: number, pitch: number, pitchCorrection: number, loopStart: number, loopEnd: number, data: Float32Array);
+    /**
+     * @type {Float32Array}
+     */
+    sampleData: Float32Array;
+    getRawData(): Uint8Array;
+}
+import { BasicSample } from '../basic_soundfont/basic_sample.js';

package/@types/soundfont/dls/dls_soundfont.d.ts

@@ -0,0 +1,31 @@
+export class DLSSoundFont extends BasicSoundFont {
+    /**
+     * Loads a new DLS (Downloadable sounds) soundfont
+     * @param buffer {ArrayBuffer}
+     */
+    constructor(buffer: ArrayBuffer);
+    dataArray: IndexedByteArray;
+    instrumentAmount: number;
+    /**
+     * @param chunk {RiffChunk}
+     * @param expected {string}
+     */
+    verifyHeader(chunk: RiffChunk, expected: string): void;
+    /**
+     * @param text {string}
+     * @param expected {string}
+     */
+    verifyText(text: string, expected: string): void;
+    readDLSInstrumentList: typeof readDLSInstrumentList;
+    readDLSInstrument: typeof readDLSInstrument;
+    readRegion: typeof readRegion;
+    readLart: typeof readLart;
+    readDLSSamples: typeof readDLSSamples;
+}
+import { BasicSoundFont } from '../basic_soundfont/basic_soundfont.js';
+import { IndexedByteArray } from '../../utils/indexed_array.js';
+import { readDLSInstrumentList } from './read_instrument_list.js';
+import { readDLSInstrument } from './read_instrument.js';
+import { readRegion } from './read_region.js';
+import { readLart } from './read_lart.js';
+import { readDLSSamples } from './read_samples.js';

package/@types/soundfont/dls/dls_sources.d.ts

@@ -0,0 +1,22 @@
+export type DLSSources = number;
+export namespace DLSSources {
+    let none: number;
+    let modLfo: number;
+    let velocity: number;
+    let keyNum: number;
+    let volEnv: number;
+    let modEnv: number;
+    let pitchWheel: number;
+    let polyPressure: number;
+    let channelPressure: number;
+    let vibratoLfo: number;
+    let modulationWheel: number;
+    let volume: number;
+    let pan: number;
+    let expression: number;
+    let chorus: number;
+    let reverb: number;
+    let pitchWheelRange: number;
+    let fineTune: number;
+    let coarseTune: number;
+}