@crossbind/bridge-tools 0.0.0-stage → 2.0.0-beta.69

package/dist/emscripten/include/emscripten/version.h

@@ -0,0 +1,12 @@
+/* Automatically generated by tools/system_libs.py */
+#define __EMSCRIPTEN_MAJOR__ 6
+#define __EMSCRIPTEN_MINOR__ 0
+#define __EMSCRIPTEN_TINY__ 13
+
+// Legacy mixed-case macros:
+#define __EMSCRIPTEN_major__ __EMSCRIPTEN_MAJOR__
+#define __EMSCRIPTEN_minor__ __EMSCRIPTEN_MINOR__
+#define __EMSCRIPTEN_tiny__ __EMSCRIPTEN_TINY__
+#pragma clang deprecated(__EMSCRIPTEN_major__, "Use __EMSCRIPTEN_MAJOR__ instead")
+#pragma clang deprecated(__EMSCRIPTEN_minor__, "Use __EMSCRIPTEN_MINOR__ instead")
+#pragma clang deprecated(__EMSCRIPTEN_tiny__, "Use __EMSCRIPTEN_TINY__ instead")

package/dist/emscripten/include/emscripten/wasm_worker.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2022 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <emscripten/atomic.h>
+#include <emscripten/em_types.h>
+#include <emscripten/threading_primitives.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define emscripten_wasm_worker_t int
+#define EMSCRIPTEN_WASM_WORKER_ID_PARENT 0
+
+// Creates a new Worker() that is attached to executing this
+// WebAssembly.Instance and WebAssembly.Memory.
+//
+// emscripten_malloc_wasm_worker:
+//   Creates a new Worker, dynamically allocating stack and TLS for it.
+//   Unfortunately due to the asynchronous no-notifications nature of how Worker
+//   API specification teardown behaves, the dynamically allocated memory can
+//   never be freed, so use this function only in scenarios where the page does
+//   not need to deinitialize/tear itself down.
+//
+// emscripten_create_wasm_worker:
+//   Creates a Wasm Worker given a preallocated region for stack and TLS data.
+//   Use this function to manually manage the memory that a Worker should use.
+//   This function does not use any dynamic memory allocation.
+//   Unlike with the above function, this variant requires that size of the
+//   region provided is large enough to hold both stack and TLS area.
+//   The size of the TLS area can be determined at runtime by calling
+//   __builtin_wasm_tls_size().
+//
+// Returns an ID that represents the given Worker. If not building with Wasm
+// workers enabled (-sWASM_WORKERS=0), these functions will return 0 to denote
+// failure.
+// Note that the Worker will be loaded up asynchronously, and initially will not
+// be executing any code. Use emscripten_wasm_worker_post_function_*() set of
+// functions to start executing code on the Worker.
+emscripten_wasm_worker_t emscripten_malloc_wasm_worker(size_t stackSize);
+emscripten_wasm_worker_t emscripten_create_wasm_worker(void * _Nonnull stackPlusTLSAddress, size_t stackPlusTLSSize);
+
+// Terminates the given Wasm Worker some time after it has finished executing
+// its current, or possibly some subsequent posted functions. Note that this
+// function is not C++ RAII safe, but you must manually coordinate to release
+// any resources from the given Worker that it may have allocated from the heap
+// or may have stored on its TLS slots.  There are no TLS destructors that would
+// execute.
+// Exists, but is a no-op if not building with Wasm Workers enabled
+// (-sWASM_WORKERS=0)
+void emscripten_terminate_wasm_worker(emscripten_wasm_worker_t id);
+
+// Note the comment on emscripten_terminate_wasm_worker(id) about thread
+// destruction.
+// Exists, but is a no-op if not building with Wasm Workers enabled
+// (-sWASM_WORKERS=0)
+void emscripten_terminate_all_wasm_workers(void);
+
+// Returns true if the current thread is executing a Wasm Worker, false
+// otherwise.
+bool emscripten_current_thread_is_wasm_worker(void);
+
+// Returns a unique ID that identifies the calling Wasm Worker. Similar to
+// pthread_self().  The main browser thread will return 0 as the ID. First Wasm
+// Worker will return 1, and so on.
+// Note: This function also returns 0 when called from other non-Wasm Worker
+// contexts, such as pthreads in a program built with both pthread and Wasm
+// Worker support.
+uint32_t emscripten_wasm_worker_self_id(void);
+
+// emscripten_wasm_worker_post_function_*: Post a pointer to a C/C++ function to
+// be executed on the target Wasm Worker (via sending a postMessage() to the
+// target thread). Notes: If running inside a Wasm Worker, specify worker ID 0
+// to pass a message to the parent thread.  When specifying non-zero ID, the
+// target worker must have been created by the calling thread. That is, a Wasm
+// Worker can only send a message to its parent or its children, but not to its
+// siblings.  The target function pointer will be executed on the target Worker
+// only after it yields back to its event loop. If the target Wasm Worker
+// executes an infinite loop that never yields, then the function pointer will
+// never be called.
+// Passing messages between threads with this family of functions is relatively
+// slow and has a really high latency cost compared to direct coordination using
+// atomics and synchronization primitives like mutexes. Additionally these 
+// functions will generate garbage on the JS heap.  Therefore avoid using these 
+// functions where performance is critical.
+void emscripten_wasm_worker_post_function_v(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(void));
+void emscripten_wasm_worker_post_function_vi(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(int), int arg0);
+void emscripten_wasm_worker_post_function_vii(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(int, int), int arg0, int arg1);
+void emscripten_wasm_worker_post_function_viii(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(int, int, int), int arg0, int arg1, int arg2);
+void emscripten_wasm_worker_post_function_vd(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(double), double arg0);
+void emscripten_wasm_worker_post_function_vdd(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(double, double), double arg0, double arg1);
+void emscripten_wasm_worker_post_function_vddd(emscripten_wasm_worker_t id, void (* _Nonnull funcPtr)(double, double, double), double arg0, double arg1, double arg2);
+void emscripten_wasm_worker_post_function_sig(emscripten_wasm_worker_t id, void * _Nonnull funcPtr, const char * _Nonnull sig, ...);
+
+// Sleeps the calling wasm worker for the given nanoseconds. Calling this
+// function on the main thread either results in a TypeError exception
+// (Firefox), or a silent return without waiting (Chrome), see
+// https://github.com/WebAssembly/threads/issues/174
+void emscripten_wasm_worker_sleep(int64_t nanoseconds);
+
+// Returns the value of navigator.hardwareConcurrency, i.e. the number of
+// logical threads available for the user agent. NOTE: If the execution
+// environment does not support navigator.hardwareConcurrency, this function
+// will return zero to signal no support. (If the value 1 is returned, then it
+// means that navigator.hardwareConcurrency is supported, but there is only one
+// logical thread of concurrency available)
+int emscripten_navigator_hardware_concurrency(void);
+
+// Legacy names for emscripten_atomic_wait/notify functions, defined in
+// emscripten/atomic.h
+#define emscripten_wasm_wait_i32 emscripten_atomic_wait_u32
+#define emscripten_wasm_wait_i64 emscripten_atomic_wait_u64
+#define emscripten_wasm_notify emscripten_atomic_notify
+#pragma clang deprecated(emscripten_wasm_wait_i32, "use emscripten_atomic_wait_u32 instead")
+#pragma clang deprecated(emscripten_wasm_wait_i64, "use emscripten_atomic_wait_u64 instead")
+#pragma clang deprecated(emscripten_wasm_notify, "use emscripten_atomic_notify instead")
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/wasmfs.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2021 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct Backend* backend_t;
+
+// Obtains the backend_t of a specified path.
+backend_t wasmfs_get_backend_by_path(const char* _Nonnull path);
+
+// Obtains the backend_t of a specified fd.
+backend_t wasmfs_get_backend_by_fd(int fd);
+
+// Creates and opens a new file using a specific backend.
+// Returns the file descriptor for the new file like `open`. Returns a negative
+// value on error. TODO: It might be worth returning a more specialized type
+// like __wasi_fd_t here.
+// TODO: Remove this function so that only directories can be mounted.
+int wasmfs_create_file(const char* _Nonnull pathname, mode_t mode, backend_t backend);
+
+// Creates a new directory using a specific backend.
+// Returns 0 on success like `mkdir`, or a negative value on error.
+// TODO: Add an alias with wasmfs_mount.
+int wasmfs_create_directory(const char* _Nonnull path, mode_t mode, backend_t backend);
+
+// Unmounts the directory (Which must be a valid mountpoint) at a specific path.
+// Returns 0 on success, or a negative value on error.
+int wasmfs_unmount(const char* _Nonnull path);
+
+// Backend creation
+
+// Creates a new JSFile Backend
+backend_t wasmfs_create_js_file_backend(void);
+
+// A function that receives a void* and returns a backend.
+typedef backend_t (*backend_constructor_t)(void*);
+
+backend_t wasmfs_create_memory_backend(void);
+
+// Fetch backend
+//
+// Creates a new fetchfs backend.  FetchFS will backstop filesystem
+// reads to HTTP fetch requests, which will download just specific
+// ranges of the requested files.  FetchFS works best when your web
+// server supports HTTP range requests, and it's important that those
+// files are not stored encrypted or compressed at rest.  FetchFS by
+// default will dispatch HTTP requests to URLs beginning with base_url
+// and ending with whatever the file's path is relative to where the
+// fetchfs directory is mounted.
+//
+// Individual range requests will be no bigger than chunk_size, and will
+// be aligned to boundaries of chunk_size.  Files smaller than chunk_size
+// will be downloaded all at once.
+//
+// If chunk_size is 0, a reasonable default value will be used.
+//
+// Note: this cannot be called on the browser main thread because it might
+// deadlock while waiting for its dedicated worker thread to be spawned.
+//
+// Note: This function blocks on the main browser thread returning to its event
+// loop. Calling this function while holding a lock the main thread is waiting
+// to acquire will cause a deadlock.
+//
+// TODO: Add an async version of this function that will work on the main
+// thread.
+//
+backend_t wasmfs_create_fetch_backend(const char* _Nonnull base_url, uint32_t chunk_size);
+
+backend_t wasmfs_create_node_backend(const char* _Nonnull root);
+
+// Note: this cannot be called on the browser main thread because it might
+// deadlock while waiting for the OPFS dedicated worker thread to be spawned.
+//
+// Note: This function blocks on the main browser thread returning to its event
+// loop. Calling this function while holding a lock the main thread is waiting
+// to acquire will cause a deadlock.
+//
+// TODO: Add an async version of this function that will work on the main
+// thread.
+backend_t wasmfs_create_opfs_backend(void);
+
+// Creates a generic JSIMPL backend
+backend_t wasmfs_create_jsimpl_backend(void);
+
+backend_t wasmfs_create_icase_backend(backend_t backend);
+
+// Similar to fflush(0), but also flushes all internal buffers inside WasmFS.
+// This is necessary because in a Web environment we must buffer at an
+// additional level after libc, since console.log() prints entire lines, that
+// is, we can't print individual characters as libc feeds them to us, so we
+// buffer them and call console.log() only after a newline. This function will
+// actually flush all buffers and add newlines as necessary to get everything
+// printed out.
+void wasmfs_flush(void);
+
+// Hooks
+
+// A hook users can do to create the root directory. Overriding this allows the
+// user to set a particular backend as the root. If this is not set then the
+// default backend is used.
+backend_t wasmfs_create_root_dir(void);
+
+// A hook users can do to run code during WasmFS startup. This hook happens
+// before file preloading, so user code could create backends and mount them,
+// which would then affect in which backend the preloaded files are loaded (the
+// preloaded files have paths, and so they are added to that path and whichever
+// backend is present there).
+void wasmfs_before_preload(void);
+
+#ifdef __cplusplus
+}
+#endif

