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

package/README.md

@@ -22,7 +22,7 @@ Some time later, possibly on a different computer…
 
 ```js
 const decoder = new TextDecoder();
-const worker = await xsnap({ 
+const worker = await xsnap({
   snapshotStream: fs.createFileStream('bootstrap.xss'),
 });
 const response = await worker.issueCommand('1');
@@ -57,7 +57,7 @@ The REPL supports special commands `load` and `save` for snapshots, and `quit`
 to quit.
 Load and save don't take arguments; just type the file name on the next prompt.
 
-```sh
+```console
 $ xsrepl
 xs> globalThis.x = 42;
 xs> x
@@ -67,7 +67,7 @@ file> temp.xss
 xs> quit
 ```
 
-```sh
+```console
 $ xsrepl
 xs> load
 file> temp.xss

package/api.js

@@ -4,10 +4,10 @@
  * The version identifier for our meter type.
  *
  * TODO Bump this whenever there's a change to metering semantics.
- * Also, update golden master test/test-xs-perf.js to reflect new meter
+ * Also, update golden master test/xs-perf.test.js to reflect new meter
  * version.
  */
-export const METER_TYPE = 'xs-meter-20';
+export const METER_TYPE = 'xs-meter-28';
 
 export const ExitCode = {
   E_UNKNOWN_ERROR: -1,
@@ -43,6 +43,7 @@ export class ErrorSignal extends Error {
     this.code = signal;
   }
 }
