@grame/faustwasm 0.0.25

package/src/LibFaust.ts

@@ -0,0 +1,57 @@
+import type { FaustModule, LibFaustWasm, FaustInfoType } from "./types";
+
+export interface ILibFaust extends LibFaustWasm {
+    module(): FaustModule;
+    fs(): typeof FS;
+}
+
+class LibFaust implements ILibFaust {
+    private fModule: FaustModule;
+    private fCompiler: LibFaustWasm;
+    private fFileSystem: typeof FS;
+
+    constructor(module: FaustModule) {
+        this.fModule = module;
+        this.fCompiler = new module.libFaustWasm();
+        this.fFileSystem = this.fModule.FS;
+    }
+    module() {
+        return this.fModule;
+    }
+    fs() {
+        return this.fFileSystem;
+    }
+    version() {
+        return this.fCompiler.version();
+    }
+    createDSPFactory(name: string, code: string, args: string, useInternalMemory: boolean) {
+        return this.fCompiler.createDSPFactory(name, code, args, useInternalMemory);
+    }
+    deleteDSPFactory(cFactory: number) {
+        return this.fCompiler.deleteDSPFactory(cFactory);
+    }
+    expandDSP(name: string, code: string, args: string) {
+        return this.fCompiler.expandDSP(name, code, args);
+    }
+    generateAuxFiles(name: string, code: string, args: string) {
+        return this.fCompiler.generateAuxFiles(name, code, args);
+    }
+    deleteAllDSPFactories() {
+        return this.fCompiler.deleteAllDSPFactories();
+    }
+    getErrorAfterException() {
+        return this.fCompiler.getErrorAfterException();
+    }
+    cleanupAfterException() {
+        return this.fCompiler.cleanupAfterException();
+    }
+    getInfos(what: FaustInfoType) {
+        return this.fCompiler.getInfos(what);
+    }
+    toString() {
+        return `LibFaust module: ${this.fModule}, compiler: ${this.fCompiler}`;
+    }
+
+}
+
+export default LibFaust;

package/src/WavDecoder.ts

