@leoqlin/openclaw-qqbot 1.6.7-alpha1

package/node_modules/@eshaz/web-worker/cjs/node.js

@@ -0,0 +1,219 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * 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.
+ */
+const URL = require('url');
+const VM = require('vm');
+const threads = require('worker_threads');
+const WORKER = Symbol.for('worker');
+const EVENTS = Symbol.for('events');
+class EventTarget {
+  constructor() {
+    Object.defineProperty(this, EVENTS, {
+      value: new Map()
+    });
+  }
+  dispatchEvent(event) {
+    event.target = event.currentTarget = this;
+    if (this['on' + event.type]) {
+      try {
+        this['on' + event.type](event);
+      } catch (err) {
+        console.error(err);
+      }
+    }
+    const list = this[EVENTS].get(event.type);
+    if (list == null) return;
+    list.forEach(handler => {
+      try {
+        handler.call(this, event);
+      } catch (err) {
+        console.error(err);
+      }
+    });
+  }
+  addEventListener(type, fn) {
+    let events = this[EVENTS].get(type);
+    if (!events) this[EVENTS].set(type, events = []);
+    events.push(fn);
+  }
+  removeEventListener(type, fn) {
+    let events = this[EVENTS].get(type);
+    if (events) {
+      const index = events.indexOf(fn);
+      if (index !== -1) events.splice(index, 1);
+    }
+  }
+}
+function Event(type, target) {
+  this.type = type;
+  this.timeStamp = Date.now();
+  this.target = this.currentTarget = this.data = null;
+}
+
+// this module is used self-referentially on both sides of the
+// thread boundary, but behaves differently in each context.
+module.exports = threads.isMainThread ? mainThread() : workerThread();
+const baseUrl = URL.pathToFileURL(process.cwd() + '/');
+function mainThread() {
+  /**
+   * A web-compatible Worker implementation atop Node's worker_threads.
+   *  - uses DOM-style events (Event.data, Event.type, etc)
+   *  - supports event handler properties (worker.onmessage)
+   *  - Worker() constructor accepts a module URL
+   *  - accepts the {type:'module'} option
+   *  - emulates WorkerGlobalScope within the worker
+   * @param {string} url  The URL or module specifier to load
+   * @param {object} [options]  Worker construction options
+   * @param {string} [options.name]  Available as `self.name` within the Worker
+   * @param {string} [options.type="classic"]  Pass "module" to create a Module Worker.
+   */
+  class Worker extends EventTarget {
+    constructor(url, options) {
+      super();
+      const {
+        name,
+        type
+      } = options || {};
+      url += '';
+      let mod;
+      if (/^data:/.test(url)) {
+        mod = url;
+      } else {
+        mod = URL.fileURLToPath(new URL.URL(url, baseUrl));
+      }
+      const worker = new threads.Worker(__filename, {
+        workerData: {
+          mod,
+          name,
+          type
+        }
+      });
+      Object.defineProperty(this, WORKER, {
+        value: worker
+      });
+      worker.on('message', data => {
+        const event = new Event('message');
+        event.data = data;
+        this.dispatchEvent(event);
+      });
+      worker.on('error', error => {
+        error.type = 'error';
+        this.dispatchEvent(error);
+      });
+      worker.on('exit', () => {
+        this.dispatchEvent(new Event('close'));
+      });
+    }
+    postMessage(data, transferList) {
+      this[WORKER].postMessage(data, transferList);
+    }
+    terminate() {
+      this[WORKER].terminate();
+    }
+  }
+  Worker.prototype.onmessage = Worker.prototype.onerror = Worker.prototype.onclose = null;
+  return Worker;
+}
+function workerThread() {
+  let {
+    mod,
+    name,
+    type
+  } = threads.workerData || {};
+  if (!mod) return mainThread();
+
+  // turn global into a mock WorkerGlobalScope
+  const self = global.self = global;
+
+  // enqueue messages to dispatch after modules are loaded
+  let q = [];
+  function flush() {
+    const buffered = q;
+    q = null;
+    buffered.forEach(event => {
+      self.dispatchEvent(event);
+    });
+  }
+  threads.parentPort.on('message', data => {
+    const event = new Event('message');
+    event.data = data;
+    if (q == null) self.dispatchEvent(event);else q.push(event);
+  });
+  threads.parentPort.on('error', err => {
+    err.type = 'Error';
+    self.dispatchEvent(err);
+  });
+  class WorkerGlobalScope extends EventTarget {
+    postMessage(data, transferList) {
+      threads.parentPort.postMessage(data, transferList);
+    }
+    // Emulates https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/close
+    close() {
+      process.exit();
+    }
+  }
+  let proto = Object.getPrototypeOf(global);
+  delete proto.constructor;
+  Object.defineProperties(WorkerGlobalScope.prototype, proto);
+  proto = Object.setPrototypeOf(global, new WorkerGlobalScope());
+  ['postMessage', 'addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(fn => {
+    proto[fn] = proto[fn].bind(global);
+  });
+  global.name = name;
+  const isDataUrl = /^data:/.test(mod);
+  if (type === 'module') {
+    import(mod).catch(err => {
+      if (isDataUrl && err.message === 'Not supported') {
+        console.warn('Worker(): Importing data: URLs requires Node 12.10+. Falling back to classic worker.');
+        return evaluateDataUrl(mod, name);
+      }
+      console.error(err);
+    }).then(flush);
+  } else {
+    try {
+      if (/^data:/.test(mod)) {
+        evaluateDataUrl(mod, name);
+      } else {
+        require(mod);
+      }
+    } catch (err) {
+      console.error(err);
+    }
+    Promise.resolve().then(flush);
+  }
+}
+function evaluateDataUrl(url, name) {
+  const {
+    data
+  } = parseDataUrl(url);
+  return VM.runInThisContext(data, {
+    filename: 'worker.<' + (name || 'data:') + '>'
+  });
+}
+function parseDataUrl(url) {
+  let [m, type, encoding, data] = url.match(/^data: *([^;,]*)(?: *; *([^,]*))? *,(.*)$/) || [];
+  if (!m) throw Error('Invalid Data URL.');
+  if (encoding) switch (encoding.toLowerCase()) {
+    case 'base64':
+      data = Buffer.from(data, 'base64').toString();
+      break;
+    default:
+      throw Error('Unknown Data URL encoding "' + encoding + '"');
+  }
+  return {
+    type,
+    data
+  };
+}

