spessasynth_lib 0.0.1

package/package/@types/synthetizer/synthetizer.d.ts

@@ -0,0 +1,294 @@
+/**
+ * synthesizer.js
+ * purpose: responds to midi messages and called functions, managing the channels and passing the messages to them
+ */
+/**
+ * @typedef {Object} StartRenderingDataConfig
+ * @property {MIDI} parsedMIDI - the MIDI to render
+ * @property {SynthesizerSnapshot} snapshot - the snapshot to apply
+ * @property {boolean|undefined} oneOutput - if synth should use one output with 32 channels (2 audio channels for each midi channel). this disables chorus and reverb.
+ */
+export const WORKLET_PROCESSOR_NAME: "spessasynth-worklet-system";
+export const VOICE_CAP: 450;
+export const DEFAULT_PERCUSSION: 9;
+export const MIDI_CHANNEL_COUNT: 16;
+export const DEFAULT_SYNTH_MODE: "gs";
+/**
+ * Creates a new instance of the SpessaSynth synthesizer
+ * @param targetNode {AudioNode}
+ * @param soundFontBuffer {ArrayBuffer} the soundfont file array buffer
+ * @param enableEventSystem {boolean} enables the event system. Defaults to true
+ * @param startRenderingData {StartRenderingDataConfig} if set, starts playing this immediately and restores the values
+ * @param effectsConfig {EffectsConfig} optional configuration for the audio effects.
+ */
+export class Synthetizer {
+    /**
+     * Creates a new instance of the SpessaSynth synthesizer
+     * @param targetNode {AudioNode}
+     * @param soundFontBuffer {ArrayBuffer} the soundfont file array buffer
+     * @param enableEventSystem {boolean} enables the event system. Defaults to true
+     * @param startRenderingData {StartRenderingDataConfig} if set, starts playing this immediately and restores the values
+     * @param effectsConfig {EffectsConfig} optional configuration for the audio effects.
+     */
+    constructor(targetNode: AudioNode, soundFontBuffer: ArrayBuffer, enableEventSystem?: boolean, startRenderingData?: StartRenderingDataConfig, effectsConfig?: EffectsConfig);
+    context: BaseAudioContext;
+    /**
+     * Allows to set up custom event listeners for the synthesizer
+     * @type {EventHandler}
+     */
+    eventHandler: EventHandler;
+    _voiceCap: number;
+    /**
+     * the new channels will have their audio sent to the moduled output by this constant.
+     * what does that mean? e.g. if outputsAmount is 16, then channel's 16 audio will be sent to channel 0
+     * @type {number}
+     * @private
+     */
+    private _outputsAmount;
+    /**
+     * the amount of midi channels
+     * @type {number}
+     */
+    channelsAmount: number;
+    /**
+     * Indicates if the synth is fully ready
+     * @type {Promise<void>}
+     */
+    isReady: Promise<void>;
+    _resolveReady: (value: void | PromiseLike<void>) => void;
+    /**
+     * individual channel voices amount
+     * @type {ChannelProperty[]}
+     */
+    channelProperties: ChannelProperty[];
+    _voicesAmount: number;
+    /**
+     * For Black MIDI's - forces release time to 50ms
+     * @type {boolean}
+     */
+    _highPerformanceMode: boolean;
+    worklet: AudioWorkletNode;
+    /**
+     * @type {function(SynthesizerSnapshot)}
+     * @private
+     */
+    private _snapshotCallback;
+    /**
+     * for the worklet sequencer's messages
+     * @type {function(WorkletSequencerReturnMessageType, any)}
+     */
+    sequencerCallbackFunction: (arg0: WorkletSequencerReturnMessageType, arg1: any) => any;
+    reverbProcessor: ConvolverNode;
+    chorusProcessor: FancyChorus;
+    /**
+     * The maximum amount of voices allowed at once
+     * @param value {number}
+     */
+    set voiceCap(value: number);
+    /**
+     * The maximum amount of voices allowed at once
+     * @returns {number}
+     */
+    get voiceCap(): number;
+    /**
+     * For Black MIDI's - forces release time to 50ms
+     * @param {boolean} value
+     */
+    set highPerformanceMode(value: boolean);
+    get highPerformanceMode(): boolean;
+    /**
+     * Sets the SpessaSynth's log level
+     * @param enableInfo {boolean} - enable info (verbose)
+     * @param enableWarning {boolean} - enable warnings (unrecognized messages)
+     * @param enableGroup {boolean} - enable groups (recomended)
+     * @param enableTable {boolean} - enable table (debug message)
+     */
+    setLogLevel(enableInfo: boolean, enableWarning: boolean, enableGroup: boolean, enableTable: boolean): void;
+    /**
+     * Handles the messages received from the worklet
+     * @param message {WorkletReturnMessage}
+     * @private
+     */
+    private handleMessage;
+    /**
+     * Gets a complete snapshot of the synthesizer, including controllers
+     * @returns {Promise<SynthesizerSnapshot>}
+     */
+    getSynthesizerSnapshot(): Promise<SynthesizerSnapshot>;
+    /**
+     * Adds a new channel to the synthesizer
+     * @param postMessage {boolean} leave at true, set to false only at initialization
+     */
+    addNewChannel(postMessage?: boolean): void;
+    /**
+     * @param channel {number}
+     * @param value {{delay: number, depth: number, rate: number}}
+     */
+    setVibrato(channel: number, value: {
+        delay: number;
+        depth: number;
+        rate: number;
+    }): void;
+    /**
+     * Connects the individual audio outputs to the given audio nodes. In the app it's used by the renderer.
+     * @param audioNodes {AudioNode[]}
+     */
+    connectIndividualOutputs(audioNodes: AudioNode[]): void;
+    lockAndResetChannelVibrato(): void;
+    /**
+     * A message for debugging
+     */
+    debugMessage(): void;
+    /**
+     * Starts playing a note
+     * @param channel {number} usually 0-15: the channel to play the note
+     * @param midiNote {number} 0-127 the key number of the note
+     * @param velocity {number} 0-127 the velocity of the note (generally controls loudness)
+     * @param enableDebugging {boolean} set to true to log technical details to console
+     */
+    noteOn(channel: number, midiNote: number, velocity: number, enableDebugging?: boolean): void;
+    /**
+     * Stops playing a note
+     * @param channel {number} usually 0-15: the channel of the note
+     * @param midiNote {number} 0-127 the key number of the note
+     * @param force {boolean} instantly kills the note if true
+     */
+    noteOff(channel: number, midiNote: number, force?: boolean): void;
+    /**
+     * Stops all notes
+     * @param force {boolean} if we should instantly kill the note, defaults to false
+     */
+    stopAll(force?: boolean): void;
+    /**
+     * Changes the given controller
+     * @param channel {number} usually 0-15: the channel to change the controller
+     * @param controllerNumber {number} 0-127 the MIDI CC number
+     * @param controllerValue {number} 0-127 the controller value
+     * @param force {boolean} forces the controller change, even if it's locked or gm system is set and the cc is bank select
+     */
+    controllerChange(channel: number, controllerNumber: number, controllerValue: number, force?: boolean): void;
+    /**
+     * Resets all controllers (for every channel)
+     */
+    resetControllers(): void;
+    /**
+     * Applies pressure to a given channel
+     * @param channel {number} usually 0-15: the channel to change the controller
+     * @param pressure {number} 0-127: the pressure to apply
+     */
+    channelPressure(channel: number, pressure: number): void;
+    /**
+     * Applies pressure to a given note
+     * @param channel {number} usually 0-15: the channel to change the controller
+     * @param midiNote {number} 0-127: the MIDI note
+     * @param pressure {number} 0-127: the pressure to apply
+     */
+    polyPressure(channel: number, midiNote: number, pressure: number): void;
+    /**
+     * @param data {WorkletMessage}
+     */
+    post(data: WorkletMessage): void;
+    /**
+     * Sets the pitch of the given channel
+     * @param channel {number} usually 0-15: the channel to change pitch
+     * @param MSB {number} SECOND byte of the MIDI pitchWheel message
+     * @param LSB {number} FIRST byte of the MIDI pitchWheel message
+     */
+    pitchWheel(channel: number, MSB: number, LSB: number): void;
+    /**
+     * Transposes the synthetizer's pitch by given semitones amount (percussion channels do not get affected)
+     * @param semitones {number} the semitones to transpose by. Can be a floating point number for more precision
+     */
+    transpose(semitones: number): void;
+    /**
+     * Transposes the channel by given amount of semitones
+     * @param channel {number} the channel number
+     * @param semitones {number} the transposition of the channel, can be a float
+     * @param force {boolean} defaults to false, if true transposes the channel even if it's a drum channel
+     */
+    transposeChannel(channel: number, semitones: number, force?: boolean): void;
+    /**
+     * Sets the main volume
+     * @param volume {number} 0-1 the volume
+     */
+    setMainVolume(volume: number): void;
+    /**
+     * Sets the master stereo panning
+     * @param pan {number} -1 to 1, the pan (-1 is left, 0 is midde, 1 is right)
+     */
+    setMasterPan(pan: number): void;
+    /**
+     * Sets the channel's pitch bend range, in semitones
+     * @param channel {number} usually 0-15: the channel to change
+     * @param pitchBendRangeSemitones {number} the bend range in semitones
+     */
+    setPitchBendRange(channel: number, pitchBendRangeSemitones: number): void;
+    /**
+     * Changes the patch for a given channel
+     * @param channel {number} usually 0-15: the channel to change
+     * @param programNumber {number} 0-127 the MIDI patch number
+     * @param userChange {boolean} indicates if the program change has been called by user. defaults to false
+     */
+    programChange(channel: number, programNumber: number, userChange?: boolean): void;
+    /**
+     * Causes the given midi channel to ignore controller messages for the given controller number
+     * @param channel {number} usually 0-15: the channel to lock
+     * @param controllerNumber {number} 0-127 MIDI CC number NOTE: -1 locks the preset
+     * @param isLocked {boolean} true if locked, false if unlocked
+     */
+    lockController(channel: number, controllerNumber: number, isLocked: boolean): void;
+    /**
+     * Mutes or unmutes the given channel
+     * @param channel {number} usually 0-15: the channel to lock
+     * @param isMuted {boolean} indicates if the channel is muted
+     */
+    muteChannel(channel: number, isMuted: boolean): void;
+    /**
+     * Reloads the sounfont.
+     * @param soundFontBuffer {ArrayBuffer} the new soundfont file array buffer
+     * @return {Promise<void>}
+     */
+    reloadSoundFont(soundFontBuffer: ArrayBuffer): Promise<void>;
+    /**
+     * Sends a MIDI Sysex message to the synthesizer
+     * @param messageData {IndexedByteArray} the message's data (excluding the F0 byte, but including the F7 at the end)
+     */
+    systemExclusive(messageData: IndexedByteArray): void;
+    /**
+     * Toggles drums on a given channel
+     * @param channel {number}
+     * @param isDrum {boolean}
+     */
+    setDrums(channel: number, isDrum: boolean): void;
+    /**
+     * sends a raw MIDI message to the synthesizer
+     * @param message {ArrayLike<number>} the midi message, each number is a byte
+     */
+    sendMessage(message: ArrayLike<number>): void;
+    /**
+     * @returns {number} the audioContext's current time
+     */
+    get currentTime(): number;
+    /**
+     * @returns {number} the current amount of voices playing
+     */
+    get voicesAmount(): number;
+    reverbateEverythingBecauseWhyNot(): string;
+}
+export type StartRenderingDataConfig = {
+    /**
+     * - the MIDI to render
+     */
+    parsedMIDI: MIDI;
+    /**
+     * - the snapshot to apply
+     */
+    snapshot: SynthesizerSnapshot;
+    /**
+     * - if synth should use one output with 32 channels (2 audio channels for each midi channel). this disables chorus and reverb.
+     */
+    oneOutput: boolean | undefined;
+};
+import { EventHandler } from './synth_event_handler.js';
+import { FancyChorus } from './audio_effects/fancy_chorus.js';
+import { IndexedByteArray } from '../utils/indexed_array.js';