package/dist/emscripten/include/emscripten/webaudio.h

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2022 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+
+#include <memory.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// A handle type that represents a JavaScript side object related to WebAudio.
+// Used to denote the AudioContext and Audio Nodes, especially the Audio Worklet
+// Node.
+typedef int EMSCRIPTEN_WEBAUDIO_T;
+
+// An outdated node type that represented an AudioWorklet node.
+// If you are using this type in your application, replace it with
+// EMSCRIPTEN_WEBAUDIO_T handle type instead.
+typedef int EMSCRIPTEN_AUDIO_WORKLET_NODE_T __attribute__((deprecated("use EMSCRIPTEN_WEBAUDIO_T instead")));
+
+// Default render size of 128 frames
+#define AUDIO_CONTEXT_RENDER_SIZE_DEFAULT 0
+// Let the hardware determine the best render size
+#define AUDIO_CONTEXT_RENDER_SIZE_HARDWARE -1
+
+typedef struct EmscriptenWebAudioCreateAttributes
+{
+	const char *latencyHint; // Specify one of "balanced", "interactive" or "playback"
+	uint32_t sampleRate; // E.g. 44100 or 48000
+	int32_t renderSizeHint; // AUDIO_CONTEXT_RENDER_SIZE_* or number of samples
+} EmscriptenWebAudioCreateAttributes;
+
+// Creates a new Web Audio AudioContext, and returns a handle to it.
+EMSCRIPTEN_WEBAUDIO_T emscripten_create_audio_context(const EmscriptenWebAudioCreateAttributes *options);
+
+typedef int AUDIO_CONTEXT_STATE;
+#define AUDIO_CONTEXT_STATE_SUSPENDED 0
+#define AUDIO_CONTEXT_STATE_RUNNING 1
+#define AUDIO_CONTEXT_STATE_CLOSED 2
+#define AUDIO_CONTEXT_STATE_INTERRUPTED	3
+
+typedef void (*EmscriptenResumeAudioContextCallback)(EMSCRIPTEN_WEBAUDIO_T audioContext, AUDIO_CONTEXT_STATE state, void *userData1);
+
+// Resumes the given AudioContext. The specified callback will fire when the AudioContext has completed resuming. Call this function
+// inside a user event handler (mousedown, button click, etc.)
+// userData1: A custom userdata pointer to pass to the callback function. This value will be passed on to the call to the given EmscriptenResumeAudioContextCallback callback function.
+void emscripten_resume_audio_context_async(EMSCRIPTEN_WEBAUDIO_T audioContext, EmscriptenResumeAudioContextCallback callback, void *userData1);
+
+// Synchronously attempts to resume the given AudioContext.
+void emscripten_resume_audio_context_sync(EMSCRIPTEN_WEBAUDIO_T audioContext);
+
+// Returns the current AudioContext state.
+AUDIO_CONTEXT_STATE emscripten_audio_context_state(EMSCRIPTEN_WEBAUDIO_T audioContext);
+
+typedef void (*EmscriptenStartWebAudioWorkletCallback)(EMSCRIPTEN_WEBAUDIO_T audioContext, bool success, void *userData2);
+
+// Calls .suspend() on the given AudioContext and releases the JS object table
+// reference to the given audio context. The specified handle is invalid
+// after calling this function.
+void emscripten_destroy_audio_context(EMSCRIPTEN_WEBAUDIO_T audioContext);
+
+// Disconnects the given audio node from its audio graph, and then releases
+// the JS object table reference to the given audio node. The specified handle
+// is invalid after calling this function.
+void emscripten_destroy_web_audio_node(EMSCRIPTEN_WEBAUDIO_T objectHandle);
+
+// Create Wasm AudioWorklet thread. Call this function once at application startup to establish an AudioWorkletGlobalScope for your app.
+// After the scope has been initialized, the given callback will fire.
+// audioContext: The Web Audio context object to initialize the Wasm AudioWorklet thread on. Each AudioContext can have only one AudioWorklet
+//               thread running, so do not call this function multiple times on the same AudioContext.
+// stackLowestAddress: The base address for the thread's stack. Must be aligned to 16 bytes. Use e.g. memalign(16, 1024) to allocate a 1KB stack for the thread.
+// stackSize: The size of the thread's stack. Must be a multiple of 16 bytes.
+// callback: The callback function that will be run when thread creation either succeeds or fails.
+// userData2: A custom userdata pointer to pass to the callback function. This value will be passed on to the call to the given EmscriptenStartWebAudioWorkletCallback callback function.
+void emscripten_start_wasm_audio_worklet_thread_async(EMSCRIPTEN_WEBAUDIO_T audioContext, void *stackLowestAddress, uint32_t stackSize, EmscriptenStartWebAudioWorkletCallback callback, void *userData2);
+
+typedef int WEBAUDIO_PARAM_AUTOMATION_RATE;
+#define WEBAUDIO_PARAM_A_RATE 0
+#define WEBAUDIO_PARAM_K_RATE 1
+
+typedef struct WebAudioParamDescriptor
+{
+	float defaultValue; // Default == 0.0
+	float minValue; // Default = -3.4028235e38
+	float maxValue; // Default = 3.4028235e38
+	WEBAUDIO_PARAM_AUTOMATION_RATE automationRate; // Either WEBAUDIO_PARAM_A_RATE or WEBAUDIO_PARAM_K_RATE. Default = WEBAUDIO_PARAM_A_RATE
+} WebAudioParamDescriptor;
+
+typedef struct WebAudioWorkletProcessorCreateOptions
+{
+	const char *name; // The name of the AudioWorkletProcessor that is being created.
+
+	int numAudioParams;
+	const WebAudioParamDescriptor *audioParamDescriptors;
+} WebAudioWorkletProcessorCreateOptions;
+
+typedef void (*EmscriptenWorkletProcessorCreatedCallback)(EMSCRIPTEN_WEBAUDIO_T audioContext, bool success, void *userData3);
+
+// Creates a new AudioWorkletProcessor with the given name and specified set of control parameters.
+// userData3: A custom userdata pointer to pass to the callback function. This value will be passed on to the call to the given EmscriptenWorkletProcessorCreatedCallback callback function.
+void emscripten_create_wasm_audio_worklet_processor_async(EMSCRIPTEN_WEBAUDIO_T audioContext, const WebAudioWorkletProcessorCreateOptions *options, EmscriptenWorkletProcessorCreatedCallback callback, void *userData3);
+
+// Returns the number of samples processed per channel in an AudioSampleFrame, fixed at 128 in the Web Audio API 1.0 specification, and valid for the lifetime of the audio context.
+// For this to differ from the default 128, the context would need to be created with a WebAudioWorkletProcessorCreateOptions renderSizeHint, part of the 1.1 Web Audio API.
+int emscripten_audio_context_quantum_size(EMSCRIPTEN_WEBAUDIO_T audioContext);
+
+// Returns the sampling rate of the given Audio Context, e.g. 48000 or 44100 or similar.
+int emscripten_audio_context_sample_rate(EMSCRIPTEN_WEBAUDIO_T audioContext);
+
+typedef struct AudioSampleFrame
+{
+	// Number of audio channels to process (multiplied by samplesPerChannel gives the elements in data)
+	const int numberOfChannels;
+	// Number of samples per channel in data
+	const int samplesPerChannel;
+	// An array of length numberOfChannels*samplesPerChannel elements. Samples are always arranged in a planar fashion,
+	// where data[channelIndex*samplesPerChannel+i] locates the data of the i'th sample of channel channelIndex.
+	float *data;
+} AudioSampleFrame;
+
+typedef struct AudioParamFrame
+{
+	// Specifies the length of the input array data (in float elements). This will be guaranteed to either have
+	// a value of 1, for a parameter valid for the entire frame, or emscripten_audio_context_quantum_size() for a parameter that changes per sample during the frame.
+	int length;
+	// An array of length specified in 'length'.
+	float *data;
+} AudioParamFrame;
+
+typedef bool (*EmscriptenWorkletNodeProcessCallback)(int numInputs, const AudioSampleFrame *inputs, int numOutputs, AudioSampleFrame *outputs, int numParams, const AudioParamFrame *params, void *userData4);
+
+typedef enum {
+    WEBAUDIO_CHANNEL_COUNT_MODE_MAX = 0,
+    WEBAUDIO_CHANNEL_COUNT_MODE_CLAMPED_MAX = 1,
+    WEBAUDIO_CHANNEL_COUNT_MODE_EXPLICIT = 2
+} WEBAUDIO_CHANNEL_COUNT_MODE;
+
+typedef enum {
+    WEBAUDIO_CHANNEL_INTERPRETATION_SPEAKERS = 0,
+    WEBAUDIO_CHANNEL_INTERPRETATION_DISCRETE = 1
+} WEBAUDIO_CHANNEL_INTERPRETATION;
+
+typedef struct EmscriptenAudioWorkletNodeCreateOptions
+{
+	// How many audio nodes does this node take inputs from? Default=1
+	int numberOfInputs;
+	// How many audio nodes does this node output to? Default=1
+	int numberOfOutputs;
+	// For each output, specifies the number of audio channels (1=mono/2=stereo/etc.) for that output. Default=an array of ones for each output channel.
+	int *outputChannelCounts;
+	// Number of channels used when up-mixing and down-mixing connections to any inputs to the node. Default=2
+	unsigned long channelCount;
+	// How channels will be counted when up-mixing and down-mixing connections to any inputs to the node? Default=max
+	WEBAUDIO_CHANNEL_COUNT_MODE channelCountMode;
+	// How individual channels will be treated when up-mixing and down-mixing connections to any inputs to the node? Default=speakers
+	WEBAUDIO_CHANNEL_INTERPRETATION channelInterpretation;
+
+} EmscriptenAudioWorkletNodeCreateOptions;
+
+// Instantiates the given AudioWorkletProcessor as an AudioWorkletNode, which continuously calls the specified processCallback() function on the browser's audio thread to perform audio processing.
+// userData4: A custom userdata pointer to pass to the callback function. This value will be passed on to the call to the given EmscriptenWorkletNodeProcessCallback callback function.
+// Returns a handle to the created audio worklet node object.
+EMSCRIPTEN_WEBAUDIO_T emscripten_create_wasm_audio_worklet_node(EMSCRIPTEN_WEBAUDIO_T audioContext, const char *name, const EmscriptenAudioWorkletNodeCreateOptions *options, EmscriptenWorkletNodeProcessCallback processCallback, void *userData4);
+
+// Connects a node's output to a target, e.g., connect the worklet node to the context.
+// For outputIndex and inputIndex, see the AudioNode.connect() documentation (setting 0 as the default values)
+void emscripten_audio_node_connect(EMSCRIPTEN_WEBAUDIO_T source, EMSCRIPTEN_WEBAUDIO_T destination, int outputIndex, int inputIndex);
+
+// Returns true if the current thread is executing a Wasm AudioWorklet, false otherwise.
+// Note that calling this function can be relatively slow as it incurs a Wasm->JS transition,
+// so avoid calling it in hot paths.
+bool emscripten_current_thread_is_audio_worklet(void);
+
+#define EMSCRIPTEN_AUDIO_MAIN_THREAD 0
+
+/* emscripten_audio_worklet_function_*: Post a pointer to a C/C++ function to be executed on the Audio Worklet 
+   thread of the given Web Audio context. Notes:
+ - If running inside an Audio Worklet thread, specify ID EMSCRIPTEN_AUDIO_MAIN_THREAD (== 0) to pass a message
+   from the audio worklet to the main thread.
+ - When specifying non-zero ID, the Audio Context denoted by the ID must have been created by the calling thread.
+ - Passing messages between audio thread and main thread with this family of functions is relatively slow and has
+   a really high latency cost compared to direct coordination using atomics and synchronization primitives like
+   mutexes. Additionally these functions will generate garbage on the JS heap. Therefore avoid using these
+   functions where performance is critical. */
+void emscripten_audio_worklet_post_function_v(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(void));
+void emscripten_audio_worklet_post_function_vi(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(int), int arg0);
+void emscripten_audio_worklet_post_function_vii(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(int, int), int arg0, int arg1);
+void emscripten_audio_worklet_post_function_viii(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(int, int, int), int arg0, int arg1, int arg2);
+void emscripten_audio_worklet_post_function_vd(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(double), double arg0);
+void emscripten_audio_worklet_post_function_vdd(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(double, double), double arg0, double arg1);
+void emscripten_audio_worklet_post_function_vddd(EMSCRIPTEN_WEBAUDIO_T id, void (*funcPtr)(double, double, double), double arg0, double arg1, double arg2);
+void emscripten_audio_worklet_post_function_sig(EMSCRIPTEN_WEBAUDIO_T id, void *funcPtr, const char *sig, ...);
+
+#ifdef __cplusplus
+} // ~extern "C"
+#endif