package/node_modules/@eshaz/web-worker/index.d.ts

@@ -0,0 +1,4 @@
+type ConstructorOf<C> = { new (...args: any[]): C }
+
+declare const _default: ConstructorOf<Worker>
+export default _default

package/node_modules/@eshaz/web-worker/node.js

@@ -0,0 +1,223 @@
+/**
+ * Copyright 2020 Google LLC
+ *
+ * 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.
+ */
+
+import URL from 'url';
+import VM from 'vm';
+import threads from 'worker_threads';
+
+const WORKER = Symbol.for('worker');
+const EVENTS = Symbol.for('events');
+
+class EventTarget {
+	constructor() {
+		Object.defineProperty(this, EVENTS, {
+			value: new Map()
+		});
+	}
+	dispatchEvent(event) {
+		event.target = event.currentTarget = this;
+		if (this['on'+event.type]) {
+			try {
+				this['on'+event.type](event);
+			}
+			catch (err) {
+				console.error(err);
+			}
+		}
+		const list = this[EVENTS].get(event.type);
+		if (list == null) return;
+		list.forEach(handler => {
+			try {
+				handler.call(this, event);
+			}
+			catch (err) {
+				console.error(err);
+			}
+		});
+	}
+	addEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (!events) this[EVENTS].set(type, events = []);
+		events.push(fn);
+	}
+	removeEventListener(type, fn) {
+		let events = this[EVENTS].get(type);
+		if (events) {
+			const index = events.indexOf(fn);
+			if (index !== -1) events.splice(index, 1);
+		}
+	}
+}
+
+function Event(type, target) {
+	this.type = type;
+	this.timeStamp = Date.now();
+	this.target = this.currentTarget = this.data = null;
+}
+
+// this module is used self-referentially on both sides of the
+// thread boundary, but behaves differently in each context.
+export default threads.isMainThread ? mainThread() : workerThread();
+
+const baseUrl = URL.pathToFileURL(process.cwd() + '/');
+
+function mainThread() {
+
+	/**
+	 * A web-compatible Worker implementation atop Node's worker_threads.
+	 *  - uses DOM-style events (Event.data, Event.type, etc)
+	 *  - supports event handler properties (worker.onmessage)
+	 *  - Worker() constructor accepts a module URL
+	 *  - accepts the {type:'module'} option
+	 *  - emulates WorkerGlobalScope within the worker
+	 * @param {string} url  The URL or module specifier to load
+	 * @param {object} [options]  Worker construction options
+	 * @param {string} [options.name]  Available as `self.name` within the Worker
+	 * @param {string} [options.type="classic"]  Pass "module" to create a Module Worker.
+	 */
+	class Worker extends EventTarget {
+		constructor(url, options) {
+			super();
+			const { name, type } = options || {};
+			url += '';
+			let mod;
+			if (/^data:/.test(url)) {
+				mod = url;
+			}
+			else {
+				mod = URL.fileURLToPath(new URL.URL(url, baseUrl));
+			}
+			const worker = new threads.Worker(
+				__filename,
+				{ workerData: { mod, name, type } }
+			);
+			Object.defineProperty(this, WORKER, {
+				value: worker
+			});
+			worker.on('message', data => {
+				const event = new Event('message');
+				event.data = data;
+				this.dispatchEvent(event);
+			});
+			worker.on('error', error => {
+				error.type = 'error';
+				this.dispatchEvent(error);
+			});
+			worker.on('exit', () => {
+				this.dispatchEvent(new Event('close'));
+			});
+		}
+		postMessage(data, transferList) {
+			this[WORKER].postMessage(data, transferList);
+		}
+		terminate() {
+			this[WORKER].terminate();
+		}
+	}
+	Worker.prototype.onmessage = Worker.prototype.onerror = Worker.prototype.onclose = null;
+	return Worker;
+}
+
+function workerThread() {
+	let { mod, name, type } = threads.workerData || {};
+	if (!mod) return mainThread();
+
+	// turn global into a mock WorkerGlobalScope
+	const self = global.self = global;
+
+	// enqueue messages to dispatch after modules are loaded
+	let q = [];
+	function flush() {
+		const buffered = q;
+		q = null;
+		buffered.forEach(event => { self.dispatchEvent(event); });
+	}
+	threads.parentPort.on('message', data => {
+		const event = new Event('message');
+		event.data = data;
+		if (q == null) self.dispatchEvent(event);
+		else q.push(event);
+	});
+	threads.parentPort.on('error', err => {
+		err.type = 'Error';
+		self.dispatchEvent(err);
+	});
+
+	class WorkerGlobalScope extends EventTarget {
+		postMessage(data, transferList) {
+			threads.parentPort.postMessage(data, transferList);
+		}
+		// Emulates https://developer.mozilla.org/en-US/docs/Web/API/DedicatedWorkerGlobalScope/close
+		close() {
+			process.exit();
+		}
+	}
+	let proto = Object.getPrototypeOf(global);
+	delete proto.constructor;
+	Object.defineProperties(WorkerGlobalScope.prototype, proto);
+	proto = Object.setPrototypeOf(global, new WorkerGlobalScope());
+	['postMessage', 'addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(fn => {
+		proto[fn] = proto[fn].bind(global);
+	});
+	global.name = name;
+
+	const isDataUrl = /^data:/.test(mod);
+	if (type === 'module') {
+		import(mod)
+			.catch(err => {
+				if (isDataUrl && err.message === 'Not supported') {
+					console.warn('Worker(): Importing data: URLs requires Node 12.10+. Falling back to classic worker.');
+					return evaluateDataUrl(mod, name);
+				}
+				console.error(err);
+			})
+			.then(flush);
+	}
+	else {
+		try {
+			if (/^data:/.test(mod)) {
+				evaluateDataUrl(mod, name);
+			}
+			else {
+				require(mod);
+			}
+		}
+		catch (err) {
+			console.error(err);
+		}
+		Promise.resolve().then(flush);
+	}
+}
+
+function evaluateDataUrl(url, name) {
+	const { data } = parseDataUrl(url);
+	return VM.runInThisContext(data, {
+		filename: 'worker.<'+(name || 'data:')+'>'
+	});
+}
+
+function parseDataUrl(url) {
+	let [m, type, encoding, data] = url.match(/^data: *([^;,]*)(?: *; *([^,]*))? *,(.*)$/) || [];
+	if (!m) throw Error('Invalid Data URL.');
+	if (encoding) switch (encoding.toLowerCase()) {
+		case 'base64':
+			data = Buffer.from(data, 'base64').toString();
+			break;
+		default:
+			throw Error('Unknown Data URL encoding "' + encoding + '"');
+	}
+	return { type, data };
+}