@@ -0,0 +1,207 @@
+export interface WavDecoderOptions {
+    symmetric?: boolean;
+    shared?: boolean;
+}
+interface Format {
+    formatId: number;
+    float: boolean;
+    numberOfChannels: number;
+    sampleRate: number;
+    byteRate: number;
+    blockSize: number;
+    bitDepth: number;
+}
+
+/**
+ * Code from https://github.com/mohayonao/wav-decoder
+ */
+class WavDecoder {
+    static decode(buffer: ArrayBuffer, options?: WavDecoderOptions) {
+        const dataView = new DataView(buffer);
+        const reader = new Reader(dataView);
+        if (reader.string(4) !== "RIFF") {
+            throw new TypeError("Invalid WAV file");
+        }
+        reader.uint32(); // skip file length
+        if (reader.string(4) !== "WAVE") {
+            throw new TypeError("Invalid WAV file");
+        }
+        let format: Format | null = null;
+        let audioData: {
+            numberOfChannels: number;
+            length: number;
+            sampleRate: number;
+            channelData: Float32Array[];
+        } | null = null;
+        do {
+            const chunkType = reader.string(4);
+            const chunkSize = reader.uint32();
+            if (chunkType === "fmt ") {
+                format = this.decodeFormat(reader, chunkSize);
+            } else if (chunkType === "data") {
+                audioData = this.decodeData(reader, chunkSize, format as Format, options || {});
+            } else {
+                reader.skip(chunkSize);
+            }
+        } while (audioData === null);
+        return audioData;
+    }
+    private static decodeFormat(reader: Reader, chunkSize: number) {
+        const formats = {
+            0x0001: "lpcm",
+            0x0003: "lpcm"
+        };
+        const formatId = reader.uint16();
+        if (!formats.hasOwnProperty(formatId)) {
+            throw new TypeError("Unsupported format in WAV file: 0x" + formatId.toString(16));
+        }
+        const format: Format = {
+            formatId: formatId,
+            float: formatId === 0x0003,
+            numberOfChannels: reader.uint16(),
+            sampleRate: reader.uint32(),
+            byteRate: reader.uint32(),
+            blockSize: reader.uint16(),
+            bitDepth: reader.uint16()
+        };
+        reader.skip(chunkSize - 16);
+        return format;
+    }
+    private static decodeData(reader: Reader, chunkSizeIn: number, format: Format, options: WavDecoderOptions) {
+        const chunkSize = Math.min(chunkSizeIn, reader.remain());
+        const length = Math.floor(chunkSize / format.blockSize);
+        const numberOfChannels = format.numberOfChannels;
+        const sampleRate = format.sampleRate;
+        const channelData: Float32Array[] = new Array(numberOfChannels);
+        for (let ch = 0; ch < numberOfChannels; ch++) {
+            const AB = options.shared ? (globalThis.SharedArrayBuffer || globalThis.ArrayBuffer) : globalThis.ArrayBuffer;
+            const ab = new AB(length * Float32Array.BYTES_PER_ELEMENT);
+            channelData[ch] = new Float32Array(ab);
+        }
+        this.readPCM(reader, channelData, length, format, options);
+        return {
+            numberOfChannels,
+            length,
+            sampleRate,
+            channelData
+        };
+    }
+    private static readPCM(reader: Reader, channelData: Float32Array[], length: number, format: Format, options: WavDecoderOptions) {
+        const bitDepth = format.bitDepth;
+        const decoderOption = format.float ? "f" : options.symmetric ? "s" : "";
+        const methodName = "pcm" + bitDepth + decoderOption as `pcm${8 | 16 | 32}${"f" | "s" | ""}`;
+        if (!(reader as any)[methodName]) {
+            throw new TypeError("Not supported bit depth: " + format.bitDepth);
+        }
+        const read: () => number = (reader as any)[methodName].bind(reader);
+        const numberOfChannels = format.numberOfChannels;
+        for (let i = 0; i < length; i++) {
+            for (let ch = 0; ch < numberOfChannels; ch++) {
+                channelData[ch][i] = read();
+            }
+        }
+    }
+}
+
+class Reader {
+    pos = 0;
+    dataView: DataView;
+    constructor(dataView: DataView) {
+        this.dataView = dataView;
+    }
+    remain() {
+        return this.dataView.byteLength - this.pos;
+    }
+    skip(n: number) {
+        this.pos += n;
+    }
+    uint8() {
+        const data = this.dataView.getUint8(this.pos);
+        this.pos += 1;
+        return data;
+    }
+    int16() {
+        const data = this.dataView.getInt16(this.pos, true);
+        this.pos += 2;
+        return data;
+    }
+    uint16() {
+        const data = this.dataView.getUint16(this.pos, true);
+        this.pos += 2;
+        return data;
+    }
+    uint32() {
+        const data = this.dataView.getUint32(this.pos, true);
+        this.pos += 4;
+        return data;
+    }
+    string(n: number) {
+        let data = "";
+        for (let i = 0; i < n; i++) {
+            data += String.fromCharCode(this.uint8());
+        }
+        return data;
+    }
+    pcm8() {
+        const data = this.dataView.getUint8(this.pos) - 128;
+        this.pos += 1;
+        return data < 0 ? data / 128 : data / 127;
+    }
+    pcm8s() {
+        const data = this.dataView.getUint8(this.pos) - 127.5;
+        this.pos += 1;
+        return data / 127.5;
+    }
+    pcm16() {
+        const data = this.dataView.getInt16(this.pos, true);
+        this.pos += 2;
+        return data < 0 ? data / 32768 : data / 32767;
+    }
+    pcm16s() {
+        const data = this.dataView.getInt16(this.pos, true);
+        this.pos += 2;
+        return data / 32768;
+    }
+    pcm24() {
+        const x0 = this.dataView.getUint8(this.pos + 0);
+        const x1 = this.dataView.getUint8(this.pos + 1);
+        const x2 = this.dataView.getUint8(this.pos + 2);
+        const xx = (x0 + (x1 << 8) + (x2 << 16));
+
+        const data = xx > 0x800000 ? xx - 0x1000000 : xx;
+        this.pos += 3;
+        return data < 0 ? data / 8388608 : data / 8388607;
+    }
+    pcm24s() {
+        const x0 = this.dataView.getUint8(this.pos + 0);
+        const x1 = this.dataView.getUint8(this.pos + 1);
+        const x2 = this.dataView.getUint8(this.pos + 2);
+        const xx = (x0 + (x1 << 8) + (x2 << 16));
+
+        const data = xx > 0x800000 ? xx - 0x1000000 : xx;
+        this.pos += 3;
+        return data / 8388608;
+    }
+    pcm32() {
+        const data = this.dataView.getInt32(this.pos, true);
+        this.pos += 4;
+        return data < 0 ? data / 2147483648 : data / 2147483647;
+    }
+    pcm32s() {
+        const data = this.dataView.getInt32(this.pos, true);
+        this.pos += 4;
+        return data / 2147483648;
+    }
+    pcm32f() {
+        const data = this.dataView.getFloat32(this.pos, true);
+        this.pos += 4;
+        return data;
+    }
+    pcm64f() {
+        const data = this.dataView.getFloat64(this.pos, true);
+        this.pos += 8;
+        return data;
+    }
+}
+
+export default WavDecoder;