package/package/@types/synthetizer/worklet_system/message_protocol/worklet_message.d.ts

@@ -0,0 +1,89 @@
+/**
+ * * // NOTE: Every message needs a channel number (if not relevant or all, set to -1)
+ */
+export type workletMessageType = number;
+export namespace workletMessageType {
+    let noteOff: number;
+    let noteOn: number;
+    let ccChange: number;
+    let programChange: number;
+    let channelPressure: number;
+    let polyPressure: number;
+    let killNote: number;
+    let ccReset: number;
+    let setChannelVibrato: number;
+    let reloadSoundFont: number;
+    let stopAll: number;
+    let killNotes: number;
+    let muteChannel: number;
+    let addNewChannel: number;
+    let customcCcChange: number;
+    let debugMessage: number;
+    let systemExclusive: number;
+    let setMasterParameter: number;
+    let setDrums: number;
+    let pitchWheel: number;
+    let transpose: number;
+    let highPerformanceMode: number;
+    let lockController: number;
+    let sequencerSpecific: number;
+    let requestSynthesizerSnapshot: number;
+    let setLogLevel: number;
+}
+export type masterParameterType = number;
+export namespace masterParameterType {
+    let mainVolume: number;
+    let masterPan: number;
+    let voicesCap: number;
+}
+export const ALL_CHANNELS_OR_DIFFERENT_ACTION: -1;
+export type returnMessageType = number;
+export namespace returnMessageType {
+    export let channelProperties: number;
+    export let eventCall: number;
+    export let reportedCurrentTime: number;
+    let sequencerSpecific_1: number;
+    export { sequencerSpecific_1 as sequencerSpecific };
+    export let synthesizerSnapshot: number;
+    export let ready: number;
+    export let soundfontError: number;
+}
+export type WorkletMessage = {
+    channelNumber: number;
+    messageType: workletMessageType;
+    messageData: (number[] | boolean[] | WorkletVoice[] | number | {
+        sampleData: Float32Array;
+        sampleID: number;
+    } | {
+        rate: number;
+        depth: number;
+        delay: number;
+    } | boolean | ArrayBuffer | {
+        messageType: WorkletSequencerMessageType;
+        messageData: any;
+    });
+};
+export type WorkletReturnMessage = {
+    /**
+     * - the message's type
+     */
+    messageType: returnMessageType;
+    /**
+     * - the message's data
+     *
+     * 0 - channel properties           -> [...<ChannelProperty>] see message_sending.js line 29
+     * 1 - event call                   -> {eventName<string>, eventData:<the event's data>}
+     * 2 - reported current time        -> currentTime<number>
+     * 3 - sequencer specific           -> [messageType<WorkletSequencerReturnMessageType> messageData<any>] note: refer to sequencer_message.js
+     * 4 - synthesizer snapshot         -> snapshot<SynthesizerSnapshot> note: refer to snapshot.js
+     * 5 - ready                        -> (no data)
+     * 6 - soundfontError               -> errorMessage<string>
+     */
+    messageData: {
+        eventName: string;
+        eventData: any;
+    } | ChannelProperty[] | PresetListElement[] | string | {
+        messageType: WorkletSequencerReturnMessageType;
+        messageData: any;
+    } | SynthesizerSnapshot;
+};

