@leofcoin/chain 1.7.65 → 1.7.67

package/exports/browser/browser-DQJ6xf_F-D0onvbt2.js

@@ -0,0 +1,188 @@
+import { g as getDefaultExportFromCjs } from './node-browser-DewO13hB.js';
+import './index-CM4QYC3g.js';
+
+var global;
+var hasRequiredGlobal;
+
+function requireGlobal () {
+	if (hasRequiredGlobal) return global;
+	hasRequiredGlobal = 1;
+	var naiveFallback = function () {
+		if (typeof self === "object" && self) return self;
+		if (typeof window === "object" && window) return window;
+		throw new Error("Unable to resolve global `this`");
+	};
+
+	global = (function () {
+		if (this) return this;
+
+		// Unexpected strict mode (may happen if e.g. bundled into ESM module)
+
+		// Fallback to standard globalThis if available
+		if (typeof globalThis === "object" && globalThis) return globalThis;
+
+		// Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
+		// In all ES5+ engines global object inherits from Object.prototype
+		// (if you approached one that doesn't please report)
+		try {
+			Object.defineProperty(Object.prototype, "__global__", {
+				get: function () { return this; },
+				configurable: true
+			});
+		} catch (error) {
+			// Unfortunate case of updates to Object.prototype being restricted
+			// via preventExtensions, seal or freeze
+			return naiveFallback();
+		}
+		try {
+			// Safari case (window.__global__ works, but __global__ does not)
+			if (!__global__) return naiveFallback();
+			return __global__;
+		} finally {
+			delete Object.prototype.__global__;
+		}
+	})();
+	return global;
+}
+
+var name = "websocket";
+var description = "Websocket Client & Server Library implementing the WebSocket protocol as specified in RFC 6455.";
+var keywords = [
+	"websocket",
+	"websockets",
+	"socket",
+	"networking",
+	"comet",
+	"push",
+	"RFC-6455",
+	"realtime",
+	"server",
+	"client"
+];
+var author = "Brian McKelvey <theturtle32@gmail.com> (https://github.com/theturtle32)";
+var contributors = [
+	"Iñaki Baz Castillo <ibc@aliax.net> (http://dev.sipdoc.net)"
+];
+var version$1 = "1.0.35";
+var repository = {
+	type: "git",
+	url: "https://github.com/theturtle32/WebSocket-Node.git"
+};
+var homepage = "https://github.com/theturtle32/WebSocket-Node";
+var engines = {
+	node: ">=4.0.0"
+};
+var dependencies = {
+	bufferutil: "^4.0.1",
+	debug: "^2.2.0",
+	"es5-ext": "^0.10.63",
+	"typedarray-to-buffer": "^3.1.5",
+	"utf-8-validate": "^5.0.2",
+	yaeti: "^0.0.6"
+};
+var devDependencies = {
+	"buffer-equal": "^1.0.0",
+	gulp: "^4.0.2",
+	"gulp-jshint": "^2.0.4",
+	"jshint-stylish": "^2.2.1",
+	jshint: "^2.0.0",
+	tape: "^4.9.1"
+};
+var config = {
+	verbose: false
+};
+var scripts = {
+	test: "tape test/unit/*.js",
+	gulp: "gulp"
+};
+var main = "index";
+var directories = {
+	lib: "./lib"
+};
+var browser$3 = "lib/browser.js";
+var license = "Apache-2.0";
+var require$$0 = {
+	name: name,
+	description: description,
+	keywords: keywords,
+	author: author,
+	contributors: contributors,
+	version: version$1,
+	repository: repository,
+	homepage: homepage,
+	engines: engines,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	config: config,
+	scripts: scripts,
+	main: main,
+	directories: directories,
+	browser: browser$3,
+	license: license
+};
+
+var version = require$$0.version;
+
+var _globalThis;
+if (typeof globalThis === 'object') {
+	_globalThis = globalThis;
+} else {
+	try {
+		_globalThis = requireGlobal();
+	} catch (error) {
+	} finally {
+		if (!_globalThis && typeof window !== 'undefined') { _globalThis = window; }
+		if (!_globalThis) { throw new Error('Could not determine global this'); }
+	}
+}
+
+var NativeWebSocket = _globalThis.WebSocket || _globalThis.MozWebSocket;
+var websocket_version = version;
+
+
+/**
+ * Expose a W3C WebSocket class with just one or two arguments.
+ */
+function W3CWebSocket(uri, protocols) {
+	var native_instance;
+
+	if (protocols) {
+		native_instance = new NativeWebSocket(uri, protocols);
+	}
+	else {
+		native_instance = new NativeWebSocket(uri);
+	}
+
+	/**
+	 * 'native_instance' is an instance of nativeWebSocket (the browser's WebSocket
+	 * class). Since it is an Object it will be returned as it is when creating an
+	 * instance of W3CWebSocket via 'new W3CWebSocket()'.
+	 *
+	 * ECMAScript 5: http://bclary.com/2004/11/07/#a-13.2.2
+	 */
+	return native_instance;
+}
+if (NativeWebSocket) {
+	['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function(prop) {
+		Object.defineProperty(W3CWebSocket, prop, {
+			get: function() { return NativeWebSocket[prop]; }
+		});
+	});
+}
+
+/**
+ * Module exports.
+ */
+var browser = {
+    'w3cwebsocket' : NativeWebSocket ? W3CWebSocket : null,
+    'version'      : websocket_version
+};
+
+var browser$1 = /*@__PURE__*/getDefaultExportFromCjs(browser);
+
+var browser$2 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: browser$1
+});
+
+export { browser$2 as b };