+harden(ErrorSignal);
 
 export class ErrorCode extends Error {
   /**
@@ -55,3 +56,4 @@ export class ErrorCode extends Error {
     this.code = code;
   }
 }
+harden(ErrorCode);

package/build.env

@@ -1,4 +1,4 @@
 MODDABLE_URL=https://github.com/agoric-labs/moddable.git
 MODDABLE_COMMIT_HASH=f6c5951fc055e4ca592b9166b9ae3cbb9cca6bf0
 XSNAP_NATIVE_URL=https://github.com/agoric-labs/xsnap-pub
-XSNAP_NATIVE_COMMIT_HASH=2d8ccb76b8508e490d9e03972bb4c64f402d5135
+XSNAP_NATIVE_COMMIT_HASH=eef9b67da5517ed18ff9e0073b842db20924eae3

package/moddable/modules/data/base64/base64.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2016-2017  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/>.
+ *
+ */
+
+/*
+	base64
+*/
+
+export default class {
+	static encode(buffer) @ "xs_base64_encode";
+	static decode(string) @ "xs_base64_decode";
+}

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

@@ -0,0 +1,11 @@
+{
+	"modules": {
+		"*": [
+			"./base64",
+			"./modBase64"
+		]
+	},
+	"preload": [
+		"base64"
+	]
+}

package/moddable/modules/data/base64/modBase64.c

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2016-2021  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/>.
+ *
+ * This file incorporates work covered by the following copyright and  
+ * permission notice:  
+ *
+ *       Copyright (C) 2010-2016 Marvell International Ltd.
+ *       Copyright (C) 2002-2010 Kinoma, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *       You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+/*
+	modeled on FskStrB64Decode and FskStrB64Encode from KPR.
+*/
+
+#include "xsmc.h"
+#include "xsHost.h"
+
+void xs_base64_encode(xsMachine *the)
+{
+	static const char b64[] ICACHE_XS6RO2_ATTR = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	xsType		srcType;
+	uint8_t		*src, *dst;
+	uint32_t	srcSize, dstSize;
+	uint8_t		a, b, c;
+
+	srcType = xsmcTypeOf(xsArg(0));
+	if (xsStringType == srcType) {
+		src = (uint8_t *)xsmcToString(xsArg(0));
+		srcSize = c_strlen((char *)src);
+	}
+	else
+		xsmcGetBufferReadable(xsArg(0), (void **)&src, &srcSize);
+	dstSize = (((srcSize + 2) / 3) * 4) + 1;
+
+	xsResult = xsStringBuffer(NULL, dstSize);
+	if (xsStringType == srcType)
+		src = (uint8_t *)xsmcToString(xsArg(0));		// refresh pointer
+	else
+		xsmcGetBufferReadable(xsArg(0), (void **)&src, &srcSize);
+	dst = (uint8_t *)xsmcToString(xsResult);
+
+	while (srcSize > 2) {
+		a = c_read8(src++);
+		b = c_read8(src++);
+		c = c_read8(src++);
+		*dst++ = c_read8(b64 + ((a & 0xfc) >> 2));
+		*dst++ = c_read8(b64 + (((a & 0x3) << 4) | ((b & 0xf0) >> 4)));
+		*dst++ = c_read8(b64 + (((b & 0xf) << 2) | ((c & 0xc0) >> 6)));
+		*dst++ = c_read8(b64 + (c & 0x3f));
+		srcSize -= 3;
+	}
+
+	if (srcSize == 2) {
+		a = c_read8(src++);
+		b = c_read8(src++);
+		*dst++ = c_read8(b64 + ((a & 0xfc) >> 2));
+		*dst++ = c_read8(b64 + (((a & 0x3) << 4) | ((b & 0xf0) >> 4)));
+		*dst++ = c_read8(b64 + ((b & 0xf) << 2));
+		*dst++ = '=';
+	}
+	else if (srcSize == 1) {
+		a = c_read8(src++);
+		*dst++ = c_read8(b64 + ((a & 0xfc) >> 2));
+		*dst++ = c_read8(b64 + ((a & 0x3) << 4));
+		*dst++ = '=';
+		*dst++ = '=';
+	}
+
+	*dst++ = 0;
+}
+
+void xs_base64_decode(xsMachine *the)
+{
+	uint8_t		*src;
+	uint32_t	srcSize, dstSize, srcIndex, dstIndex;
+	uint8_t		aFlag = 0;
+	uint8_t		aByte;
+	uint8_t		aBuffer[4];
+	uint8_t		*dst, *dstStart;
+
+	src = (uint8_t *)xsmcToString(xsArg(0));
+	srcSize = c_strlen((char *)src);
+
+	dstSize = (srcSize / 4) * 3;
+	if (c_read8(src + srcSize - 1) == '=')
+		dstSize--;
+	if (c_read8(src + srcSize - 2) == '=')
+		dstSize--;
+	srcIndex = 0;
+
+	xsmcSetArrayBufferResizable(xsResult, NULL, dstSize, dstSize);
+	dst = dstStart = xsmcToArrayBuffer(xsResult);
+
+	src = (uint8_t *)xsmcToString(xsArg(0));	// refresh pointer
+
+	dstIndex = 3;
+	while ((aByte = c_read8(src++))) {
+		if (('A' <= aByte) && (aByte <= 'Z'))
+			aByte = aByte - 'A';
+		else if (('a' <= aByte) && (aByte <= 'z'))
+			aByte = aByte - 'a' + 26;
+		else if (('0' <= aByte) && (aByte <= '9'))
+			aByte = aByte - '0' + 52;
+		else if (aByte == '+')
+			aByte = 62;
+		else if (aByte == '/')
+			aByte = 63;
+		else if (aByte == '=') {
+			if (srcIndex == 2) {
+				if (c_read8(src) == '=') {
+					aBuffer[srcIndex++] = 0;
+					dstIndex = 1;
+					aByte = 0;
+					aFlag = 1;
+				}
+				else
+					continue;
+			}
+			else if (srcIndex == 3) {
+				dstIndex = 2;
+				aByte = 0;
+				aFlag = 1;
+			}
+			else
+				continue;
+		}
+		else
+			continue;
+		aBuffer[srcIndex++] = aByte;
+		if (srcIndex == 4) {
+			*dst++ = (aBuffer[0] << 2) | ((aBuffer[1] & 0x30) >> 4);
+			if (dstIndex > 1)
+				*dst++ = ((aBuffer[1] & 0x0F) << 4) | ((aBuffer[2] & 0x3C) >> 2);
+			if (dstIndex > 2)
+				*dst++ = ((aBuffer[2] & 0x03) << 6) | (aBuffer[3] & 0x3F);
+			srcIndex = 0;
+		}
+		if (aFlag)
+			break;
+	}
+
+	xsmcSetArrayBufferLength(xsResult, dst - dstStart);
+}
+
+void modInstallBase64(xsMachine *the)
+{
+	#define kNamespace (0)
+	#define kScratch (1)
+
+	xsBeginHost(the);
+	xsmcVars(2);
+
+	xsVar(kNamespace) = xsNewObject();
+	xsmcSet(xsGlobal, xsID("Base64"), xsVar(kNamespace));
+	xsVar(kScratch) = xsNewHostFunction(xs_base64_encode, 1);
+	xsmcSet(xsVar(kNamespace), xsID("encode"), xsVar(kScratch));
+	xsVar(kScratch) = xsNewHostFunction(xs_base64_decode, 1);
+	xsmcSet(xsVar(kNamespace), xsID("decode"), xsVar(kScratch));
+
+	xsEndHost(the);
+}

package/moddable/modules/data/binaryMessage/BinaryMessage.js

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2016-2019  Moddable Tech, Inc.
+ *
+ *   This file is part of the Moddable SDK Tools.
+ *
+ *   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU 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 Tools 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 General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+const BinaryMessage = {
+	Float32: {
+		bytesLength:4,
+		getter:DataView.prototype.getFloat32,
+		setter:DataView.prototype.setFloat32,
+	},
+	Float64: {
+		bytesLength:8,
+		getter:DataView.prototype.getFloat64,
+		setter:DataView.prototype.setFloat64,
+	},
+	Int8: {
+		bytesLength:1,
+		getter:DataView.prototype.getInt8,
+		setter:DataView.prototype.setInt8,
+	},
+	Int16: {
+		bytesLength:2,
+		getter:DataView.prototype.getInt16,
+		setter:DataView.prototype.setInt16,
+	},
+	Int32: {
+		bytesLength:4,
+		getter:DataView.prototype.getInt32,
+		setter:DataView.prototype.setInt32,
+	},
+	Uint8: {
+		bytesLength:1,
+		getter:DataView.prototype.getUint8,
+		setter:DataView.prototype.setUint8,
+	},
+	Uint16: {
+		bytesLength:2,
+		getter:DataView.prototype.getUint16,
+		setter:DataView.prototype.setUint16,
+	},
+	Uint32: {
+		bytesLength:4,
+		getter:DataView.prototype.getUint32,
+		setter:DataView.prototype.setUint32,
+	},
+	generate(format) {
+		let message = {};
+		format.forEach(item => {
+			let value = 0;
+			let range = item.range;
+			if (range) 
+				value = range[value];
+			message[item.name] = value;
+		});
+		return message;
+	},
+	parse(format, buffer, endian) {
+		let view = new DataView(buffer);
+		let message = {};
+		let bytesLength = 0;
+		format.forEach(item => {
+			let value = item.type.getter.call(view, bytesLength, endian);
+			let range = item.range;
+			if (range) 
+				value = range[value];
+			message[item.name] = value;
+			bytesLength += item.type.bytesLength;
+		});
+		return message;
+	},
+	serialize(format, message, endian) {
+		let bytesLength = format.reduce((sum, item) => sum + item.type.bytesLength, 0);
+		let buffer = new ArrayBuffer(bytesLength);
+		let view = new DataView(buffer);
+		bytesLength = 0;
+		format.forEach(item => {
+			let value = message[item.name];
+			let range = item.range;
+			if (range) 
+				value = range.findIndex(string => string == value);
+			item.type.setter.call(view, bytesLength, value, endian);
+			bytesLength += item.type.bytesLength;
+		});
+		return buffer;
+	},
+}
+
+Object.freeze(BinaryMessage, true);
+
+export default BinaryMessage;

package/moddable/modules/data/crc/crc.c

@@ -0,0 +1,205 @@
+/*
+ * 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/>.
+ *
+ */
+
+#include "xsmc.h"
+#include "xsHost.h"
+
+// https://graphics.stanford.edu/~seander/bithacks.html
+uint8_t reflect8(uint8_t b) {
+	return ((b * 0x0802LU & 0x22110LU) | (b * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16;
+}
+
+static void make_crc8_table(uint8_t polynomial, uint8_t *crc8_table)
+{
+	int i, j, cur;
+
+	for (i=0; i<256; i++) {
+		for (cur=i, j=0; j<8; j++) {
+			if (cur & 0x80)
+				cur = ((cur << 1) ^ polynomial) % 256;
+			else
+				cur = (cur << 1) % 256;
+		}
+		crc8_table[i] = cur;
+	}
+}
+
+static uint8_t checksum8(uint8_t *bytes, uint32_t length, uint8_t *crc8_table, uint8_t crc, uint8_t refIn) {
+	uint32_t i;
+
+	for (i=0; i<length; i++) {
+		uint8_t b = bytes[i];
+		if (refIn)
+			b = reflect8(b);
+		crc = crc8_table[(crc ^ b) % 256];
+	}
+	return crc;
+}
+
+typedef struct {
+	uint8_t	reset;
+	uint8_t	initial;
+	uint8_t	reflectInput;
+	uint8_t	reflectOutput;
+	uint8_t	xorOutput;
+	uint8_t	table[256];
+} CRC8Record, *CRC8;
+
+void xs_crc8_destructor(void *data)
+{
+}
+
+void xs_crc8(xsMachine *the)
+{
+	int argc = xsmcArgc;
+	int polynomial = xsmcToInteger(xsArg(0));
+	int initial = (argc > 1) ? xsmcToInteger(xsArg(1)) : 0;
+	int reflectInput = (argc > 2) ? xsmcToInteger(xsArg(2)) : 0;
+	int reflectOutput = (argc > 3) ? xsmcToInteger(xsArg(3)) : 0;
+	int xorOutput = (argc > 4) ? xsmcToInteger(xsArg(4)) : 0;
+	CRC8 crc8 = xsmcSetHostChunk(xsThis, NULL, sizeof(CRC8Record));
+
+	crc8->reset = initial;
+	crc8->initial = initial;
+	crc8->reflectInput = reflectInput;
+	crc8->reflectOutput = reflectOutput;
+	crc8->xorOutput = xorOutput;
+
+	make_crc8_table(polynomial, crc8->table);
+}
+
+void xs_crc8_close(xsMachine *the)
+{
+	xsmcSetHostData(xsThis, NULL);
+}
+
+void xs_crc8_reset(xsMachine *the)
+{
+	CRC8 crc8 = xsmcGetHostChunk(xsThis);
+
+	crc8->initial = crc8->reset;
+	xsResult = xsThis;
+}
+
+void xs_crc8_checksum(xsMachine *the)
+{
+	CRC8 crc8 = xsmcGetHostChunk(xsThis);
+	uint8_t *data;
+	uint32_t length;
+
+	xsmcGetBufferReadable(xsArg(0), (void **)&data, &length);
+	crc8->initial = checksum8(data, length, crc8->table, crc8->initial, crc8->reflectInput);
+
+	uint8_t crc = crc8->initial;
+	if (crc8->reflectOutput)
+		crc = reflect8(crc);
+
+	xsmcSetInteger(xsResult, crc ^ crc8->xorOutput);
+}
+
+
+static void make_crc16_table(uint16_t polynomial, uint16_t *crc16_table) {
+	int i, j;
+	uint16_t crc;
+
+	for (i=0; i<256; i++) {
+		for (crc=i<<8, j=0; j<8; j++) {
+			if (crc & 0x8000) {
+				crc <<= 1;
+				crc ^= polynomial;
+			}
+			else
+				crc <<= 1;
+		}
+		crc16_table[i] = crc;
+	}
+}
+
+static uint16_t checksum16(uint8_t *bytes, uint32_t length, uint16_t *crc16_table, uint16_t crc, uint8_t refIn) {
+	uint32_t i;
+
+	for (i=0; i<length; i++) {
+		uint8_t b = bytes[i];
+		if (refIn)
+			b = reflect8(b);
+		crc = crc ^ (b << 8);
+		crc = ((crc << 8) ^ crc16_table[crc >> 8]);
+	}
+	return crc;
+}
+
+typedef struct {
+	uint16_t	reset;
+	uint16_t	initial;
+	uint16_t	reflectInput;
+	uint16_t	reflectOutput;
+	uint16_t	xorOutput;
+	uint16_t	table[256];
+} CRC16Record, *CRC16;
+
+void xs_crc16_destructor(void *data)
+{
+}
+
+void xs_crc16(xsMachine *the)
+{
+	int argc = xsmcArgc;
+	int polynomial = xsmcToInteger(xsArg(0));
+	int initial = (argc > 1) ? xsmcToInteger(xsArg(1)) : 0;
+	int reflectInput = (argc > 2) ? xsmcToInteger(xsArg(2)) : 0;
+	int reflectOutput = (argc > 3) ? xsmcToInteger(xsArg(3)) : 0;
+	int xorOutput = (argc > 4) ? xsmcToInteger(xsArg(4)) : 0;
+	CRC16 crc16 = xsmcSetHostChunk(xsThis, NULL, sizeof(CRC16Record));
+
+	crc16->reset = initial;
+	crc16->initial = initial;
+	crc16->reflectInput = reflectInput;
+	crc16->reflectOutput = reflectOutput;
+	crc16->xorOutput = xorOutput;
+
+	make_crc16_table(polynomial, crc16->table);
+}
+
+void xs_crc16_close(xsMachine *the)
+{
+	xsmcSetHostData(xsThis, NULL);
+}
+
+void xs_crc16_reset(xsMachine *the)
+{
+	CRC16 crc16 = xsmcGetHostChunk(xsThis);
+
+	crc16->initial = crc16->reset;
+}
+
+void xs_crc16_checksum(xsMachine *the)
+{
+	CRC16 crc16 = xsmcGetHostChunk(xsThis);
+	uint8_t *data;
+	uint32_t length;
+
+	xsmcGetBufferReadable(xsArg(0), (void **)&data, &length);
+	crc16->initial = checksum16(data, length, crc16->table, crc16->initial, crc16->reflectInput);
+
+	uint16_t crc = crc16->initial; 
+	if (crc16->reflectOutput)
+		crc = (reflect8(crc & 0xff) << 8) | reflect8(crc >> 8);
+	xsmcSetInteger(xsResult, crc ^ crc16->xorOutput);
+}

package/moddable/modules/data/crc/crc.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2021  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 CRC8  @ "xs_crc8_destructor" {
+	constructor(polynomial, initial, reflectInput, reflectOutput, xorOutput) @ "xs_crc8";
+	close() @ "xs_crc8_close";
+	checksum(buffer) @ "xs_crc8_checksum";
+	reset() @ "xs_crc8_reset";
+}
+
+class CRC16  @ "xs_crc16_destructor" {
+	constructor(polynomial, initial, reflectInput, reflectOutput, xorOutput) @ "xs_crc16";
+	close() @ "xs_crc16_close";
+	checksum(buffer) @ "xs_crc16_checksum";
+	reset() @ "xs_crc16_reset";
+}
+
+export { CRC8 as default, CRC8, CRC16 };

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

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

package/moddable/modules/data/hex/hex.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2016-2017  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/>.
+ *
+ */
+
+/*
+	hex
+*/
+
+export default class {
+	static toString(buffer) @ "xs_hex_toString";
+	static toBuffer(string) @ "xs_hex_toBuffer";
+}

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

@@ -0,0 +1,11 @@
+{
+	"modules": {
+		"*": [
+			"./hex",
+			"./modHex"
+		]
+	},
+	"preload": [
+		"hex"
+	]
+}