@4players/odin-common 1.0.6 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
-## 1.0.4
+## 1.1.0
 
-- Initial release
+- Added utility functions shared across browser frontend/backend apis
+
+## 1.0.6
+
+- Initial public release

package/lib/cjs/index.js

@@ -14,13 +14,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./schemas/serialization"), exports);
-__exportStar(require("./schemas/token"), exports);
-__exportStar(require("./schemas/room"), exports);
-__exportStar(require("./schemas/peer"), exports);
-__exportStar(require("./schemas/media"), exports);
-__exportStar(require("./schemas/message"), exports);
-__exportStar(require("./schemas/webrtc"), exports);
-__exportStar(require("./streams/commands"), exports);
-__exportStar(require("./streams/notifications"), exports);
-__exportStar(require("./plugins/api"), exports);
+__exportStar(require("./schema/serialization"), exports);
+__exportStar(require("./schema/token"), exports);
+__exportStar(require("./schema/room"), exports);
+__exportStar(require("./schema/peer"), exports);
+__exportStar(require("./schema/media"), exports);
+__exportStar(require("./schema/message"), exports);
+__exportStar(require("./schema/webrtc"), exports);
+__exportStar(require("./rpc/commands"), exports);
+__exportStar(require("./rpc/notifications"), exports);
+__exportStar(require("./utility/base64"), exports);
+__exportStar(require("./utility/bytearray"), exports);
+__exportStar(require("./utility/iterable"), exports);
+__exportStar(require("./utility/environment"), exports);
+__exportStar(require("./utility/json"), exports);
+__exportStar(require("./utility/result"), exports);
+__exportStar(require("./utility/rpc"), exports);
+__exportStar(require("./utility/selector"), exports);
+__exportStar(require("./utility/sleep"), exports);
+__exportStar(require("./utility/strand"), exports);
+__exportStar(require("./utility/url"), exports);
+__exportStar(require("./utility/validation"), exports);
+__exportStar(require("./utility/websocket"), exports);
+__exportStar(require("./plugin/api"), exports);

package/lib/cjs/{streams → rpc}/commands.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoomCommands = exports.MainCommands = void 0;
+exports.RoomCommandsRpc = exports.MainCommandsRpc = void 0;
 const z = require("zod");