package/exports/browser/browser-pguCHlVu-pguCHlVu.js

@@ -0,0 +1,25 @@
+var browser$1 = {};
+
+browser$1.MediaStream = window.MediaStream;
+browser$1.MediaStreamTrack = window.MediaStreamTrack;
+browser$1.RTCDataChannel = window.RTCDataChannel;
+browser$1.RTCDataChannelEvent = window.RTCDataChannelEvent;
+browser$1.RTCDtlsTransport = window.RTCDtlsTransport;
+browser$1.RTCIceCandidate = window.RTCIceCandidate;
+browser$1.RTCIceTransport = window.RTCIceTransport;
+browser$1.RTCPeerConnection = window.RTCPeerConnection;
+browser$1.RTCPeerConnectionIceEvent = window.RTCPeerConnectionIceEvent;
+browser$1.RTCRtpReceiver = window.RTCRtpReceiver;
+browser$1.RTCRtpSender = window.RTCRtpSender;
+browser$1.RTCRtpTransceiver = window.RTCRtpTransceiver;
+browser$1.RTCSctpTransport = window.RTCSctpTransport;
+browser$1.RTCSessionDescription = window.RTCSessionDescription;
+browser$1.getUserMedia = window.getUserMedia;
+browser$1.mediaDevices = navigator.mediaDevices;
+
+var browser = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: browser$1
+});
+
+export { browser as b };

package/exports/browser/browser-store.js