package/dist/emscripten/include/emscripten/websocket.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2018 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+
+#include <memory.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EMSCRIPTEN_WEBSOCKET_T int
+
+// Returns the WebSocket.readyState field into readyState. readyState must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_ready_state(EMSCRIPTEN_WEBSOCKET_T socket, unsigned short * _Nonnull readyState);
+
+// Returns the WebSocket.bufferedAmount field into bufferedAmount. bufferedAmount must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_buffered_amount(EMSCRIPTEN_WEBSOCKET_T socket, size_t * _Nonnull bufferedAmount);
+
+// Writes the WebSocket.url field as a UTF-8 string to the memory area pointed by url. The memory area must contain at least urlLength bytes of free space. If this memory area cannot
+// fit the url string, it will be truncated. Call emscripten_websocket_get_url_length() to determine how large memory area will be required to store the url.
+// url must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_url(EMSCRIPTEN_WEBSOCKET_T socket, char * _Nonnull url, int urlLength);
+// Returns the byte length needed to store WebSocket.url string in Wasm heap. This length can be passed to emscripten_websocket_get_url as it includes the null byte in the count.
+// urlLength must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_url_length(EMSCRIPTEN_WEBSOCKET_T socket, int * _Nonnull urlLength);
+
+// Similar to emscripten_websocket_get_url(), but returns WebSocket.extensions field instead.
+EMSCRIPTEN_RESULT emscripten_websocket_get_extensions(EMSCRIPTEN_WEBSOCKET_T socket, char * _Nonnull extensions, int extensionsLength);
+EMSCRIPTEN_RESULT emscripten_websocket_get_extensions_length(EMSCRIPTEN_WEBSOCKET_T socket, int * _Nonnull extensionsLength);
+
+// Similar to emscripten_websocket_get_url(), but returns WebSocket.protocol field instead.
+EMSCRIPTEN_RESULT emscripten_websocket_get_protocol(EMSCRIPTEN_WEBSOCKET_T socket, char * _Nonnull protocol, int protocolLength);
+EMSCRIPTEN_RESULT emscripten_websocket_get_protocol_length(EMSCRIPTEN_WEBSOCKET_T socket, int * _Nonnull protocolLength);
+
+typedef struct EmscriptenWebSocketOpenEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+} EmscriptenWebSocketOpenEvent;
+
+typedef bool (*em_websocket_open_callback_func)(int eventType, const EmscriptenWebSocketOpenEvent * _Nonnull websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onopen_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_open_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketMessageEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+  uint8_t *data;
+  uint32_t numBytes;
+  bool isText;
+} EmscriptenWebSocketMessageEvent;
+
+typedef bool (*em_websocket_message_callback_func)(int eventType, const EmscriptenWebSocketMessageEvent * _Nonnull websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onmessage_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_message_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketErrorEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+} EmscriptenWebSocketErrorEvent;
+
+typedef bool (*em_websocket_error_callback_func)(int eventType, const EmscriptenWebSocketErrorEvent * _Nonnull websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onerror_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_error_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketCloseEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+  bool wasClean;
+  unsigned short code;
+  char reason[512]; // WebSockets spec enforces this can be max 123 characters, so as UTF-8 at most 123*4 bytes < 512.
+} EmscriptenWebSocketCloseEvent;
+
+typedef bool (*em_websocket_close_callback_func)(int eventType, const EmscriptenWebSocketCloseEvent * _Nonnull websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onclose_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_close_callback_func callback, pthread_t targetThread);
+
+#define emscripten_websocket_set_onopen_callback(socket, userData, callback)    emscripten_websocket_set_onopen_callback_on_thread(   (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onerror_callback(socket, userData, callback)   emscripten_websocket_set_onerror_callback_on_thread(  (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onclose_callback(socket, userData, callback)   emscripten_websocket_set_onclose_callback_on_thread(  (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onmessage_callback(socket, userData, callback) emscripten_websocket_set_onmessage_callback_on_thread((socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+
+typedef struct EmscriptenWebSocketCreateAttributes {
+  // The target URL to connect to. This string can point to a stack local variable, the string is read immediately at a call to emscripten_websocket_new().
+  const char *url;
+  // A comma-separated list of protocol strings. Set to e.g. "binary,base64" to create a WebSocket connection with two supported protocols "binary" and "base64".
+  // Be careful to avoid leading and trailing spaces, e.g. "binary, base64" may not be interpreted properly.
+  // This string can point to a stack local variable, the string is read immediately at a call to emscripten_websocket_new().
+  const char *protocols;
+
+  // If true, the created socket will reside on the main browser thread. If false, the created socket is bound to the calling thread.
+  // If you want to share the created EMSCRIPTEN_WEBSOCKET_T structure across multiple threads, or are running your own main loop in the
+  // pthread that you create the socket, set createOnMainThread to true. If the created WebSocket only needs to be accessible on the thread
+  // that created it, and the creating thread is an event based thread (meaning it regularly yields back to the browser event loop), then
+  // it is more efficient to set this to false.
+  bool createOnMainThread;
+} EmscriptenWebSocketCreateAttributes;
+
+//extern void emscripten_websocket_init_create_attributes(EmscriptenWebSocketCreateAttributes *attributes);
+#define emscripten_websocket_init_create_attributes(attributes) do { memset((attributes), 0, sizeof(EmscriptenWebSocketCreateAttributes)); } while(0)
+
+// Returns true if WebSockets are supported by the current browser
+bool emscripten_websocket_is_supported(void);
+
+// Creates a new WebSocket and connects it to the given remote host.
+// If the return value of this function is > 0, the function has succeeded and the return value represents a handle to the WebSocket object.
+// If the return value of this function is < 0, then the function has failed, and the return value can be interpreted as a EMSCRIPTEN_RESULT code
+// representing the cause of the failure. If the function returns 0, then the call has failed with an unknown reason (build with -sWEBSOCKET_DEBUG for more information)
+EMSCRIPTEN_WEBSOCKET_T emscripten_websocket_new(EmscriptenWebSocketCreateAttributes * _Nonnull createAttributes);
+
+// Sends the given string of null-delimited UTF8 encoded text data to the connected server.
+EMSCRIPTEN_RESULT emscripten_websocket_send_utf8_text(EMSCRIPTEN_WEBSOCKET_T socket, const char * _Nonnull textData);
+
+// Sends the given block of raw memory data out to the connected server.
+EMSCRIPTEN_RESULT emscripten_websocket_send_binary(EMSCRIPTEN_WEBSOCKET_T socket, void * _Nonnull binaryData, uint32_t dataLength);
+
+// Closes the specified WebSocket. N.B.: the meaning of "closing" a WebSocket means "eager read/lazy write"-closing the socket. That is, all still
+// pending untransferred outbound bytes will continue to transfer out, but after calling close on the socket, any pending bytes still in the process
+// of being received will never be available. See https://html.spec.whatwg.org/multipage/web-sockets.html#dom-websocket-sclose
+// After calling close(), it is no longer possible to send() on the WebSocket to send more bytes.
+EMSCRIPTEN_RESULT emscripten_websocket_close(EMSCRIPTEN_WEBSOCKET_T socket, unsigned short code, const char *reason);
+
+// Releases the given WebSocket object and all associated allocated memory for garbage collection. This effectively frees the socket handle, after calling
+// this function the given handle no longer exists.
+EMSCRIPTEN_RESULT emscripten_websocket_delete(EMSCRIPTEN_WEBSOCKET_T socket);
+
+// This function close()s and releases all created WebSocket connections for the current thread. You can call this at application exit time to enforce
+// teardown of all active sockets, although it is optional. When a pthread terminates, it will call this function to delete all active connections bound to
+// that specific pthread (sockets created with createOnMainThread=false). Any WebSockets created by a pthread with createOnMainThread=true will remain alive
+// even after the pthread quits, although be warned that if the target thread that was registered to handle events for a given WebSocket quits, then those
+// events will stop from being delivered altogether.
+void emscripten_websocket_deinitialize(void);
+
+#ifdef __cplusplus
+} // ~extern "C"
+#endif