package/src/WavEncoder.ts

@@ -0,0 +1,204 @@
+export interface WavEncoderOptions {
+    bitDepth: number;
+    float?: boolean;
+    symmetric?: boolean;
+    shared?: boolean;
+    sampleRate: number;
+}
+interface Format {
+    formatId: number;
+    float: boolean;
+    symmetric: boolean;
+    numberOfChannels: number;
+    sampleRate: number;
+    length: number;
+    bitDepth: number;
+    byteDepth: number;
+}
+
+/**
+ * Code from https://github.com/mohayonao/wav-encoder
+ */
+class WavEncoder {
+    static encode(audioBuffer: Float32Array[], options: WavEncoderOptions) {
+        const numberOfChannels = audioBuffer.length;
+        const length = audioBuffer[0].length;
+        const { shared, float } = options;
+        const bitDepth = float ? 32 : ((options.bitDepth | 0) || 16);
+        const byteDepth = bitDepth >> 3;
+        const byteLength = length * numberOfChannels * byteDepth;
+        // eslint-disable-next-line no-undef
+        const AB = shared ? (globalThis.SharedArrayBuffer || globalThis.ArrayBuffer) : globalThis.ArrayBuffer;
+        const ab = new AB((44 + byteLength) * Uint8Array.BYTES_PER_ELEMENT);
+        const dataView = new DataView(ab);
+        const writer = new Writer(dataView);
+        const format: Format = {
+            formatId: float ? 0x0003 : 0x0001,
+            float: !!float,
+            numberOfChannels,
+            sampleRate: options.sampleRate,
+            symmetric: !!options.symmetric,
+            length,
+            bitDepth,
+            byteDepth
+        };
+        this.writeHeader(writer, format);
+        this.writeData(writer, audioBuffer, format);
+        return ab;
+    }
+    private static writeHeader(writer: Writer, format: Format) {
+        const { formatId, sampleRate, bitDepth, numberOfChannels, length, byteDepth } = format;
+        writer.string("RIFF");
+        writer.uint32(writer.dataView.byteLength - 8);
+        writer.string("WAVE");
+        writer.string("fmt ");
+        writer.uint32(16);
+        writer.uint16(formatId);
+        writer.uint16(numberOfChannels);
+        writer.uint32(sampleRate);
+        writer.uint32(sampleRate * numberOfChannels * byteDepth);
+        writer.uint16(numberOfChannels * byteDepth);
+        writer.uint16(bitDepth);
+        writer.string("data");
+        writer.uint32(length * numberOfChannels * byteDepth);
+        return writer.pos;
+    }
+    private static writeData(writer: Writer, audioBuffer: Float32Array[], format: Format) {
+        const { bitDepth, float, length, numberOfChannels, symmetric } = format;
+        if (bitDepth === 32 && float) {
+            const { dataView, pos } = writer;
+            const ab = dataView.buffer;
+            const f32View = new Float32Array(ab, pos);
+            if (numberOfChannels === 1) {
+                f32View.set(audioBuffer[0]);
+                return;
+            }
+            for (let ch = 0; ch < numberOfChannels; ch++) {
+                const channel = audioBuffer[ch];
+                for (let i = 0; i < length; i++) {
+                    f32View[i * numberOfChannels + ch] = channel[i];
+                }
+            }
+            return;
+        }
+        const encoderOption = float ? "f" : symmetric ? "s" : "";
+        const methodName = "pcm" + bitDepth + encoderOption;
+
+        if (!(writer as any)[methodName]) {
+            throw new TypeError("Not supported bit depth: " + bitDepth);
+        }
+
+        const write: (value: number) => void = (writer as any)[methodName].bind(writer);
+
+        for (let i = 0; i < length; i++) {
+            for (let j = 0; j < numberOfChannels; j++) {
+                write(audioBuffer[j][i]);
+            }
+        }
+    }
+}
+
+class Writer {
+    pos = 0;
+    dataView: DataView;
+    constructor(dataView: DataView) {
+        this.dataView = dataView;
+    }
+    int16(value: number) {
+        this.dataView.setInt16(this.pos, value, true);
+        this.pos += 2;
+    }
+    uint16(value: number) {
+        this.dataView.setUint16(this.pos, value, true);
+        this.pos += 2;
+    }
+    uint32(value: number) {
+        this.dataView.setUint32(this.pos, value, true);
+        this.pos += 4;
+    }
+    string(value: string) {
+        for (let i = 0, imax = value.length; i < imax; i++) {
+            this.dataView.setUint8(this.pos++, value.charCodeAt(i));
+        }
+    }
+    pcm8(valueIn: number) {
+        let value = valueIn;
+        value = Math.max(-1, Math.min(value, +1));
+        value = (value * 0.5 + 0.5) * 255;
+        value = Math.round(value) | 0;
+        this.dataView.setUint8(this.pos, value/* , true*/);
+        this.pos += 1;
+    }
+    pcm8s(valueIn: number) {
+        let value = valueIn;
+        value = Math.round(value * 128) + 128;
+        value = Math.max(0, Math.min(value, 255));
+        this.dataView.setUint8(this.pos, value/* , true*/);
+        this.pos += 1;
+    }
+    pcm16(valueIn: number) {
+        let value = valueIn;
+        value = Math.max(-1, Math.min(value, +1));
+        value = value < 0 ? value * 32768 : value * 32767;
+        value = Math.round(value) | 0;
+        this.dataView.setInt16(this.pos, value, true);
+        this.pos += 2;
+    }
+    pcm16s(valueIn: number) {
+        let value = valueIn;
+        value = Math.round(value * 32768);
+        value = Math.max(-32768, Math.min(value, 32767));
+        this.dataView.setInt16(this.pos, value, true);
+        this.pos += 2;
+    }
+    pcm24(valueIn: number) {
+        let value = valueIn;
+        value = Math.max(-1, Math.min(value, +1));
+        value = value < 0 ? 0x1000000 + value * 8388608 : value * 8388607;
+        value = Math.round(value) | 0;
+
+        const x0 = (value >> 0) & 0xFF;
+        const x1 = (value >> 8) & 0xFF;
+        const x2 = (value >> 16) & 0xFF;
+
+        this.dataView.setUint8(this.pos + 0, x0);
+        this.dataView.setUint8(this.pos + 1, x1);
+        this.dataView.setUint8(this.pos + 2, x2);
+        this.pos += 3;
+    }
+    pcm24s(valueIn: number) {
+        let value = valueIn;
+        value = Math.round(value * 8388608);
+        value = Math.max(-8388608, Math.min(value, 8388607));
+
+        const x0 = (value >> 0) & 0xFF;
+        const x1 = (value >> 8) & 0xFF;
+        const x2 = (value >> 16) & 0xFF;
+
+        this.dataView.setUint8(this.pos + 0, x0);
+        this.dataView.setUint8(this.pos + 1, x1);
+        this.dataView.setUint8(this.pos + 2, x2);
+        this.pos += 3;
+    }
+    pcm32(valueIn: number) {
+        let value = valueIn;
+        value = Math.max(-1, Math.min(value, +1));
+        value = value < 0 ? value * 2147483648 : value * 2147483647;
+        value = Math.round(value) | 0;
+        this.dataView.setInt32(this.pos, value, true);
+        this.pos += 4;
+    }
+    pcm32s(valueIn: number) {
+        let value = valueIn;
+        value = Math.round(value * 2147483648);
+        value = Math.max(-2147483648, Math.min(value, +2147483647));
+        this.dataView.setInt32(this.pos, value, true);
+        this.pos += 4;
+    }
+    pcm32f(value: number) {
+        this.dataView.setFloat32(this.pos, value, true);
+        this.pos += 4;
+    }
+}
+
+export default WavEncoder;