package/node_modules/@eshaz/web-worker/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@eshaz/web-worker",
+  "version": "1.2.2",
+  "description": "Consistent Web Workers in browser and Node.",
+  "main": "./cjs/node.js",
+  "browser": "./cjs/browser.js",
+  "types": "index.d.ts",
+  "files": [
+    "cjs",
+    "browser.js",
+    "node.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "prepare": "babel node.js browser.js -d cjs",
+    "test": "eslint '*.js' test && node --experimental-modules ./node_modules/.bin/ava"
+  },
+  "babel": {
+    "plugins": [
+      "@babel/plugin-syntax-dynamic-import",
+      "babel-plugin-commonjs-lite"
+    ]
+  },
+  "repository": "https://github.com/eshaz/web-worker",
+  "keywords": [
+    "worker",
+    "worker_threads",
+    "webworker",
+    "web worker",
+    "web-worker",
+    "threads"
+  ],
+  "authors": [],
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/eshaz/web-worker",
+  "eslintConfig": {
+    "extends": "developit",
+    "rules": {
+      "no-console": 0
+    }
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.7.7",
+    "@babel/core": "^7.7.7",
+    "@babel/plugin-syntax-dynamic-import": "^7.7.4",
+    "@babel/plugin-transform-modules-commonjs": "^7.7.5",
+    "@babel/preset-env": "^7.7.7",
+    "ava": "^2.4.0",
+    "babel-plugin-commonjs-lite": "gist:3e38560d5bed35da1fd708d635e4acb3",
+    "eslint": "^6.8.0",
+    "eslint-config-developit": "^1.1.1",
+    "eslint-plugin-compat": "^4.1.4"
+  }
+}