package/package/@types/synthetizer/worklet_system/worklet_utilities/worklet_processor_channel.d.ts

@@ -0,0 +1,134 @@
+/**
+ * @typedef {Object} WorkletProcessorChannel
+ * @property {Int16Array} midiControllers - array of MIDI controller values + the values used by modulators as source (pitch bend, bend range etc.)
+ * @property {boolean[]} lockedControllers - array indicating if a controller is locked
+ * @property {Float32Array} customControllers - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+ *
+ * @property {number} channelTransposeKeyShift - key shift of the channel
+ * @property {boolean} holdPedal - indicates whether the hold pedal is active
+ * @property {boolean} drumChannel - indicates whether the channel is a drum channel
+ *
+ * @property {dataEntryStates} dataEntryState - the current state of the data entry
+ * @property {number} NRPCoarse - the current coarse value of the Non-Registered Parameter
+ * @property {number} NRPFine - the current fine value of the Non-Registered Parameter
+ * @property {number} RPValue - the current value of the Registered Parameter
+ *
+ * @property {Preset} preset - the channel's preset
+ * @property {boolean} lockPreset - indicates whether the program on the channel is locked
+ *
+ * @property {boolean} lockVibrato - indicates whether the custom vibrato is locked
+ * @property {Object} channelVibrato - vibrato settings for the channel
+ * @property {number} channelVibrato.depth - depth of the vibrato effect (cents)
+ * @property {number} channelVibrato.delay - delay before the vibrato effect starts (seconds)
+ * @property {number} channelVibrato.rate - rate of the vibrato oscillation (Hz)
+
+ * @property {boolean} isMuted - indicates whether the channel is muted
+ * @property {WorkletVoice[]} voices - array of voices currently active on the channel
+ * @property {WorkletVoice[]} sustainedVoices - array of voices that are sustained on the channel
+ * @property {WorkletVoice[][][]} cachedVoices - first is midi note, second is velocity. output is an array of WorkletVoices
+ */
+/**
+ * @param sendEvent {boolean}
+ * @this {SpessaSynthProcessor}
+ */
+export function createWorkletChannel(this: SpessaSynthProcessor, sendEvent?: boolean): void;
+export const NON_CC_INDEX_OFFSET: 128;
+export const CONTROLLER_TABLE_SIZE: 147;
+export const resetArray: Int16Array;
+export type dataEntryStates = number;
+export namespace dataEntryStates {
+    let Idle: number;
+    let RPCoarse: number;
+    let RPFine: number;
+    let NRPCoarse: number;
+    let NRPFine: number;
+    let DataCoarse: number;
+    let DataFine: number;
+}
+export namespace customControllers {
+    let channelTuning: number;
+    let channelTransposeFine: number;
+    let modulationMultiplier: number;
+    let masterTuning: number;
+    let channelTuningSemitones: number;
+}
+export const CUSTOM_CONTROLLER_TABLE_SIZE: number;
+export const customResetArray: Float32Array;
+export type WorkletProcessorChannel = {
+    /**
+     * - array of MIDI controller values + the values used by modulators as source (pitch bend, bend range etc.)
+     */
+    midiControllers: Int16Array;
+    /**
+     * - array indicating if a controller is locked
+     */
+    lockedControllers: boolean[];
+    /**
+     * - array of custom (not sf2) control values such as RPN pitch tuning, transpose, modulation depth, etc.
+     */
+    customControllers: Float32Array;
+    /**
+     * - key shift of the channel
+     */
+    channelTransposeKeyShift: number;
+    /**
+     * - indicates whether the hold pedal is active
+     */
+    holdPedal: boolean;
+    /**
+     * - indicates whether the channel is a drum channel
+     */
+    drumChannel: boolean;
+    /**
+     * - the current state of the data entry
+     */
+    dataEntryState: dataEntryStates;
+    /**
+     * - the current coarse value of the Non-Registered Parameter
+     */
+    NRPCoarse: number;
+    /**
+     * - the current fine value of the Non-Registered Parameter
+     */
+    NRPFine: number;
+    /**
+     * - the current value of the Registered Parameter
+     */
+    RPValue: number;
+    /**
+     * - the channel's preset
+     */
+    preset: Preset;
+    /**
+     * - indicates whether the program on the channel is locked
+     */
+    lockPreset: boolean;
+    /**
+     * - indicates whether the custom vibrato is locked
+     */
+    lockVibrato: boolean;
+    /**
+     * - vibrato settings for the channel
+     */
+    channelVibrato: {
+        depth: number;
+        delay: number;
+        rate: number;
+    };
+    /**
+     * - indicates whether the channel is muted
+     */
+    isMuted: boolean;
+    /**
+     * - array of voices currently active on the channel
+     */
+    voices: WorkletVoice[];
+    /**
+     * - array of voices that are sustained on the channel
+     */
+    sustainedVoices: WorkletVoice[];
+    /**
+     * - first is midi note, second is velocity. output is an array of WorkletVoices
+     */
+    cachedVoices: WorkletVoice[][][];
+};

