spessasynth_lib 3.24.3 → 3.24.6

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

@@ -1,135 +0,0 @@
-/**
- * This is the base type for MIDI files. It contains all the "metadata" and information.
- * It extends to:
- * - BasicMIDI, which contains the actual track data of the MIDI file. Essentially the MIDI file itself.
- * - MidiData, which contains all properties that MIDI does, except for tracks and the embedded soundfont.
- * MidiData is the "shell" of the file which is available on the main thread at all times, containing the metadata.
- */
-export class MIDISequenceData {
-    /**
-     * The time division of the sequence, representing the number of ticks per beat.
-     * @type {number}
-     */
-    timeDivision: number;
-    /**
-     * The duration of the sequence, in seconds.
-     * @type {number}
-     */
-    duration: number;
-    /**
-     * The tempo changes in the sequence, ordered from the last change to the first.
-     * Each change is represented by an object with a tick position and a tempo value in beats per minute.
-     * @type {{ticks: number, tempo: number}[]}
-     */
-    tempoChanges: {
-        ticks: number;
-        tempo: number;
-    }[];
-    /**
-     * A string containing the copyright information for the MIDI sequence if detected.
-     * @type {string}
-     */
-    copyright: string;
-    /**
-     * The number of tracks in the MIDI sequence.
-     * @type {number}
-     */
-    tracksAmount: number;
-    /**
-     * An array containing the lyrics of the sequence, stored as binary chunks (Uint8Array).
-     * @type {Uint8Array[]}
-     */
-    lyrics: Uint8Array[];
-    /**
-     * An array of tick positions where lyrics events occur in the sequence.
-     * @type {number[]}
-     */
-    lyricsTicks: number[];
-    /**
-     * The tick position of the first note-on event in the MIDI sequence.
-     * @type {number}
-     */
-    firstNoteOn: number;
-    /**
-     * The MIDI key range used in the sequence, represented by a minimum and maximum note value.
-     * @type {{min: number, max: number}}
-     */
-    keyRange: {
-        min: number;
-        max: number;
-    };
-    /**
-     * The tick position of the last voice event (such as note-on, note-off, or control change) in the sequence.
-     * @type {number}
-     */
-    lastVoiceEventTick: number;
-    /**
-     * An array of MIDI port numbers used by each track in the sequence.
-     * @type {number[]}
-     */
-    midiPorts: number[];
-    /**
-     * An array of channel offsets for each MIDI port, using the SpessaSynth method.
-     * @type {number[]}
-     */
-    midiPortChannelOffsets: number[];
-    /**
-     * A list of sets, where each set contains the MIDI channels used by each track in the sequence.
-     * @type {Set<number>[]}
-     */
-    usedChannelsOnTrack: Set<number>[];
-    /**
-     * The loop points (in ticks) of the sequence, including both start and end points.
-     * @type {{start: number, end: number}}
-     */
-    loop: {
-        start: number;
-        end: number;
-    };
-    /**
-     * The name of the MIDI sequence.
-     * @type {string}
-     */
-    midiName: string;
-    /**
-     * A boolean indicating if the sequence's name is the same as the file name.
-     * @type {boolean}
-     */
-    midiNameUsesFileName: boolean;
-    /**
-     * The file name of the MIDI sequence, if provided during parsing.
-     * @type {string}
-     */
-    fileName: string;
-    /**
-     * The raw, encoded MIDI name, represented as a Uint8Array.
-     * Useful when the MIDI file uses a different code page.
-     * @type {Uint8Array}
-     */
-    rawMidiName: Uint8Array;
-    /**
-     * The format of the MIDI file, which can be 0, 1, or 2, indicating the type of the MIDI file.
-     * @type {number}
-     */
-    format: number;
-    /**
-     * The RMID (Resource Interchangeable MIDI) info data, if the file is RMID formatted.
-     * Otherwise, this field is undefined.
-     * Chunk type (e.g. "INAM"): Chunk data as binary array.
-     * @type {Object<string, IndexedByteArray>}
-     */
-    RMIDInfo: {
-        [x: string]: IndexedByteArray;
-    };
-    /**
-     * The bank offset used for RMID files.
-     * @type {number}
-     */
-    bankOffset: number;
-    /**
-     * If the MIDI file is a Soft Karaoke file (.kar), this flag is set to true.
-     * https://www.mixagesoftware.com/en/midikit/help/HTML/karaoke_formats.html
-     * @type {boolean}
-     */
-    isKaraokeFile: boolean;
-}

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

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

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