@@ -0,0 +1,306 @@
+const encode = (string) => {
+    if (typeof string === 'string')
+        return new TextEncoder().encode(string);
+    throw Error(`expected typeof String instead got ${string}`);
+};
+const decode = (uint8Array) => {
+    if (uint8Array instanceof Uint8Array)
+        return new TextDecoder().decode(uint8Array);
+    throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
+};
+
+const pathSepS = '/';
+class KeyPath {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyPath) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath');
+        }
+    }
+    isKeyPath() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
+    /**
+     * Returns the `list` representation of this path.
+     *
+     * @example
+     * ```js
+     * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+     * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+     * ```
+     */
+    list() {
+        return this.toString().split(pathSepS).slice(1);
+    }
+}
+
+class KeyValue {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyValue) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue');
+        }
+    }
+    isKeyValue() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
+}
+
+if (!globalThis.DEBUG) {
+  let DEBUG = [];
+  if (globalThis.localStorage) {
+    DEBUG = globalThis.localStorage.getItem('DEBUG');
+    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+  }
+}
+
+const debug$1 = (target, text) => {
+  if (!globalThis.DEBUG && globalThis.DEBUG.length === 0) return;
+  if (
+    globalThis.DEBUG === 'true' ||
+    globalThis.DEBUG === true ||
+    globalThis.DEBUG?.indexOf(target) !== -1 ||
+    globalThis.DEBUG?.indexOf('*') !== -1 ||
+    globalThis.DEBUG?.indexOf(target.split('/')[0]) !== -1
+  )
+    if (text) console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+    else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+};
+
+if (!globalThis.debug) {
+  globalThis.debug = debug$1;
+
+  globalThis.createDebugger = (target) => (text) => debug$1(target, text);
+}
+
+const debug = globalThis.createDebugger('leofcoin/storage');
+const opfsRoot = await navigator.storage.getDirectory();
+class BrowerStore {
+    db;
+    name;
+    root;
+    inWorker;
+    version;
+    busy;
+    queue = [];
+    async init(name = 'storage', root = '.leofcoin', version = '1', inWorker = false) {
+        this.version = version;
+        this.name = name;
+        this.root = opfsRoot;
+        this.inWorker = inWorker;
+        let directoryHandle;
+        try {
+            directoryHandle = await opfsRoot.getDirectoryHandle(this.name, {
+                create: true
+            });
+            if (inWorker) {
+                // it's in a worker so that's why typings invalid?
+                // @ts-ignore
+                directoryHandle = await directoryHandle.createSyncAccessHandle();
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        this.db = directoryHandle;
+    }
+    toKeyPath(key) {
+        if (key instanceof KeyPath)
+            key = new KeyPath(key);
+        return key.toString();
+    }
+    toKeyValue(value) {
+        if (value instanceof KeyValue)
+            value = new KeyValue(value);
+        // @ts-ignore
+        return value.uint8Array;
+    }
+    async has(key) {
+        debug(`has ${this.toKeyPath(key)}`);
+        try {
+            await this.db.getFileHandle(this.toKeyPath(key));
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async get(key) {
+        let promiseResolve;
+        let promiseReject;
+        let result = new Promise((resolve, reject) => {
+            promiseResolve = resolve;
+            promiseReject = reject;
+        });
+        const promise = () => new Promise(async (resolve, reject) => {
+            debug(`get ${this.toKeyPath(key)}`);
+            setTimeout(async () => {
+                try {
+                    let handle = await this.db.getFileHandle(this.toKeyPath(key));
+                    let readBuffer;
+                    if (this.inWorker) {
+                        // it's in a worker so that's why typings invalid?
+                        // @ts-ignore
+                        handle = await handle.createSyncAccessHandle();
+                        // @ts-ignore
+                        const fileSize = handle.getSize();
+                        // Read file content to a buffer.
+                        const buffer = new DataView(new ArrayBuffer(fileSize));
+                        // @ts-ignore
+                        readBuffer = handle.read(buffer, { at: 0 });
+                        // @ts-ignore
+                        handle.close();
+                    }
+                    else {
+                        const file = await handle.getFile();
+                        readBuffer = await file.arrayBuffer();
+                    }
+                    this.runQueue();
+                    promiseResolve(new Uint8Array(readBuffer));
+                    resolve(new Uint8Array(readBuffer));
+                }
+                catch (error) {
+                    promiseReject(error);
+                    resolve(false);
+                }
+            }, 1);
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return result;
+    }
+    async put(key, value) {
+        let promiseResolve;
+        let promiseReject;
+        let result = new Promise((resolve, reject) => {
+            promiseResolve = resolve;
+            promiseReject = reject;
+        });
+        const promise = () => new Promise(async (resolve, reject) => {
+            debug(`put ${this.toKeyPath(key)}`);
+            setTimeout(async () => {
+                try {
+                    let handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
+                    let writeable;
+                    if (this.inWorker) {
+                        // it's in a worker so that's why typings invalid?
+                        // @ts-ignore
+                        writeable = await handle.createSyncAccessHandle();
+                    }
+                    else {
+                        writeable = await handle.createWritable();
+                    }
+                    ;
+                    (await writeable).write(this.toKeyValue(value));
+                    (await writeable).close();
+                    this.runQueue();
+                    resolve(true);
+                    promiseResolve(true);
+                }
+                catch (error) {
+                    promiseReject(error);
+                    resolve(false);
+                }
+            }, 5);
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return result;
+    }
+    async runQueue() {
+        if (this.queue.length > 0 && !this.busy) {
+            this.busy = true;
+            const next = this.queue.shift();
+            await next();
+            this.busy = false;
+            return this.runQueue();
+        }
+        else if (this.queue.length === 0 && this.busy) {
+            this.busy = false;
+        }
+    }
+    async delete(key) {
+        debug(`delete ${this.toKeyPath(key)}`);
+        return new Promise(async (resolve, reject) => {
+            try {
+                await this.db.getFileHandle(`${this.toKeyPath(key)}.crswap`);
+                setTimeout(() => resolve(this.delete(key)), 5);
+            }
+            catch (error) {
+                try {
+                    await this.db.removeEntry(this.toKeyPath(key));
+                    resolve(true);
+                }
+                catch (error) {
+                    if (error.name === 'NoModificationAllowedError')
+                        setTimeout(() => resolve(this.delete(key)), 5);
+                    else
+                        reject(error);
+                }
+            }
+        });
+    }
+    async clear() {
+        for await (const key of this.db.keys()) {
+            debug(`clear ${this.toKeyPath(key)}`);
+            await this.delete(key);
+        }
+    }
+    async values() {
+        let values = [];
+        for await (const cursor of this.db.values()) {
+            // huh? Outdated typings?
+            // @ts-ignore
+            values.push(cursor.getFile());
+        }
+        values = await Promise.all(values);
+        return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
+    }
+    async size() {
+        let size = 0;
+        for await (const cursor of this.db.values()) {
+            // huh? Outdated typings?
+            // @ts-ignore
+            console.log((await cursor.getFile()).size);
+
+            size += (await cursor.getFile()).size;
+        }
+        return size;
+    }
+    async keys() {
+        const keys = [];
+        for await (const cursor of this.db.keys()) {
+            keys.push(cursor);
+        }
+        return keys;
+    }
+    async iterate() {
+        return this.db.entries();
+    }
+}
+
+export { BrowerStore as default };