@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.1

package/moddable/modules/data/url/url.js

@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2021-2022  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+// https://url.spec.whatwg.org/#url-class
+
+function parseURL(url) @ "fx_parseURL"
+function serializeURL(url) @ "fx_serializeURL"
+function parseQuery(query) @ "fx_parseQuery"
+function serializeQuery(pairs) @ "fx_serializeQuery"
+
+const SCHEME = 1;
+const USERNAME = 2;
+const PASSWORD = 3;
+const HOST = 4;
+const HOSTNAME = 5;
+const PORT = 6;
+const PATH = 7;
+const QUERY = 8;
+const FRAGMENT = 9;
+const ORIGIN = 10;
+
+class URL {
+	#parts;
+	#searchParams;
+	constructor(href, base) {
+		if (base !== undefined)
+			this.#parts = parseURL(href, parseURL(base));
+		else
+			this.#parts = parseURL(href);
+		this.#searchParams = new URLSearchParams(this.#parts.query, this.#parts);
+	}
+	get hash() {
+		return serializeURL(this.#parts, FRAGMENT);
+	}
+	set hash(it) {
+		parseURL(it, this.#parts, FRAGMENT);
+	}
+	get host() {
+		return serializeURL(this.#parts, HOST);
+	}
+	set host(it) {
+		parseURL(it, this.#parts, HOST);
+	}
+	get hostname() {
+		return serializeURL(this.#parts, HOSTNAME);
+	}
+	set hostname(it) {
+		parseURL(it, this.#parts, HOSTNAME);
+	}
+	get href() {
+		return serializeURL(this.#parts);
+	}
+	set href(it) {
+		this.#parts = parseURL(it);
+		this.#searchParams.updatePairs();
+	}
+	get origin() {
+		return serializeURL(this.#parts, ORIGIN);
+	}
+	get password() {
+		return serializeURL(this.#parts, PASSWORD);
+	}
+	set password(it) {
+		parseURL(it, this.#parts, PASSWORD);
+	}
+	get pathname() {
+		return serializeURL(this.#parts, PATH);
+	}
+	set pathname(it) {
+		parseURL(it, this.#parts, PATH);
+	}
+	get port() {
+		return serializeURL(this.#parts, PORT);
+	}
+	set port(it) {
+		parseURL(it, this.#parts, PORT);
+	}
+	get protocol() {
+		return serializeURL(this.#parts, SCHEME);
+	}
+	set protocol(it) {
+		parseURL(it, this.#parts, SCHEME);
+	}
+	get search() {
+		return serializeURL(this.#parts, QUERY);
+	}
+	set search(it) {
+		parseURL(it, this.#parts, QUERY);
+		this.#searchParams.updatePairs();
+	}
+	get searchParams() {
+		return this.#searchParams;
+	}
+	get username() {
+		return serializeURL(this.#parts, USERNAME);
+	}
+	set username(it) {
+		parseURL(it, this.#parts, USERNAME);
+	}
+	toJSON() {
+		return serializeURL(this.#parts);
+	}
+	toString() {
+		return serializeURL(this.#parts);
+	}
+}
+
+// https://url.spec.whatwg.org/#interface-urlsearchparams
+
+class URLSearchParams {
+	#pairs = null;
+	#parts = null;
+	constructor(it = "", parts = null) {
+		if (typeof(it) == "object") {
+			this.#pairs = [];
+			if (Array.isArray(it)) {
+				for (let item of it) {
+					if (item.length != 2)
+						throw new TypeError("invalid parameter");
+					this.append(item[0], item[1]);
+				}
+			}
+			else {
+				for (let name in it)
+					this.append(name, it[name]);
+			}
+		}
+		else {
+			this.#pairs = parseQuery(it);
+			this.#parts = parts;
+		}
+	}
+	get length() {
+		return this.#pairs.length;
+	}
+	append(name, value) {
+		this.#pairs.push({ name, value });
+		this.updateParts();
+	}
+	delete(name) {
+		this.#pairs = this.#pairs.filter(pair => pair.name != name);
+		this.updateParts();
+	}
+	get(name) {
+		const pair = this.#pairs.find(pair => pair.name == name);
+		return pair ? pair.value : null;
+	}
+	getAll(name) {
+		return this.#pairs.filter(pair => pair.name == name).map(pair => pair.value);
+	}
+	has(name) {
+		const pair = this.#pairs.find(pair => pair.name == name);
+		return pair ? true : false;
+	}
+	set(name, value) {
+		const pair = this.#pairs.find(pair => pair.name == name);
+		if (pair)
+			pair.value = value;
+		else
+			this.#pairs.push({ name, value });
+		this.updateParts();
+	}
+	toString() {
+		return serializeQuery(this.#pairs);
+	}
+	updatePairs() {
+		if (this.#parts)
+			this.#pairs = parseQuery(this.#parts.query);
+	}
+	updateParts() {
+		if (this.#parts)
+			this.#parts.query = serializeQuery(this.#pairs);
+	}
+	[Symbol.iterator]() {
+		const pairs = this.#pairs
+		let index = 0;
+		const iteraror = {
+			next() {
+				if (index < pairs.length) {
+					const pair = pairs[index];
+					index++;
+					return { value: [pair.name, pair.value], done: false };
+				}
+				return { value: undefined, done: true };
+			}
+		}
+		return iteraror;
+	}
+}
+
+export { URL, URLSearchParams }
+export default URL;
+

package/moddable/modules/data/wavreader/manifest.json

@@ -0,0 +1,8 @@
+{
+	"modules": {
+		"data/wavreader": "./wavreader"
+	},
+	"preload": [
+		"data/wavreader"
+	]
+}

package/moddable/modules/data/wavreader/wavreader.js

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2016-2022  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ * 
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ * 
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ * 
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+class WavReader {
+	constructor(buffer) {
+		this.wav = new DataView(buffer);
+		this.position = 0;
+		this.waveSize = buffer.byteLength;
+
+		if ("RIFF" !== this.readFourCC())
+			throw new Error("expected RIFF");
+		this.seekBy(4);		// file size
+		if ("WAVE" !== this.readFourCC())
+			throw new Error("expected WAVE");
+
+		if ("JUNK" === this.readFourCC())
+			this.seekBy(this.readUint32())
+		else
+			this.seekBy(-4);
+
+		if ("fmt " !== this.readFourCC())
+			throw new Error("expected fmt");
+		let next = this.readUint32();
+		next += this.position;
+
+		this.audioFormat = this.readUint16();
+		this.numChannels = this.readUint16();
+		this.sampleRate = this.readUint32();
+		this.seekBy(4 + 2);
+		this.bitsPerSample = this.readUint16();
+
+		this.seekTo(next);
+
+		while ("data" !== this.readFourCC())
+			this.seekBy(this.readUint32());
+
+		this.samples = Math.floor(this.readUint32() / ((this.numChannels * this.bitsPerSample) >> 3));
+	}
+
+	getSamples(buffer, count) {		// always returns signed 16-bit sample values
+		this.samples -= count;
+		if (this.samples < 0)
+			throw Error("out of samples");
+
+		count *= this.numChannels;
+		let i = 0;
+		if (16 === this.bitsPerSample) {
+			while (count--)
+				buffer[i++] = this.readInt16();
+		}
+		else
+		if (8 == this.bitsPerSample) {
+			while (count--) {
+				let value = this.readInt8();
+				buffer[i++] = value << 8;		// write Uint8 representation of value into low bits
+			}
+		}
+	}
+
+	readFourCC() {
+		let result = String.fromCharCode(this.wav.getUint8(this.position), this.wav.getUint8(this.position + 1),
+										 this.wav.getUint8(this.position + 2), this.wav.getUint8(this.position + 3));
+		this.position += 4;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	readUint32() {
+		let result = this.wav.getUint32(this.position, true);
+		this.position += 4;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	readUint16() {
+		let result = this.wav.getUint16(this.position, true);
+		this.position += 2;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	readInt16() {
+		let result = this.wav.getInt16(this.position, true);
+		this.position += 2;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	readUint8() {
+		let result = this.wav.getUint8(this.position, true);
+		this.position += 1;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	readInt8() {
+		let result = this.wav.getInt8(this.position, true);
+		this.position += 1;
+		if (this.position > this.waveSize)
+			throw new Error("eof");
+		return result;
+	}
+	seekBy(count) {
+		this.position += count;
+	}
+	seekTo(position) {
+		this.position = position;
+	}
+}
+
+export default WavReader;

package/moddable/modules/data/zlib/deflate.c

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2019-2022  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+ 
+#include "xsmc.h"
+#include "xsHost.h"
+#include "mc.xs.h"			// for xsID_ values
+
+#define MINIZ_HEADER_FILE_ONLY
+#include "miniz.c"
+
+static void *zAlloc(void *opaque, size_t items, size_t size)
+{
+	return c_malloc(items * size);
+}
+
+static void zFree(void *opaque, void *address)
+{
+	if (address)
+		c_free(address);
+}
+
+void xs_deflate_destructor(void *data)
+{
+	if (data) {
+		deflateEnd((z_stream *)data);
+		c_free(data);
+	}
+}
+
+void xs_deflate(xsMachine *the)
+{
+	int windowBits = Z_DEFAULT_WINDOW_BITS, level = MZ_DEFAULT_COMPRESSION, strategy = Z_DEFAULT_STRATEGY;
+	z_stream *zlib;
+
+	xsmcVars(1);
+	if (xsmcHas(xsArg(0), xsID_windowBits)) {
+		xsmcGet(xsVar(0), xsArg(0), xsID_windowBits);
+		windowBits = xsmcToInteger(xsVar(0));
+		if ((15 != windowBits) && (-15 != windowBits))
+			xsRangeError("invalid windowBits");
+	}
+
+	if (xsmcHas(xsArg(0), xsID_level)) {
+		xsmcGet(xsVar(0), xsArg(0), xsID_level);
+		level = xsmcToInteger(xsVar(0));
+		if ((level < -1) || (level > 10))
+			xsRangeError("invalid level");
+	}
+
+	if (xsmcHas(xsArg(0), xsID_strategy)) {
+		xsmcGet(xsVar(0), xsArg(0), xsID_strategy);
+		strategy = xsmcToInteger(xsVar(0));
+		if ((strategy < 0) || (strategy > 4))
+			xsRangeError("invalid level");
+	}
+
+	zlib = c_malloc(sizeof(z_stream));
+	if (!zlib)
+		xsUnknownError("no memory");
+
+	zlib->zalloc = zAlloc;
+	zlib->zfree = zFree;
+	
+	if (Z_OK != deflateInit2(zlib, level, MZ_DEFLATED, windowBits, 1, strategy)) {
+		c_free(zlib);
+		xsUnknownError("deflateInit2 failed");
+	}
+
+	xsmcSetHostData(xsThis, zlib);
+}
+
+void xs_deflate_close(xsMachine *the)
+{
+	z_stream *zlib = xsmcGetHostData(xsThis);
+	if (zlib && xsmcGetHostDataValidate(xsThis, xs_deflate_destructor)) {
+		xs_deflate_destructor(zlib);
+		xsmcSetHostData(xsThis, NULL);
+		xsmcSetHostDestructor(xsThis, NULL);
+	}
+}
+
+void xs_deflate_push(xsMachine *the)
+{
+	z_stream *zlib = xsmcGetHostDataValidate(xsThis, xs_deflate_destructor);
+	uint8_t output[1024];
+	int inputOffset = 0;
+	xsUnsignedValue inputRemaining;
+	void *input;
+	int inputEnd = (xsmcArgc > 1) ? xsmcTest(xsArg(1)) : 0;
+	int status = Z_OK;
+	uint8_t isString = xsStringType == xsmcTypeOf(xsArg(0));
+
+	if (isString)
+		inputRemaining = c_strlen(xsmcToString(xsArg(0)));
+	else
+		xsmcGetBufferReadable(xsArg(0), &input, &inputRemaining);
+
+	while ((0 != inputRemaining) || (Z_OK == status)) {
+		zlib->next_out	= output;
+		zlib->avail_out	= sizeof(output);
+		zlib->total_out	= 0;
+
+		if (isString)
+			zlib->next_in = inputOffset + (uint8_t *)xsmcToString(xsArg(0));
+		else {
+			xsUnsignedValue ignore;
+			xsmcGetBufferReadable(xsArg(0), &input, &ignore);
+			zlib->next_in = inputOffset + (uint8_t *)input;
+		}
+		zlib->avail_in = inputRemaining;
+		zlib->total_in = 0;
+
+		status = deflate(zlib, (inputEnd ? Z_FINISH : Z_NO_FLUSH));
+		if (Z_BUF_ERROR == status) {
+			status = Z_OK;
+			goto bail;
+		}
+		if ((Z_OK != status) && (Z_STREAM_END != status)) {
+			xs_deflate_close(the);
+
+			xsmcSetInteger(xsResult, status);
+			xsCall1(xsThis, xsID_onEnd, xsResult);
+			goto bail;
+		}
+
+		if (zlib->total_out) {
+			xsmcSetArrayBuffer(xsResult, output, zlib->total_out);
+			xsCall1(xsThis, xsID_onData, xsResult);
+		}
+
+		inputOffset += zlib->total_in;
+		inputRemaining -= zlib->total_in;
+	}
+
+	if (inputEnd || (status == Z_STREAM_END)) {
+		xs_deflate_close(the);
+
+		xsmcSetInteger(xsResult, (Z_STREAM_END == status) ? Z_OK : status);
+		xsCall1(xsThis, xsID_onEnd, xsResult);
+	}
+
+bail:
+	xsmcSetBoolean(xsResult, (Z_OK == status) || (Z_STREAM_END == status));
+}

package/moddable/modules/data/zlib/deflate.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2019-2022  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+ 
+
+class Deflate @ "xs_deflate_destructor" {
+	err = 0;
+	chunks = [];
+
+	constructor(options = {}) {
+		build.call(this, options);
+		this.onData = onData;
+		this.onEnd = onEnd;
+	}
+	close() @ "xs_deflate_close";
+
+	push(buffer, end) @ "xs_deflate_push";
+}
+
+function build(options) @ "xs_deflate";
+
+function onData(chunk) {
+	this.chunks.push(chunk);
+}
+
+function onEnd(err) {
+	this.err = err;
+	if (err) {
+		delete this.chunks;
+		return;
+	}
+
+	// join chunks
+	let total = 0;
+	for (let i = 0, chunks = this.chunks, length = chunks.length; i < length; i++)
+		total += chunks[i].byteLength;
+
+	this.result = new Uint8Array(total);
+	let offset = 0;
+	for (let i = 0, chunks = this.chunks, length = chunks.length; i < length; i++) {
+		this.result.set(new Uint8Array(this.chunks[i]), offset);
+		offset += chunks[i].byteLength;
+	}
+	delete this.chunks;
+}
+
+export default Deflate;

package/moddable/modules/data/zlib/inflate.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2019-2022  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Runtime.
+ *
+ *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public License
+ *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+ 
+
+#include "xsmc.h"
+#include "xsHost.h"
+#include "mc.xs.h"			// for xsID_ values
+
+#define MINIZ_HEADER_FILE_ONLY
+#include "miniz.c"
+
+static void *zAlloc(void *opaque, size_t items, size_t size)
+{
+	return c_malloc(items * size);
+}
+
+static void zFree(void *opaque, void *address)
+{
+	if (address)
+		c_free(address);
+}
+
+void xs_inflate_destructor(void *data)
+{
+	if (data) {
+		inflateEnd((z_stream *)data);
+		c_free(data);
+	}
+}
+
+void xs_inflate(xsMachine *the)
+{
+	int windowBits = 15;
+	z_stream *zlib;
+
+	xsmcVars(1);
+	if (xsmcHas(xsArg(0), xsID_windowBits)) {
+		xsmcGet(xsVar(0), xsArg(0), xsID_windowBits);
+		windowBits = xsmcToInteger(xsVar(0));
+		if ((15 != windowBits) && (-15 != windowBits))
+			xsRangeError("invalid windowBits");
+	}
+
+	zlib = c_malloc(sizeof(z_stream));
+	if (!zlib)
+		xsUnknownError("no memory");
+
+	zlib->zalloc = zAlloc;
+	zlib->zfree = zFree;
+	
+	if (Z_OK != inflateInit2(zlib, windowBits)) {
+		c_free(zlib);
+		xsUnknownError("inflateInit2 failed");
+	}
+
+	xsmcSetHostData(xsThis, zlib);
+}
+
+void xs_inflate_close(xsMachine *the)
+{
+	z_stream *zlib = xsmcGetHostData(xsThis);
+	if (zlib && xsmcGetHostDataValidate(xsThis, xs_inflate_destructor)) {
+		xs_inflate_destructor(zlib);
+		xsmcSetHostData(xsThis, NULL);
+		xsmcSetHostDestructor(xsThis, NULL);
+	}
+}
+
+void xs_inflate_push(xsMachine *the)
+{
+	z_stream *zlib = xsmcGetHostDataValidate(xsThis, xs_inflate_destructor);
+	uint8_t output[1024];
+	int inputOffset = 0;
+	uint8_t *input;
+	xsUnsignedValue inputRemaining, ignore;
+//@@int inputEnd = xsmcTest(xsArg(1));
+	int inputEnd = 0;
+	int status = Z_OK;
+
+	xsmcGetBufferReadable(xsArg(0), (void **)&input, &inputRemaining);
+	while (Z_OK == status) {
+		zlib->next_out	= output;
+		zlib->avail_out	= sizeof(output);
+		zlib->total_out	= 0;
+
+		xsmcGetBufferReadable(xsArg(0), (void **)&input, &ignore);
+		zlib->next_in = inputOffset + input;
+		zlib->avail_in = inputRemaining;
+		zlib->total_in = 0;
+
+		status = inflate(zlib, (inputEnd ? Z_FINISH : MZ_NO_FLUSH));
+		if ((Z_OK != status) && (Z_STREAM_END != status)) {
+			if (Z_DATA_ERROR == status) {
+				xs_inflate_close(the);
+				xsUnknownError("bad zlib data");
+			}
+		}
+
+		if (zlib->total_out) {
+			xsmcSetArrayBuffer(xsResult, output, zlib->total_out);
+			xsCall1(xsThis, xsID_onData, xsResult);
+		}
+
+		inputOffset += zlib->total_in;
+		inputRemaining -= zlib->total_in;
+
+		if (Z_STREAM_END == status)
+			break;
+
+		if (Z_BUF_ERROR == status) {
+			if (!inputRemaining && !zlib->total_out)
+				break;
+			status = Z_OK;
+		}
+	}
+
+	if (inputEnd || (status == Z_STREAM_END)) {
+		if (Z_STREAM_END != status)
+			inflateEnd(zlib);
+
+		xs_inflate_close(the);
+
+		xsmcSetInteger(xsResult, (Z_STREAM_END == status) ? Z_OK : status);
+		xsCall1(xsThis, xsID_onEnd, xsResult);
+	}
+
+	xsmcSetInteger(xsResult, inputRemaining);
+}