-const serialization_1 = require("../schemas/serialization");
-const room_1 = require("../schemas/room");
-const peer_1 = require("../schemas/peer");
-const media_1 = require("../schemas/media");
-const webrtc_1 = require("../schemas/webrtc");
-exports.MainCommands = {
+const serialization_1 = require("../schema/serialization");
+const room_1 = require("../schema/room");
+const peer_1 = require("../schema/peer");
+const media_1 = require("../schema/media");
+const webrtc_1 = require("../schema/webrtc");
+exports.MainCommandsRpc = {
     JoinRoom: {
         request: z.object({
             token: z.string(),
@@ -34,7 +34,7 @@ exports.MainCommands = {
         response: z.null(),
     },
 };
-exports.RoomCommands = {
+exports.RoomCommandsRpc = {
     UpdatePeer: {
         request: z.object({ user_data: serialization_1.ByteArraySchema }),
         response: z.null(),

package/lib/cjs/{streams → rpc}/notifications.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoomNotifications = exports.MainNotifications = void 0;
-const room_1 = require("../schemas/room");
-const peer_1 = require("../schemas/peer");
-const message_1 = require("../schemas/message");
-const webrtc_1 = require("../schemas/webrtc");
-exports.MainNotifications = {
+exports.RoomNotificationsRpc = exports.MainNotificationsRpc = void 0;
+const room_1 = require("../schema/room");
+const peer_1 = require("../schema/peer");
+const message_1 = require("../schema/message");
+const webrtc_1 = require("../schema/webrtc");
+exports.MainNotificationsRpc = {
     WebRtcUpdate: webrtc_1.WebRtcUpdateSchema,
 };
-exports.RoomNotifications = {
+exports.RoomNotificationsRpc = {
     RoomStatusChanged: room_1.RoomStatusChangedSchema,
     RoomUpdated: room_1.RoomUpdatesSchema,
     PeerUpdated: peer_1.PeerUpdateSchema,

package/lib/cjs/utility/base64.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase64Url = exports.fromBase64 = void 0;
+const result_1 = require("./result");
+function fromBase64(base64) {
+    try {
+        const binString = atob(base64);
+        /* @ts-ignore: strings are array-like */
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        const decoder = new TextDecoder('utf8');
+        return (0, result_1.success)(decoder.decode(bytes));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.fromBase64 = fromBase64;
+function fromBase64Url(base64uri) {
+    try {
+        const binString = atob(base64uri.replace(/-/g, '+').replace(/_/g, '/'));
+        /* @ts-ignore: strings are array-like */
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        const decoder = new TextDecoder('utf8');
+        return (0, result_1.success)(decoder.decode(bytes));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.fromBase64Url = fromBase64Url;

package/lib/cjs/utility/bytearray.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBytes = exports.toBytes = void 0;
+const result_1 = require("./result");
+function toBytes(value) {
+    try {
+        (0, result_1.assert)(value !== undefined, 'undefined cannot be converted to byte array');
+        (0, result_1.assert)(value !== null, 'null cannot be converted to byte array');
+        const json = JSON.stringify(value);
+        const decoder = new TextEncoder();
+        return (0, result_1.success)(decoder.encode(json));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.toBytes = toBytes;
+function fromBytes(bytes) {
+    try {
+        (0, result_1.assert)(bytes.length > 0, 'empty byte array cannot be converted to value');
+        const json = new TextDecoder().decode(bytes);
+        const text = JSON.parse(json);
+        return (0, result_1.success)(text);
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.fromBytes = fromBytes;

package/lib/cjs/utility/environment.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlinkBrowser = exports.isAudioCapable = void 0;
+function isAudioCapable() {
+    return typeof AudioContext !== 'undefined' && typeof Worker !== 'undefined';
+}
+exports.isAudioCapable = isAudioCapable;
+function isBlinkBrowser() {
+    const pattern = /(apple)?webkit\/537\.36/i;
+    return (typeof window !== 'undefined' && pattern.test(window.navigator.userAgent));
+}
+exports.isBlinkBrowser = isBlinkBrowser;

package/lib/cjs/utility/iterable.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find = void 0;
+function find(entries, predicate) {
+    for (const entry of entries) {
+        if (predicate(entry))
+            return entry;
+    }
+    return undefined;
+}
+exports.find = find;

package/lib/cjs/utility/json.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRaw = void 0;
+function toRaw(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+exports.toRaw = toRaw;

package/lib/cjs/utility/result.js

@@ -0,0 +1,29 @@
+"use strict";
+/* eslint-disable no-redeclare */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrap = exports.failure = exports.success = exports.fail = exports.assert = void 0;
+function assert(condition, message) {
+    if (!condition) {
+        fail(message);
+    }
+}
+exports.assert = assert;
+function fail(message) {
+    throw new Error(message);
+}
+exports.fail = fail;
+function success(value) {
+    return { type: 'Success', value };
+}
+exports.success = success;
+function failure(reason) {
+    return { type: 'Failure', reason };
+}
+exports.failure = failure;
+function unwrap(result) {
+    if (result.type === 'Failure') {
+        fail(result.reason);
+    }
+    return result.value;
+}
+exports.unwrap = unwrap;

package/lib/cjs/utility/rpc.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRpcMessage = exports.parseRpc = exports.msgpackDecode = exports.msgpackEncode = void 0;
+const msgpack = require("@msgpack/msgpack");
+const serialization_1 = require("../schema/serialization");
+const result_1 = require("./result");
+function msgpackEncode(value) {
+    return msgpack.encode(value);
+}
+exports.msgpackEncode = msgpackEncode;
+function msgpackDecode(buffer) {
+    return msgpack.decode(buffer);
+}
+exports.msgpackDecode = msgpackDecode;
+function parseRpc(buffer) {
+    try {
+        return (0, result_1.success)(serialization_1.MessagePackRpcSchema.parse(msgpackDecode(buffer)));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.parseRpc = parseRpc;
+function parseRpcMessage(events, rpc) {
+    if (!isKnownRpcMessage(events, rpc.name))
+        return undefined;
+    const parsed = events[rpc.name].safeParse(rpc.properties);
+    if (!parsed.success) {
+        return undefined;
+    }
+    return {
+        name: rpc.name,
+        properties: parsed.data,
+    };
+}
+exports.parseRpcMessage = parseRpcMessage;
+function isKnownRpcMessage(events, name) {
+    return name in events;
+}

package/lib/cjs/utility/selector.js

@@ -0,0 +1,31 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Selector = void 0;
+class Selector {
+    constructor(generators) {
+        this.generators = generators;
+        this.futures = generators.map(Selector.addIndex);
+    }
+    next() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [result, index] = yield Promise.race(this.futures);
+            this.futures[index] = Selector.addIndex(this.generators[index], index);
+            return result;
+        });
+    }
+    static addIndex(generator, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [yield generator(), index];
+        });
+    }
+}
+exports.Selector = Selector;

package/lib/cjs/utility/sleep.js

@@ -0,0 +1,29 @@
+"use strict";
+/* eslint-disable no-redeclare */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextTick = exports.abortableSleep = exports.sleep = void 0;
+function sleep(ms, value) {
+    if (ms <= 0) {
+        return Promise.resolve(value);
+    }
+    return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+}
+exports.sleep = sleep;
+function abortableSleep(ms, signal) {
+    if (signal.aborted) {
+        return Promise.resolve('aborted');
+    }
+    return new Promise((resolve) => {
+        const onAbort = () => resolve('aborted');
+        signal.addEventListener('abort', onAbort, { once: true });
+        setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(undefined);
+        }, ms);
+    });
+}
+exports.abortableSleep = abortableSleep;
+function nextTick() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+exports.nextTick = nextTick;

package/lib/cjs/utility/strand.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Strand = void 0;
+class Strand {
+    constructor() {
+        this.tasks = [];
+        this.running = false;
+    }
+    enqueue(task) {
+        return new Promise((resolve, reject) => {
+            const wrapped = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield task();
+                    resolve(result);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            this.tasks.push(wrapped);
+            if (!this.running) {
+                this.execute();
+            }
+        });
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.running = true;
+            while (true) {
+                const task = this.tasks.shift();
+                if (task === undefined)
+                    break;
+                yield task();
+            }
+            this.running = false;
+        });
+    }
+}
+exports.Strand = Strand;

package/lib/cjs/utility/url.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendUrl = exports.normalizeUrl = void 0;
+const result_1 = require("./result");
+function normalizeUrl(url) {
+    let normalized = url.trim();
+    if (url.indexOf('://') === -1)
+        normalized = `https://${normalized}`;
+    try {
+        return (0, result_1.success)(new URL(normalized));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.normalizeUrl = normalizeUrl;
+function extendUrl(base, path) {
+    let pathname = base.pathname;
+    if (pathname.endsWith('/') === false)
+        pathname += '/';
+    try {
+        return (0, result_1.success)(new URL(pathname + path, base));
+    }
+    catch (error) {
+        return (0, result_1.failure)(String(error));
+    }
+}
+exports.extendUrl = extendUrl;

package/lib/cjs/utility/validation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUndefined = exports.isString = exports.isObject = exports.isNumber = exports.isNull = exports.isFunction = exports.isProperty = void 0;
+function isProperty(object, name) {
+    return name in object;
+}
+exports.isProperty = isProperty;
+function isFunction(value) {
+    return typeof value === 'function';
+}
+exports.isFunction = isFunction;
+function isNull(value) {
+    return typeof value === 'object' && value === null;
+}
+exports.isNull = isNull;
+function isNumber(value) {
+    return typeof value === 'number';
+}
+exports.isNumber = isNumber;
+function isObject(value) {
+    return typeof value === 'object';
+}
+exports.isObject = isObject;
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+function isUndefined(value) {
+    return typeof value === 'undefined';
+}
+exports.isUndefined = isUndefined;

package/lib/cjs/utility/websocket.js

@@ -0,0 +1,85 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webSocketConnectOnce = exports.webSocketConnect = void 0;
+const ws_1 = require("ws");
+const result_1 = require("./result");
+const sleep_1 = require("./sleep");
+function webSocketConnect(url, connectIntervals, clientOptions, onFailure) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const start = performance.now();
+        let connection = (0, result_1.failure)('no connection was attempted');
+        let cancelled = false;
+        const cancel = () => {
+            cancelled = true;
+        };
+        const connect = () => __awaiter(this, void 0, void 0, function* () {
+            for (let failures = 0; failures < connectIntervals.length && !cancelled; failures++) {
+                const nextReconnectAt = start + whenToConnect(failures, connectIntervals);
+                yield (0, sleep_1.sleep)(nextReconnectAt - performance.now(), 'interval');
+                if (cancelled) {
+                    return (0, result_1.failure)('cancelled');
+                }
+                connection = yield webSocketConnectOnce(url, clientOptions);
+                if (connection.type === 'Success') {
+                    return connection;
+                }
+                else if (onFailure !== undefined) {
+                    onFailure(failures + 1, cancel);
+                }
+            }
+            return connection;
+        });
+        return { connect, cancel };
+    });
+}
+exports.webSocketConnect = webSocketConnect;
+function webSocketConnectOnce(url, clientOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let webSocket;
+        try {
+            webSocket = new ws_1.WebSocket(url, clientOptions);
+        }
+        catch (reason) {
+            return (0, result_1.failure)(`unable to create websocket; ${reason}`);
+        }
+        return new Promise((resolve) => {
+            const onOpen = () => {
+                cleanup();
+                resolve((0, result_1.success)(webSocket));
+            };
+            const onError = (event) => {
+                cleanup();
+                resolve((0, result_1.failure)(event.message));
+            };
+            const onClose = (event) => {
+                cleanup();
+                resolve((0, result_1.failure)(event.reason));
+            };
+            const cleanup = () => {
+                webSocket.removeEventListener('open', onOpen);
+                webSocket.removeEventListener('error', onError);
+                webSocket.removeEventListener('close', onClose);
+            };
+            webSocket.addEventListener('open', onOpen);
+            webSocket.addEventListener('error', onError);
+            webSocket.addEventListener('close', onClose);
+        });
+    });
+}
+exports.webSocketConnectOnce = webSocketConnectOnce;
+function whenToConnect(failures, connectIntervals) {
+    const past_connects = connectIntervals
+        .slice(0, failures)
+        .reduce((a, b) => a + b, 0);
+    const interval = connectIntervals[failures] * Math.random();
+    return past_connects + interval;
+}

package/lib/esm/index.js

@@ -1,10 +1,23 @@
-export * from './schemas/serialization';
-export * from './schemas/token';
-export * from './schemas/room';
-export * from './schemas/peer';
-export * from './schemas/media';
-export * from './schemas/message';
-export * from './schemas/webrtc';
-export * from './streams/commands';
-export * from './streams/notifications';
-export * from './plugins/api';
+export * from './schema/serialization';
+export * from './schema/token';
+export * from './schema/room';
+export * from './schema/peer';
+export * from './schema/media';
+export * from './schema/message';
+export * from './schema/webrtc';
+export * from './rpc/commands';
+export * from './rpc/notifications';
+export * from './utility/base64';
+export * from './utility/bytearray';
+export * from './utility/iterable';
+export * from './utility/environment';
+export * from './utility/json';
+export * from './utility/result';
+export * from './utility/rpc';
+export * from './utility/selector';
+export * from './utility/sleep';
+export * from './utility/strand';
+export * from './utility/url';
+export * from './utility/validation';
+export * from './utility/websocket';
+export * from './plugin/api';

package/lib/esm/{streams → rpc}/commands.js

@@ -1,10 +1,10 @@
 import * as z from 'zod';
-import { ByteArraySchema } from '../schemas/serialization';
-import { RoomIdSchema } from '../schemas/room';
-import { PeerIdSchema, PeerPositionSchema } from '../schemas/peer';
-import { MediaIdSchema, MediaPropertiesSchema } from '../schemas/media';
-import { WebRtcUpdateSchema } from '../schemas/webrtc';
-export const MainCommands = {
+import { ByteArraySchema } from '../schema/serialization';
+import { RoomIdSchema } from '../schema/room';
+import { PeerIdSchema, PeerPositionSchema } from '../schema/peer';
+import { MediaIdSchema, MediaPropertiesSchema } from '../schema/media';
+import { WebRtcUpdateSchema } from '../schema/webrtc';
+export const MainCommandsRpc = {
     JoinRoom: {
         request: z.object({
             token: z.string(),
@@ -31,7 +31,7 @@ export const MainCommands = {
         response: z.null(),
     },
 };
-export const RoomCommands = {
+export const RoomCommandsRpc = {
     UpdatePeer: {
         request: z.object({ user_data: ByteArraySchema }),
         response: z.null(),

package/lib/esm/{streams → rpc}/notifications.js

@@ -1,11 +1,11 @@
-import { RoomStatusChangedSchema, RoomUpdatesSchema } from '../schemas/room';
-import { PeerUpdateSchema } from '../schemas/peer';
-import { MessageReceivedSchema } from '../schemas/message';
-import { WebRtcUpdateSchema } from '../schemas/webrtc';
-export const MainNotifications = {
+import { RoomStatusChangedSchema, RoomUpdatesSchema } from '../schema/room';
+import { PeerUpdateSchema } from '../schema/peer';
+import { MessageReceivedSchema } from '../schema/message';
+import { WebRtcUpdateSchema } from '../schema/webrtc';
+export const MainNotificationsRpc = {
     WebRtcUpdate: WebRtcUpdateSchema,
 };
-export const RoomNotifications = {
+export const RoomNotificationsRpc = {
     RoomStatusChanged: RoomStatusChangedSchema,
     RoomUpdated: RoomUpdatesSchema,
     PeerUpdated: PeerUpdateSchema,

package/lib/esm/utility/base64.js

@@ -0,0 +1,25 @@
+import { failure, success } from './result';
+export function fromBase64(base64) {
+    try {
+        const binString = atob(base64);
+        /* @ts-ignore: strings are array-like */
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        const decoder = new TextDecoder('utf8');
+        return success(decoder.decode(bytes));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}
+export function fromBase64Url(base64uri) {
+    try {
+        const binString = atob(base64uri.replace(/-/g, '+').replace(/_/g, '/'));
+        /* @ts-ignore: strings are array-like */
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        const decoder = new TextDecoder('utf8');
+        return success(decoder.decode(bytes));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}

package/lib/esm/utility/bytearray.js

@@ -0,0 +1,24 @@
+import { assert, failure, success } from './result';
+export function toBytes(value) {
+    try {
+        assert(value !== undefined, 'undefined cannot be converted to byte array');
+        assert(value !== null, 'null cannot be converted to byte array');
+        const json = JSON.stringify(value);
+        const decoder = new TextEncoder();
+        return success(decoder.encode(json));
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}
+export function fromBytes(bytes) {
+    try {
+        assert(bytes.length > 0, 'empty byte array cannot be converted to value');
+        const json = new TextDecoder().decode(bytes);
+        const text = JSON.parse(json);
+        return success(text);
+    }
+    catch (error) {
+        return failure(String(error));
+    }
+}