package/package/@types/synthetizer/worklet_url.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The absolute path (from the spessasynth_lib folder) to the worklet module
+ * @type {string}
+ */
+export const WORKLET_URL_ABSOLUTE: string;

package/package/@types/utils/buffer_to_wav.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param audioBuffer {AudioBuffer}
+ * @param normalizeAudio {boolean} find the max sample point and set it to 1, and scale others with it
+ * @param channelOffset {number} channel offset and channel offset + 1 get saved
+ * @returns {Blob}
+ */
+export function audioBufferToWav(audioBuffer: AudioBuffer, normalizeAudio?: boolean, channelOffset?: number): Blob;

package/package/@types/utils/byte_functions/big_endian.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reads as Big endian
+ * @param dataArray {IndexedByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintBigEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
+/**
+ * @param number {number}
+ * @param bytesAmount {number}
+ * @returns {number[]}
+ */
+export function writeBytesAsUintBigEndian(number: number, bytesAmount: number): number[];

package/package/@types/utils/byte_functions/little_endian.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reads as little endian
+ * @param dataArray {IndexedByteArray}
+ * @param bytesAmount {number}
+ * @returns {number}
+ */
+export function readBytesAsUintLittleEndian(dataArray: IndexedByteArray, bytesAmount: number): number;
+/**
+ * Writes a number as little endian seems to also work for negative numbers so yay?
+ * @param dataArray {IndexedByteArray}
+ * @param number {number}
+ * @param byteTarget {number}
+ */
+export function writeLittleEndian(dataArray: IndexedByteArray, number: number, byteTarget: number): void;
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param word {number}
+ */
+export function writeWord(dataArray: IndexedByteArray, word: number): void;
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param dword {number}
+ */
+export function writeDword(dataArray: IndexedByteArray, dword: number): void;
+/**
+ * @param byte1 {number}
+ * @param byte2 {number}
+ * @returns {number}
+ */
+export function signedInt16(byte1: number, byte2: number): number;
+/**
+ * @param byte {number}
+ * @returns {number}
+ */
+export function signedInt8(byte: number): number;

package/package/@types/utils/byte_functions/string.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param dataArray {IndexedByteArray}
+ * @param bytes {number}
+ * @param encoding {string} the textElement encoding
+ * @param trimEnd {boolean} if we should trim once we reach an invalid byte
+ * @returns {string}
+ */
+export function readBytesAsString(dataArray: IndexedByteArray, bytes: number, encoding?: string, trimEnd?: boolean): string;
+/**
+ * @param string {string}
+ * @param padLength {number}
+ * @returns {IndexedByteArray}
+ */
+export function getStringBytes(string: string, padLength?: number): IndexedByteArray;
+/**
+ * @param string {string}
+ * @param outArray {IndexedByteArray}
+ * @param padLength {number}
+ * @returns {IndexedByteArray} modified IN PLACE
+ */
+export function writeStringAsBytes(outArray: IndexedByteArray, string: string, padLength?: number): IndexedByteArray;
+import { IndexedByteArray } from '../indexed_array.js';

package/package/@types/utils/byte_functions/variable_length_quantity.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Reads VLQ From a MIDI byte array
+ * @param MIDIbyteArray {IndexedByteArray}
+ * @returns {number}
+ */
+export function readVariableLengthQuantity(MIDIbyteArray: IndexedByteArray): number;
+/**
+ * Write a VLQ from a number to a byte array
+ * @param number {number}
+ * @returns {number[]}
+ */
+export function writeVariableLengthQuantity(number: number): number[];

package/package/@types/utils/indexed_array.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param arrs {(IndexedByteArray|Uint8Array)[]}
+ * @returns {IndexedByteArray|Uint8Array}
+ */
+export function combineArrays(arrs: (IndexedByteArray | Uint8Array)[]): IndexedByteArray | Uint8Array;
+/**
+ * indexed_array.js
+ * purpose: exteds Uint8Array with a currentIndex property
+ */
+export class IndexedByteArray extends Uint8Array {
+    /**
+     * Creates a new instance of an Uint8Array with a currentIndex property
+     * @param args {any} same as for Uint8Array
+     */
+    constructor(args: any);
+    /**
+     * The current index of the array
+     * @type {number}
+     */
+    currentIndex: number;
+}

package/package/@types/utils/loggin.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Enables or disables looging
+ * @param enableInfo {boolean} - enables info
+ * @param enableWarn {boolean} - enables warning
+ * @param enableGroup {boolean} - enables groups
+ * @param enableTable {boolean} - enables tables
+ */
+export function SpessaSynthLogging(enableInfo: boolean, enableWarn: boolean, enableGroup: boolean, enableTable: boolean): void;
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthInfo(...message: any[]): void;
+/**
+ * @param message {...any}
+ */
+export function SpessaSynthWarn(...message: any[]): void;
+export function SpessaSynthTable(...args: any[]): void;
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroup(...message: any[]): void;
+/**
+ * @param message {...any} the message
+ */
+export function SpessaSynthGroupCollapsed(...message: any[]): void;
+export function SpessaSynthGroupEnd(): void;