package/src/copyWebStandaloneAssets.d.ts

@@ -0,0 +1,3 @@
+declare const copyWebStandaloneAssets: (outputDir: string) => void;
+
+export default copyWebStandaloneAssets;

package/src/copyWebStandaloneAssets.js

@@ -0,0 +1,20 @@
+//@ts-check
+import * as fs from "fs";
+import * as path from "path";
+import { cpSync } from "../fileutils.js";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+
+/**
+ * @param {string} outputDir
+ */
+const copyWebStandaloneAssets = (outputDir) => {
+    console.log(`Writing assets files.`)
+    const assetsPath = path.join(__dirname, "../assets/standalone");
+    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir);
+    cpSync(assetsPath, outputDir);
+};
+
+export default copyWebStandaloneAssets;

package/src/exports-bundle.ts

@@ -0,0 +1,5 @@
+export { default as instantiateFaustModule } from "./instantiateFaustModule";
+
+export * from "./instantiateFaustModule";
+
+export * from "./exports";

package/src/exports.ts

@@ -0,0 +1,24 @@
+export { default as instantiateFaustModuleFromFile } from "./instantiateFaustModuleFromFile";
+export { default as getFaustAudioWorkletProcessor } from "./FaustAudioWorkletProcessor";
+export { default as getFaustFFTAudioWorkletProcessor } from "./FaustFFTAudioWorkletProcessor";
+export { default as FaustCompiler } from "./FaustCompiler";
+export { default as FaustDspInstance } from "./FaustDspInstance";
+export { default as FaustWasmInstantiator } from "./FaustWasmInstantiator";
+export { default as FaustOfflineProcessor } from "./FaustOfflineProcessor";
+export { default as FaustSvgDiagrams } from "./FaustSvgDiagrams";
+export { default as LibFaust } from "./LibFaust";
+export { default as WavEncoder } from "./WavEncoder";
+export { default as WavDecoder } from "./WavDecoder";
+
+export * from "./FaustAudioWorkletNode";
+export * from "./FaustAudioWorkletProcessor";
+export * from "./FaustFFTAudioWorkletProcessor";
+export * from "./FaustCompiler";
+export * from "./FaustDspInstance";
+export * from "./FaustOfflineProcessor";
+export * from "./FaustScriptProcessorNode";
+export * from "./FaustWebAudioDsp";
+export * from "./FaustDspGenerator";
+export * from "./LibFaust";
+
+export * from "./types";