package/dist/emscripten/include/emscripten/wget.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2012 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "em_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// wget
+
+void emscripten_async_wget(const char* url, const char* file, em_str_callback_func onload, em_str_callback_func onerror);
+
+typedef void (*em_async_wget_onload_func)(void* userdata, void* data, int size);
+void emscripten_async_wget_data(const char* url, void *userdata, em_async_wget_onload_func onload, em_arg_callback_func onerror);
+
+typedef void (*em_async_wget2_onload_func)(unsigned handle, void* userdata, const char* data);
+typedef void (*em_async_wget2_onstatus_func)(unsigned handle, void* userdata, int status);
+
+int emscripten_async_wget2(const char* url, const char* file,  const char* requesttype, const char* param, void *userdata, em_async_wget2_onload_func onload, em_async_wget2_onstatus_func onerror, em_async_wget2_onstatus_func onprogress);
+
+typedef void (*em_async_wget2_data_onload_func)(unsigned handle, void* userdata, void* data, unsigned size);
+typedef void (*em_async_wget2_data_onerror_func)(unsigned handle, void* userdata, int status, const char* status_text);
+typedef void (*em_async_wget2_data_onprogress_func)(unsigned handle, void* userdata, int loaded, int total);
+
+int emscripten_async_wget2_data(const char* url, const char* requesttype, const char* param, void *arg, int free, em_async_wget2_data_onload_func onload, em_async_wget2_data_onerror_func onerror, em_async_wget2_data_onprogress_func onprogress);
+
+void emscripten_async_wget2_abort(int handle);
+
+// wget "sync"
+
+int emscripten_wget(const char* url, const char* file);
+
+void emscripten_wget_data(const char* url, void** pbuffer, int* pnum, int *perror);
+
+#ifdef __cplusplus
+}
+#endif