@@ -1,85 +0,0 @@
-/**
- * @typedef {Object} RMIDMetadata
- * @property {string|undefined} name - the name of the file
- * @property {string|undefined} engineer - the engineer who worked on the file
- * @property {string|undefined} artist - the artist
- * @property {string|undefined} album - the album
- * @property {string|undefined} genre - the genre of the song
- * @property {ArrayBuffer|undefined} picture - the image for the file (album cover)
- * @property {string|undefined} comment - the coment of the file
- * @property {string|undefined} creationDate - the creation date of the file
- * @property {string|undefined} copyright - the copyright of the file
- * @property {string|unescape} midiEncoding - the encoding of the inner MIDI file
- */
-/**
- * Writes an RMIDI file
- * @param soundfontBinary {Uint8Array}
- * @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: BasicMIDI, soundfont: BasicSoundFont, bankOffset?: number, encoding?: string, metadata?: RMIDMetadata, correctBankOffset?: boolean): IndexedByteArray;
-export type RMIDINFOChunks = string;
-export namespace RMIDINFOChunks {
-    let name: string;
-    let album: string;
-    let album2: string;
-    let artist: string;
-    let genre: string;
-    let picture: string;
-    let copyright: string;
-    let creationDate: string;
-    let comment: string;
-    let engineer: string;
-    let software: string;
-    let encoding: string;
-    let midiEncoding: string;
-    let bankOffset: string;
-}
-export type RMIDMetadata = {
-    /**
-     * - the name of the file
-     */
-    name: string | undefined;
-    /**
-     * - the engineer who worked on the file
-     */
-    engineer: string | undefined;
-    /**
-     * - the artist
-     */
-    artist: string | undefined;
-    /**
-     * - the album
-     */
-    album: string | undefined;
-    /**
-     * - the genre of the song
-     */
-    genre: string | undefined;
-    /**
-     * - the image for the file (album cover)
-     */
-    picture: ArrayBuffer | undefined;
-    /**
-     * - the coment of the file
-     */
-    comment: string | undefined;
-    /**
-     * - the creation date of the file
-     */
-    creationDate: string | undefined;
-    /**
-     * - the copyright of the file
-     */
-    copyright: string | undefined;
-    /**
-     * - the encoding of the inner MIDI file
-     */
-    midiEncoding: string | typeof unescape;
-};
-import { IndexedByteArray } from "../utils/indexed_array.js";

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

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

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