package/src/faust2svgFiles.d.ts

@@ -0,0 +1,3 @@
+declare const faust2svgFiles: (inputFile: string, outputDir: string, argv?: string[]) => Promise<Record<string, string>>;
+
+export default faust2svgFiles;

package/src/faust2svgFiles.js

@@ -0,0 +1,43 @@
+//@ts-check
+import * as fs from "fs";
+import * as path from "path";
+import {
+    instantiateFaustModuleFromFile,
+    LibFaust,
+    FaustCompiler,
+    FaustSvgDiagrams
+} from "../dist/esm/index.js";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+
+/**
+ * @param {string} inputFile
+ * @param {string} outputDir
+ * @param {string[]} [argv]
+ */
+const faust2svgFiles = async (inputFile, outputDir, argv = []) => {
+    const faustModule = await instantiateFaustModuleFromFile(path.join(__dirname, "../libfaust-wasm/libfaust-wasm.js"));
+    const libFaust = new LibFaust(faustModule);
+    const compiler = new FaustCompiler(libFaust);
+    console.log(`Faust Compiler version: ${compiler.version()}`);
+    console.log(`Reading file ${inputFile}`);
+    const code = fs.readFileSync(inputFile, { encoding: "utf8" });
+
+    if (!argv.find(a => a === "-I")) argv.push("-I", "libraries/");
+    const { name } = path.parse(inputFile);
+    const diagram = new FaustSvgDiagrams(compiler);
+    const svgs = diagram.from(name, code, argv.join(" "));
+    console.log(`Generated ${Object.keys(svgs).length} files.`);
+
+    console.log(`Writing files to ${outputDir}`);
+    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir);
+    for (const file in svgs) {
+        const svgPath = path.join(outputDir, file);
+        fs.writeFileSync(svgPath, svgs[file]);
+    }
+    return svgs;
+};
+
+export default faust2svgFiles;

package/src/faust2wasmFiles.d.ts

@@ -0,0 +1,5 @@
+import { FaustDspMeta } from "./types";
+
+declare const faust2wasmFiles: (inputFile: string, outputDir: string, argv?: string[], poly?: boolean) => Promise<{ dspMeta: FaustDspMeta; effectMeta: FaustDspMeta | null }>;
+
+export default faust2wasmFiles;

package/src/faust2wasmFiles.js