package/node_modules/@wasm-audio-decoders/common/index.js

@@ -0,0 +1,5 @@
+import WASMAudioDecoderCommon from "./src/WASMAudioDecoderCommon.js";
+import WASMAudioDecoderWorker from "./src/WASMAudioDecoderWorker.js";
+import { assignNames } from "./src/utilities.js";
+
+export { WASMAudioDecoderCommon, WASMAudioDecoderWorker, assignNames };

package/node_modules/@wasm-audio-decoders/common/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@wasm-audio-decoders/common",
+  "version": "9.0.7",
+  "description": "Web Assembly Audio Decoders Common",
+  "module": "index.js",
+  "main": "index.js",
+  "exports": {
+    "types": "./types.d.ts",
+    "default": "./index.js"
+  },
+  "types": "types.d.ts",
+  "sideEffects": false,
+  "files": [
+    "index.js",
+    "types.d.ts",
+    "src/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eshaz/wasm-audio-decoders.git"
+  },
+  "type": "module",
+  "author": {
+    "name": "Ethan Halsall",
+    "email": "ethanhalsall@pm.me"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/eshaz/wasm-audio-decoders/issues"
+  },
+  "homepage": "https://github.com/eshaz/wasm-audio-decoders/tree/master/src/common",
+  "dependencies": {
+    "@eshaz/web-worker": "1.2.2",
+    "simple-yenc": "^1.0.4"
+  }
+}