@@ -1,277 +0,0 @@
-export class Sequencer {
-    /**
-     * Creates a new Midi sequencer for playing back MIDI files
-     * @param midiBinaries {MIDIFile[]} List of the buffers of the MIDI files
-     * @param synth {Synthetizer} synth to send events to
-     * @param options {SequencerOptions} the sequencer's options
-     */
-    constructor(midiBinaries: MIDIFile[], synth: Synthetizer, options?: SequencerOptions);
-    /**
-     * Executes when MIDI parsing has an error.
-     * @type {function(string)}
-     */
-    onError: (arg0: string) => any;
-    /**
-     * The sequence's data, except for the track data.
-     *  @type {MidiData}
-     */
-    midiData: MidiData;
-    /**
-     * @type {Object<string, function(MidiData)>}
-     * @private
-     */
-    private onSongChange;
-    /**
-     * Fires on text event
-     * @type {function}
-     * @param data {Uint8Array} the data text
-     * @param type {number} the status byte of the message (the meta-status byte)
-     * @param lyricsIndex {number} if the text is a lyric, the index of the lyric in midiData.lyrics, otherwise -1
-     */
-    onTextEvent: Function;
-    /**
-     * Fires when CurrentTime changes
-     * @type {Object<string, function(number)>} the time that was changed to
-     * @private
-     */
-    private onTimeChange;
-    /**
-     * @type {Object<string, function>}
-     * @private
-     */
-    private onSongEnded;
-    /**
-     * Fires on tempo change
-     * @type {Object<string, function(number)>}
-     */
-    onTempoChange: {
-        [x: string]: (arg0: number) => any;
-    };
-    /**
-     * Current song's tempo in BPM
-     * @type {number}
-     */
-    currentTempo: number;
-    /**
-     * Current song index
-     * @type {number}
-     */
-    songIndex: number;
-    /**
-     * @type {function(BasicMIDI)}
-     * @private
-     */
-    private _getMIDIResolve;
-    /**
-     * Indicates if the current midiData property has fake data in it (not yet loaded)
-     * @type {boolean}
-     */
-    hasDummyData: boolean;
-    /**
-     * Indicates whether the sequencer has finished playing a sequence
-     * @type {boolean}
-     */
-    isFinished: boolean;
-    /**
-     * The current sequence's length, in seconds
-     * @type {number}
-     */
-    duration: number;
-    /**
-     * Indicates if the sequencer is paused.
-     * Paused if a number, undefined if playing
-     * @type {undefined|number}
-     * @private
-     */
-    private pausedTime;
-    ignoreEvents: boolean;
-    synth: Synthetizer;
-    highResTimeOffset: number;
-    /**
-     * Absolute playback startTime, bases on the synth's time
-     * @type {number}
-     */
-    absoluteStartTime: number;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    private _skipToFirstNoteOn;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    private _preservePlaybackState;
-    /**
-     * Internal loop marker
-     * @type {boolean}
-     * @private
-     */
-    private _loop;
-    set loop(value: boolean);
-    get loop(): boolean;
-    /**
-     * Controls the playback's rate
-     * @type {number}
-     * @private
-     */
-    private _playbackRate;
-    /**
-     * @param value {number}
-     */
-    set playbackRate(value: number);
-    /**
-     * @returns {number}
-     */
-    get playbackRate(): number;
-    /**
-     * Indicates if the sequencer should skip to first note on
-     * @param val {boolean}
-     */
-    set skipToFirstNoteOn(val: boolean);
-    /**
-     * Indicates if the sequencer should skip to first note on
-     * @return {boolean}
-     */
-    get skipToFirstNoteOn(): boolean;
-    /**
-     * if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     * @param val {boolean}
-     */
-    set preservePlaybackState(val: boolean);
-    /**
-     * if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     * @returns {boolean}
-     */
-    get preservePlaybackState(): boolean;
-    set currentTime(time: number);
-    /**
-     * @returns {number} Current playback time, in seconds
-     */
-    get currentTime(): number;
-    /**
-     * Use for visualization as it's not affected by the audioContext stutter
-     * @returns {number}
-     */
-    get currentHighResolutionTime(): number;
-    /**
-     * true if paused, false if playing or stopped
-     * @returns {boolean}
-     */
-    get paused(): boolean;
-    /**
-     * Adds a new event that gets called when the song changes
-     * @param callback {function(MidiData)}
-     * @param id {string} must be unique
-     */
-    addOnSongChangeEvent(callback: (arg0: MidiData) => any, id: string): void;
-    /**
-     * Adds a new event that gets called when the song ends
-     * @param callback {function}
-     * @param id {string} must be unique
-     */
-    addOnSongEndedEvent(callback: Function, id: string): void;
-    /**
-     * Adds a new event that gets called when the time changes
-     * @param callback {function(number)} the new time, in seconds
-     * @param id {string} must be unique
-     */
-    addOnTimeChangeEvent(callback: (arg0: number) => any, id: string): void;
-    /**
-     * Adds a new event that gets called when the tempo changes
-     * @param callback {function(number)} the new tempo, in BPM
-     * @param id {string} must be unique
-     */
-    addOnTempoChangeEvent(callback: (arg0: number) => any, id: string): void;
-    resetMIDIOut(): void;
-    /**
-     * @param messageType {WorkletSequencerMessageType}
-     * @param messageData {any}
-     * @private
-     */
-    private _sendMessage;
-    nextSong(): void;
-    previousSong(): void;
-    /**
-     * @param type {Object<string, function>}
-     * @param params {any}
-     * @private
-     */
-    private _callEvents;
-    /**
-     * @param {WorkletSequencerReturnMessageType} messageType
-     * @param {any} messageData
-     * @private
-     */
-    private _handleMessage;
-    /**
-     * @param time
-     * @private
-     */
-    private _recalculateStartTime;
-    /**
-     * @returns {Promise<MIDI>}
-     */
-    getMIDI(): Promise<MIDI>;
-    /**
-     * Loads a new song list
-     * @param midiBuffers {MIDIFile[]} - the MIDI files to play
-     * @param autoPlay {boolean} - if true, the first sequence will automatically start playing
-     */
-    loadNewSongList(midiBuffers: MIDIFile[], autoPlay?: boolean): void;
-    songsAmount: number;
-    /**
-     * @param output {MIDIOutput}
-     */
-    connectMidiOutput(output: MIDIOutput): void;
-    MIDIout: MIDIOutput;
-    /**
-     * Pauses the playback
-     */
-    pause(): void;
-    unpause(): void;
-    /**
-     * Starts the playback
-     * @param resetTime {boolean} If true, time is set to 0 s
-     */
-    play(resetTime?: boolean): void;
-    /**
-     * Stops the playback
-     */
-    stop(): void;
-}
-/**
- * {Object}
- */
-export type MidFile = {
-    /**
-     * - the binary data of the file.
-     */
-    binary: ArrayBuffer;
-    /**
-     * - the alternative name for the file
-     */
-    altName: string | undefined;
-};
-export type MIDIFile = BasicMIDI | MidFile;
-export type SequencerOptions = {
-    /**
-     * - if true, the sequencer will skip to the first note
-     */
-    skipToFirstNoteOn: boolean | undefined;
-    /**
-     * - if true, the sequencer will automatically start playing the MIDI
-     */
-    autoPlay: boolean | undefined;
-    /**
-     * - if true,
-     * the sequencer will stay paused when seeking or changing the playback rate
-     */
-    preservePlaybackState: boolean | typeof unescape;
-};
-import { MidiData } from "../midi_parser/midi_data.js";
-import { Synthetizer } from "../synthetizer/synthetizer.js";
-import { MIDI } from "../midi_parser/midi_loader.js";
-import { BasicMIDI } from "../midi_parser/basic_midi.js";

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