@@ -0,0 +1,93 @@
+//@ts-check
+import * as fs from "fs";
+import * as path from "path";
+import {
+    instantiateFaustModuleFromFile,
+    LibFaust,
+    FaustCompiler,
+    FaustMonoDspGenerator,
+    FaustPolyDspGenerator
+} from "../dist/esm/index.js";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = fileURLToPath(import.meta.url);
+
+/**
+ * @param {string} inputFile
+ * @param {string} outputDir
+ * @param {string[]} [argv]
+ * @param {boolean} [poly]
+ */
+const faust2wasmFiles = async (inputFile, outputDir, argv = [], poly = false) => {
+    const faustModule = await instantiateFaustModuleFromFile(path.join(__dirname, "../libfaust-wasm/libfaust-wasm.js"));
+    const libFaust = new LibFaust(faustModule);
+    const compiler = new FaustCompiler(libFaust);
+    console.log(`Faust Compiler version: ${compiler.version()}`);
+    console.log(`Reading file ${inputFile}`);
+    const code = fs.readFileSync(inputFile, { encoding: "utf8" });
+
+    if (!argv.find(a => a === "-I")) argv.push("-I", "libraries/");
+    const dspModulePath = path.join(outputDir, "dspModule.wasm");
+    const dspMetaPath = path.join(outputDir, "dspMeta.json");
+    const effectModulePath = path.join(outputDir, "effectModule.wasm");
+    const effectMetaPath = path.join(outputDir, "effectMeta.json");
+    const mixerModulePath = path.join(outputDir, "mixerModule.wasm");
+    /** @type {Uint8Array} */
+    let dspModule;
+    /** @type {import("./types").FaustDspMeta} */
+    let dspMeta;
+    /** @type {Uint8Array | null} */
+    let effectModule = null;
+    /** @type {import("./types").FaustDspMeta | null} */
+    let effectMeta = null;
+    /** @type {Uint8Array | null} */
+    let mixerModule = null;
+    const { name } = path.parse(inputFile);
+    if (poly) {
+        const generator = new FaustPolyDspGenerator();
+        const t1 = Date.now();
+        const dsp = await generator.compile(compiler, name, code, argv.join(" "));
+        if (!dsp) throw new Error("Faust DSP not compiled");
+        const { voiceFactory, effectFactory, mixerBuffer } = dsp;
+        if (!voiceFactory) throw new Error("Faust DSP Factory not compiled");
+        console.log(`Compilation successful (${Date.now() - t1} ms).`);
+        dspModule = voiceFactory.code;
+        dspMeta = JSON.parse(voiceFactory.json);
+        mixerModule = mixerBuffer;
+
+        if (effectFactory) {
+            effectModule = effectFactory.code;
+            effectMeta = JSON.parse(effectFactory.json);
+        }
+    } else {
+        const generator = new FaustMonoDspGenerator();
+        const t1 = Date.now();
+        const dsp = await generator.compile(compiler, name, code, argv.join(" "));
+        if (!dsp) throw new Error("Faust DSP not compiled");
+        const { factory } = dsp;
+        if (!factory) throw new Error("Faust DSP Factory not compiled");
+        console.log(`Compilation successful (${Date.now() - t1} ms).`);
+        dspModule = factory.code;
+        dspMeta = JSON.parse(factory.json);
+    }
+    const files = [dspModulePath, dspMetaPath];
+    if (mixerModule) files.push(mixerModulePath);
+    if (effectModule) files.push(effectModulePath, effectMetaPath);
+
+    console.log(`Writing files to ${outputDir}`);
+    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir);
+    for (const filePath in files) {
+        if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    }
+    fs.writeFileSync(dspModulePath, dspModule);
+    fs.writeFileSync(dspMetaPath, JSON.stringify(dspMeta, null, 4));
+    if (effectModule && effectMeta) {
+        fs.writeFileSync(effectModulePath, effectModule);
+        fs.writeFileSync(effectMetaPath, JSON.stringify(effectMeta, null, 4));
+    }
+    if (mixerModule) fs.writeFileSync(mixerModulePath, mixerModule);
+    return { dspMeta, effectMeta };
+};
+
+export default faust2wasmFiles;

package/src/faust2wavFiles.d.ts

@@ -0,0 +1,3 @@
+declare const faust2wavFiles: (inputFile: string, inputWav: string, outputWav: string, bufferSize?: number, sampleRate?: number, samples?: number, bitDepth?: number, argv?: string[]) => Promise<void>;
+
+export default faust2wavFiles;