@@ -1,31 +0,0 @@
-/**
- * *
- */
-export type WorkletSequencerMessageType = number;
-export namespace WorkletSequencerMessageType {
-    let loadNewSongList: number;
-    let pause: number;
-    let stop: number;
-    let play: number;
-    let setTime: number;
-    let changeMIDIMessageSending: number;
-    let setPlaybackRate: number;
-    let setLoop: number;
-    let changeSong: number;
-    let getMIDI: number;
-    let setSkipToFirstNote: number;
-    let setPreservePlaybackState: number;
-}
-export type WorkletSequencerReturnMessageType = number;
-export namespace WorkletSequencerReturnMessageType {
-    export let midiEvent: number;
-    export let songChange: number;
-    export let textEvent: number;
-    export let timeChange: number;
-    let pause_1: number;
-    export { pause_1 as pause };
-    let getMIDI_1: number;
-    export { getMIDI_1 as getMIDI };
-    export let midiError: number;
-    export let tempoChange: number;
-}

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

@@ -1,29 +0,0 @@
-export class BasicInstrument {
-    /**
-     * The instrument's name
-     * @type {string}
-     */
-    instrumentName: string;
-    /**
-     * The instrument's zones
-     * @type {BasicInstrumentZone[]}
-     */
-    instrumentZones: BasicInstrumentZone[];
-    _useCount: number;
-    /**
-     * @returns {number}
-     */
-    get useCount(): number;
-    addUseCount(): void;
-    removeUseCount(): void;
-    deleteInstrument(): void;
-    /**
-     * @param index {number}
-     * @returns {boolean} is the zone has been deleted
-     */
-    safeDeleteZone(index: number): boolean;
-    /**
-     * @param index {number}
-     */
-    deleteZone(index: number): void;
-}

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

@@ -1,86 +0,0 @@
-export class BasicPreset {
-    /**
-     * @param modulators {Modulator[]}
-     */
-    constructor(modulators: Modulator[]);
-    /**
-     * The preset's name
-     * @type {string}
-     */
-    presetName: string;
-    /**
-     * The preset's MIDI program number
-     * @type {number}
-     */
-    program: number;
-    /**
-     * The preset's MIDI bank number
-     * @type {number}
-     */
-    bank: number;
-    /**
-     * The preset's zones
-     * @type {BasicPresetZone[]}
-     */
-    presetZones: BasicPresetZone[];
-    /**
-     * SampleID offset for this preset
-     * @type {number}
-     */
-    sampleIDOffset: number;
-    /**
-     * Stores already found getSamplesAndGenerators for reuse
-     * @type {SampleAndGenerators[][][]}
-     */
-    foundSamplesAndGenerators: SampleAndGenerators[][][];
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    library: number;
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    genre: number;
-    /**
-     * unused metadata
-     * @type {number}
-     */
-    morphology: number;
-    /**
-     * Default modulators
-     * @type {Modulator[]}
-     */
-    defaultModulators: Modulator[];
-    deletePreset(): void;
-    /**
-     * @param index {number}
-     */
-    deleteZone(index: number): void;
-    /**
-     * Preloads all samples (async)
-     */
-    preload(keyMin: any, keyMax: any): void;
-    /**
-     * Preloads a specific key/velocity combo
-     * @param key {number}
-     * @param velocity {number}
-     */
-    preloadSpecific(key: number, velocity: number): void;
-    /**
-     * Returns generatorTranslator and generators for given note
-     * @param midiNote {number}
-     * @param velocity {number}
-     * @returns {SampleAndGenerators[]}
-     */
-    getSamplesAndGenerators(midiNote: number, velocity: number): SampleAndGenerators[];
-}
-export type SampleAndGenerators = {
-    instrumentGenerators: Generator[];
-    presetGenerators: Generator[];
-    modulators: Modulator[];
-    sample: BasicSample;
-    sampleID: number;
-};
-import { Modulator } from "./modulator.js";