@jointhedots/gear 1.0.21 → 1.1.5

package/node_modules/@jspm/core/src-browser/url.js

@@ -0,0 +1,154 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+import url from 'url';
+import path from 'path-browserify';
+
+const processPlatform = typeof Deno !== 'undefined' ? (Deno.build.os === "windows" ? "win32" : Deno.build.os) : undefined;
+
+export default url;
+
+url.URL = typeof URL !== 'undefined' ? URL : null;
+url.pathToFileURL = pathToFileURL;
+url.fileURLToPath = fileURLToPath;
+
+export var Url = url.Url;
+export var format = url.format;
+export var resolve = url.resolve;
+export var resolveObject = url.resolveObject;
+export var parse = url.parse;
+
+const _URL = url.URL;
+export { _URL as URL }
+
+const CHAR_BACKWARD_SLASH = 92;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_LOWERCASE_A = 97;
+const CHAR_LOWERCASE_Z = 122;
+
+const isWindows = processPlatform === 'win32';
+
+const forwardSlashRegEx = /\//g;
+const percentRegEx = /%/g;
+const backslashRegEx = /\\/g;
+const newlineRegEx = /\n/g;
+const carriageReturnRegEx = /\r/g;
+const tabRegEx = /\t/g;
+
+/**
+ * Get fully resolved platform-specific file path from the given URL string/ object
+ * @param path The file URL string or URL object to convert to a path
+ */
+export function fileURLToPath(path) {
+  if (typeof path === "string") path = new URL(path);
+  else if (!(path instanceof URL)) {
+    throw new Deno.errors.InvalidData(
+      "invalid argument path , must be a string or URL",
+    );
+  }
+  if (path.protocol !== "file:") {
+    throw new Deno.errors.InvalidData("invalid url scheme");
+  }
+  return isWindows ? getPathFromURLWin(path) : getPathFromURLPosix(path);
+}
+
+function getPathFromURLWin(url) {
+  const hostname = url.hostname;
+  let pathname = url.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = pathname.codePointAt(n + 2) || 0x20;
+      if (
+        (pathname[n + 1] === "2" && third === 102) || // 2f 2F /
+        (pathname[n + 1] === "5" && third === 99)
+      ) {
+        // 5c 5C \
+        throw new Deno.errors.InvalidData(
+          "must not include encoded \\ or / characters",
+        );
+      }
+    }
+  }
+
+  pathname = pathname.replace(forwardSlashRegEx, "\\");
+  pathname = decodeURIComponent(pathname);
+  if (hostname !== "") {
+    //TODO add support for punycode encodings
+    return `\\\\${hostname}${pathname}`;
+  } else {
+    // Otherwise, it's a local path that requires a drive letter
+    const letter = pathname.codePointAt(1) | 0x20;
+    const sep = pathname[2];
+    if (
+      letter < CHAR_LOWERCASE_A ||
+      letter > CHAR_LOWERCASE_Z || // a..z A..Z
+      sep !== ":"
+    ) {
+      throw new Deno.errors.InvalidData("file url path must be absolute");
+    }
+    return pathname.slice(1);
+  }
+};
+
+function getPathFromURLPosix(url) {
+  if (url.hostname !== "") {
+    throw new Deno.errors.InvalidData("invalid file url hostname");
+  }
+  const pathname = url.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = pathname.codePointAt(n + 2) || 0x20;
+      if (pathname[n + 1] === "2" && third === 102) {
+        throw new Deno.errors.InvalidData(
+          "must not include encoded / characters",
+        );
+      }
+    }
+  }
+  return decodeURIComponent(pathname);
+}
+
+/** Get fully resolved platform-specific File URL from the given file path */
+export function pathToFileURL(filepath) {
+  let resolved = path.resolve(filepath);
+  // path.resolve strips trailing slashes so we must add them back
+  const filePathLast = filepath.charCodeAt(filepath.length - 1);
+  if (
+    (filePathLast === CHAR_FORWARD_SLASH ||
+      (isWindows && filePathLast === CHAR_BACKWARD_SLASH)) &&
+    resolved[resolved.length - 1] !== path.sep
+  ) {
+    resolved += "/";
+  }
+  const outURL = new URL("file://");
+  if (resolved.includes("%")) resolved = resolved.replace(percentRegEx, "%25");
+  // In posix, "/" is a valid character in paths
+  if (!isWindows && resolved.includes("\\")) {
+    resolved = resolved.replace(backslashRegEx, "%5C");
+  }
+  if (resolved.includes("\n")) resolved = resolved.replace(newlineRegEx, "%0A");
+  if (resolved.includes("\r")) {
+    resolved = resolved.replace(carriageReturnRegEx, "%0D");
+  }
+  if (resolved.includes("\t")) resolved = resolved.replace(tabRegEx, "%09");
+  outURL.pathname = resolved;
+  return outURL;
+};

package/node_modules/@jspm/core/src-browser/util/types.js

@@ -0,0 +1,48 @@
+import { types } from '../util.js';
+export { types as default } from '../util.js';
+
+export const {
+  isExternal,
+  isDate,
+  isArgumentsObject,
+  isBigIntObject,
+  isBooleanObject,
+  isNumberObject,
+  isStringObject,
+  isSymbolObject,
+  isNativeError,
+  isRegExp,
+  isAsyncFunction,
+  isGeneratorFunction,
+  isGeneratorObject,
+  isPromise,
+  isMap,
+  isSet,
+  isMapIterator,
+  isSetIterator,
+  isWeakMap,
+  isWeakSet,
+  isArrayBuffer,
+  isDataView,
+  isSharedArrayBuffer,
+  isProxy,
+  isModuleNamespaceObject,
+  isAnyArrayBuffer,
+  isBoxedPrimitive,
+  isArrayBufferView,
+  isTypedArray,
+  isUint8Array,
+  isUint8ClampedArray,
+  isUint16Array,
+  isUint32Array,
+  isInt8Array,
+  isInt16Array,
+  isInt32Array,
+  isFloat32Array,
+  isFloat64Array,
+  isBigInt64Array,
+  isBigUint64Array,
+  isKeyObject,
+  isCryptoKey
+} = types;
+

package/node_modules/@jspm/core/src-browser/util.js

@@ -0,0 +1,30 @@
+import util from 'util';
+export default util;
+export var _extend = util._extend;
+export var callbackify = util.callbackify;
+export var debuglog = util.debuglog;
+export var deprecate = util.deprecate;
+export var format = util.format;
+export var inherits = util.inherits;
+export var inspect = util.inspect;
+export var isArray = util.isArray;
+export var isBoolean = util.isBoolean;
+export var isBuffer = util.isBuffer;
+export var isDate = util.isDate;
+export var isError = util.isError;
+export var isFunction = util.isFunction;
+export var isNull = util.isNull;
+export var isNullOrUndefined = util.isNullOrUndefined;
+export var isNumber = util.isNumber;
+export var isObject = util.isObject;
+export var isPrimitive = util.isPrimitive;
+export var isRegExp = util.isRegExp;
+export var isString = util.isString;
+export var isSymbol = util.isSymbol;
+export var isUndefined = util.isUndefined;
+export var log = util.log;
+export var promisify = util.promisify;
+export var types = util.types;
+
+export const TextEncoder = util.TextEncoder = globalThis.TextEncoder;
+export const TextDecoder = util.TextDecoder = globalThis.TextDecoder;

package/node_modules/@jspm/core/src-browser/v8.js

@@ -0,0 +1,35 @@
+
+// Using null for Babel
+// (https://unpkg.com/browse/@babel/core@7.14.8/lib/transformation/util/clone-deep.js)
+
+const unimplemented = null;
+
+export default {
+  cacheDataVersionTag: unimplemented,
+  getHeapSnapshot: unimplemented,
+  getHeapStatistics: unimplemented,
+  getHeapSpaceStatistics: unimplemented,
+  setFlagsFromString: unimplemented,
+  Serializer: unimplemented,
+  Deserializer: unimplemented,
+  DefaultSerializer: unimplemented,
+  DefaultDeserializer: unimplemented,
+  deserialize: unimplemented,
+  serialize: unimplemented,
+  writeHeapSnapshot: unimplemented
+};
+
+export {
+  unimplemented as cacheDataVersionTag,
+  unimplemented as getHeapSnapshot,
+  unimplemented as getHeapStatistics,
+  unimplemented as getHeapSpaceStatistics,
+  unimplemented as setFlagsFromString,
+  unimplemented as Serializer,
+  unimplemented as Deserializer,
+  unimplemented as DefaultSerializer,
+  unimplemented as DefaultDeserializer,
+  unimplemented as deserialize,
+  unimplemented as serialize,
+  unimplemented as writeHeapSnapshot
+}

package/node_modules/@jspm/core/src-browser/vm.js

@@ -0,0 +1,9 @@
+import vm from 'vm-browserify';
+export default vm;
+export var Script = vm.Script;
+export var createContext = vm.createContext;
+export var createScript = vm.createScript;
+export var isContext = vm.isContext;
+export var runInContext = vm.runInContext;
+export var runInNewContext = vm.runInNewContext;
+export var runInThisContext = vm.runInThisContext;

package/node_modules/@jspm/core/src-browser/wasi.js

@@ -0,0 +1,15 @@
+import { WASI as _WASI } from '@wasmer/wasi/lib/index.esm.js';
+import fs from './fs.js';
+
+export class WASI extends _WASI {
+  constructor(options) {
+    super(Object.assign({}, options, {
+      bindings: Object.assign({}, _WASI.defaultBindings, {
+        isTTY: () => false,
+        fs,
+      }),
+    }));
+  }
+}
+
+export default { WASI };

package/node_modules/@jspm/core/src-browser/worker_threads.js

@@ -0,0 +1,139 @@
+import { EventEmitter, once } from './events.js';
+
+function unimplemented(name) {
+  throw new Error(
+    `Node.js worker_threads ${name} is not currently supported by JSPM core in Deno`,
+  );
+}
+
+let environmentData = new Map();
+let threads = 0;
+
+const kHandle = Symbol('kHandle');
+export class Worker extends EventEmitter {
+  resourceLimits = {
+    maxYoungGenerationSizeMb: -1,
+    maxOldGenerationSizeMb: -1,
+    codeRangeSizeMb: -1,
+    stackSizeMb: 4,
+  };
+
+  constructor(specifier, options) {
+    super();
+    if (options?.eval === true) {
+      specifier = URL.createObjectURL(new Blob([specifier], { type: 'application/javascript' }));
+    }
+    const handle = this[kHandle] = new globalThis.Worker(specifier, {
+      ...(options || {}),
+      type: 'module',
+    });
+    handle.addEventListener('error', (event) => this.emit('error', event.error || event.message));
+    handle.addEventListener('messageerror', (event) => this.emit('messageerror', event.data));
+    handle.addEventListener('message', (event) => this.emit('message', event.data));
+    handle.postMessage({
+      environmentData,
+      threadId: (this.threadId = ++threads),
+      workerData: options?.workerData,
+    }, options?.transferList);
+    this.postMessage = handle.postMessage.bind(handle);
+    this.emit('online');
+  }
+
+  terminate() {
+    this[kHandle].terminate();
+    this.emit('exit', 0);
+  }
+
+  getHeapSnapshot = () => unimplemented('Worker#getHeapsnapshot');
+  // fake performance
+  performance = globalThis.performance;
+}
+
+export const isMainThread = typeof WorkerGlobalScope === 'undefined' || self instanceof WorkerGlobalScope === false;
+
+// fake resourceLimits
+export const resourceLimits = isMainThread ? {} : {
+  maxYoungGenerationSizeMb: 48,
+  maxOldGenerationSizeMb: 2048,
+  codeRangeSizeMb: 0,
+  stackSizeMb: 4,
+};
+
+let threadId = 0;
+let workerData = null;
+let parentPort = null;
+
+if (!isMainThread) {
+  const listeners = new WeakMap();
+  parentPort = self;
+  parentPort.off = parentPort.removeListener = function (name, listener) {
+    this.removeEventListener(name, listeners.get(listener));
+    listeners.delete(listener);
+    return this;
+  };
+  parentPort.on = parentPort.addListener = function (name, listener) {
+    const _listener = (ev) => listener(ev.data);
+    listeners.set(listener, _listener);
+    this.addEventListener(name, _listener);
+    return this;
+  };
+  parentPort.once = function (name, listener) {
+    const _listener = (ev) => listener(ev.data);
+    listeners.set(listener, _listener);
+    this.addEventListener(name, _listener);
+    return this;
+  };
+
+  // mocks
+  parentPort.setMaxListeners = () => {};
+  parentPort.getMaxListeners = () => Infinity;
+  parentPort.eventNames = () => [];
+  parentPort.listenerCount = () => 0;
+
+  parentPort.emit = () => notImplemented();
+  parentPort.removeAllListeners = () => notImplemented();
+
+  ([{ threadId, workerData, environmentData }] = await once(parentPort, 'message'));
+
+  // alias
+  parentPort.addEventListener('offline', () => parentPort.emit('close'));
+}
+
+export function getEnvironmentData(key) {
+  return environmentData.get(key);
+}
+
+export function setEnvironmentData(key, value) {
+  if (value === undefined) {
+    environmentData.delete(key);
+  } else {
+    environmentData.set(key, value);
+  }
+}
+
+export const markAsUntransferable = () => unimplemented('markAsUntransferable');
+export const moveMessagePortToContext = () => unimplemented('moveMessagePortToContext');
+export const receiveMessageOnPort = () => unimplemented('receiveMessageOnPort');
+export const MessagePort = globalThis.MessagePort;
+export const MessageChannel = globalThis.MessageChannel;
+export const BroadcastChannel = globalThis.BroadcastChannel;
+export const SHARE_ENV = Symbol.for('nodejs.worker_threads.SHARE_ENV');
+export { parentPort, threadId, workerData }
+
+export default {
+  markAsUntransferable,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  MessagePort,
+  MessageChannel,
+  BroadcastChannel,
+  Worker,
+  getEnvironmentData,
+  setEnvironmentData,
+  SHARE_ENV,
+  threadId,
+  workerData,
+  resourceLimits,
+  parentPort,
+  isMainThread,
+}

package/node_modules/@jspm/core/src-browser/zlib.js

@@ -0,0 +1,71 @@
+import zlib from 'browserify-zlib';
+export default zlib;
+export var Deflate = zlib.Deflate;
+export var DeflateRaw = zlib.DeflateRaw;
+export var Gunzip = zlib.Gunzip;
+export var Gzip = zlib.Gzip;
+export var Inflate = zlib.Inflate;
+export var InflateRaw = zlib.InflateRaw;
+export var Unzip = zlib.Unzip;
+export var Z_BEST_COMPRESSION = zlib.Z_BEST_COMPRESSION;
+export var Z_BEST_SPEED = zlib.Z_BEST_SPEED;
+export var Z_BINARY = zlib.Z_BINARY;
+export var Z_BLOCK = zlib.Z_BLOCK;
+export var Z_BUF_ERROR = zlib.Z_BUF_ERROR;
+export var Z_DATA_ERROR = zlib.Z_DATA_ERROR;
+export var Z_DEFAULT_CHUNK = zlib.Z_DEFAULT_CHUNK;
+export var Z_DEFAULT_COMPRESSION = zlib.Z_DEFAULT_COMPRESSION;
+export var Z_DEFAULT_LEVEL = zlib.Z_DEFAULT_LEVEL;
+export var Z_DEFAULT_MEMLEVEL = zlib.Z_DEFAULT_MEMLEVEL;
+export var Z_DEFAULT_STRATEGY = zlib.Z_DEFAULT_STRATEGY;
+export var Z_DEFAULT_WINDOWBITS = zlib.Z_DEFAULT_WINDOWBITS;
+export var Z_DEFLATED = zlib.Z_DEFLATED;
+export var Z_ERRNO = zlib.Z_ERRNO;
+export var Z_FILTERED = zlib.Z_FILTERED;
+export var Z_FINISH = zlib.Z_FINISH;
+export var Z_FIXED = zlib.Z_FIXED;
+export var Z_FULL_FLUSH = zlib.Z_FULL_FLUSH;
+export var Z_HUFFMAN_ONLY = zlib.Z_HUFFMAN_ONLY;
+export var Z_MAX_CHUNK = zlib.Z_MAX_CHUNK;
+export var Z_MAX_LEVEL = zlib.Z_MAX_LEVEL;
+export var Z_MAX_MEMLEVEL = zlib.Z_MAX_MEMLEVEL;
+export var Z_MAX_WINDOWBITS = zlib.Z_MAX_WINDOWBITS;
+export var Z_MIN_CHUNK = zlib.Z_MIN_CHUNK;
+export var Z_MIN_LEVEL = zlib.Z_MIN_LEVEL;
+export var Z_MIN_MEMLEVEL = zlib.Z_MIN_MEMLEVEL;
+export var Z_MIN_WINDOWBITS = zlib.Z_MIN_WINDOWBITS;
+export var Z_NEED_DICT = zlib.Z_NEED_DICT;
+export var Z_NO_COMPRESSION = zlib.Z_NO_COMPRESSION;
+export var Z_NO_FLUSH = zlib.Z_NO_FLUSH;
+export var Z_OK = zlib.Z_OK;
+export var Z_PARTIAL_FLUSH = zlib.Z_PARTIAL_FLUSH;
+export var Z_RLE = zlib.Z_RLE;
+export var Z_STREAM_END = zlib.Z_STREAM_END;
+export var Z_STREAM_ERROR = zlib.Z_STREAM_ERROR;
+export var Z_SYNC_FLUSH = zlib.Z_SYNC_FLUSH;
+export var Z_TEXT = zlib.Z_TEXT;
+export var Z_TREES = zlib.Z_TREES;
+export var Z_UNKNOWN = zlib.Z_UNKNOWN;
+export var Zlib = zlib.Zlib;
+export var codes = zlib.codes;
+export var createDeflate = zlib.createDeflate;
+export var createDeflateRaw = zlib.createDeflateRaw;
+export var createGunzip = zlib.createGunzip;
+export var createGzip = zlib.createGzip;
+export var createInflate = zlib.createInflate;
+export var createInflateRaw = zlib.createInflateRaw;
+export var createUnzip = zlib.createUnzip;
+export var deflate = zlib.deflate;
+export var deflateRaw = zlib.deflateRaw;
+export var deflateRawSync = zlib.deflateRawSync;
+export var deflateSync = zlib.deflateSync;
+export var gunzip = zlib.gunzip;
+export var gunzipSync = zlib.gunzipSync;
+export var gzip = zlib.gzip;
+export var gzipSync = zlib.gzipSync;
+export var inflate = zlib.inflate;
+export var inflateRaw = zlib.inflateRaw;
+export var inflateRawSync = zlib.inflateRawSync;
+export var inflateSync = zlib.inflateSync;
+export var unzip = zlib.unzip;
+export var unzipSync = zlib.unzipSync;

package/node_modules/@jspm/core/test/chrome-worker_threads.test.js

@@ -0,0 +1,14 @@
+import assert from '../nodelibs/browser/assert.js';
+import { Worker } from '../nodelibs/browser/worker_threads.js';
+import { once } from '../nodelibs/browser/events.js';
+
+const worker = new Worker(`import { parentPort } from 'http://localhost:8080/nodelibs/browser/worker_threads.js';
+import { once } from 'http://localhost:8080/nodelibs/browser/events.js';
+
+parentPort.postMessage('hello');
+parentPort.postMessage(\`received: \${(await once(parentPort, 'message'))[0]}\`);
+`, { eval: true });
+worker.postMessage('hello2');
+
+assert.deepStrictEqual(await once(worker, 'message'), ['hello']);
+assert.deepStrictEqual(await once(worker, 'message'), ['received: hello2']);

package/node_modules/@jspm/core/test/exports.test.js

@@ -0,0 +1,99 @@
+import * as empty from '../nodelibs/@empty.js';
+import * as emptyDew from '../nodelibs/@empty.dew.js';
+import * as assert from '../nodelibs/browser/assert.js';
+import * as assertStrict from '../nodelibs/browser/assert/strict.js';
+import * as buffer from '../nodelibs/browser/buffer.js';
+import * as console from '../nodelibs/browser/console.js';
+import * as constants from '../nodelibs/browser/constants.js';
+import * as crypto from '../nodelibs/browser/crypto.js';
+import * as domain from '../nodelibs/browser/domain.js';
+import * as events from '../nodelibs/browser/events.js';
+import * as fs from '../nodelibs/browser/fs.js';
+import * as fsPromises from '../nodelibs/browser/fs/promises.js';
+import * as http from '../nodelibs/browser/http.js';
+import * as https from '../nodelibs/browser/https.js';
+import * as os from '../nodelibs/browser/os.js';
+import * as path from '../nodelibs/browser/path.js';
+import * as pathPosix from '../nodelibs/browser/path/posix.js';
+import * as pathWin32 from '../nodelibs/browser/path/win32.js';
+import * as process from '../nodelibs/browser/process.js';
+import * as punycode from '../nodelibs/browser/punycode.js';
+import * as querystring from '../nodelibs/browser/querystring.js';
+import * as stream from '../nodelibs/browser/stream.js';
+import * as streamPromises from '../nodelibs/browser/stream/promises.js';
+import * as string_decoder from '../nodelibs/browser/string_decoder.js';
+import * as sys from '../nodelibs/browser/sys.js';
+import * as timers from '../nodelibs/browser/timers.js';
+import * as tty from '../nodelibs/browser/tty.js';
+import * as url from '../nodelibs/browser/url.js';
+import * as util from '../nodelibs/browser/util.js';
+import * as vm from '../nodelibs/browser/vm.js';
+import * as zlib from '../nodelibs/browser/zlib.js';
+import * as performance from '../nodelibs/browser/perf_hooks.js'
+import * as diagnostics_channel from '../nodelibs/browser/diagnostics_channel.js'
+import * as wasi from '../nodelibs/browser/wasi.js'
+import * as webStream from '../nodelibs/browser/stream/web.js'
+import * as workerThreads from '../nodelibs/browser/worker_threads.js'
+
+if (Object.keys(assert).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(assertStrict).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(buffer).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(console).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(constants).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(crypto).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(domain).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(events).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(fs).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(fsPromises).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(http).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(https).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(os).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(path).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(process).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(punycode).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(querystring).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(stream).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(string_decoder).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(sys).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(timers).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(tty).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(url).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(util).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(vm).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(zlib).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(performance).length < 5)
+  throw new Error('Invalid exports');
+else if (Object.keys(diagnostics_channel).length < 4)
+  throw new Error('Invalid exports')
+else if (Object.keys(wasi).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(webStream).length < 2)
+  throw new Error('Invalid exports.');
+else if (Object.keys(workerThreads).length < 16)
+  throw new Error('Invalid exports');

package/node_modules/@jspm/core/test/fs.test.js

@@ -0,0 +1,13 @@
+import assert from '../nodelibs/browser/assert.js';
+import * as fs from '../nodelibs/browser/fs.js';
+
+fs.appendFileSync('/dev/stdout', 'test');
+fs.appendFileSync('/dev/stderr', 'test');
+
+assert.deepStrictEqual(fs.readdirSync('/').sort(), ['dev', 'usr', 'home', 'tmp'].sort());
+assert.deepStrictEqual(fs.readdirSync('/usr'), ['bin']);
+
+// TODO: test that stdout and stderr are console.logged and console.errored.
+
+assert.deepStrictEqual(fs.readFileSync('/dev/stderr', 'utf8'), 'test');
+assert.deepStrictEqual(fs.readFileSync('/dev/stdout', 'utf8'), 'test');

package/node_modules/@jspm/core/test/os.test.js

@@ -0,0 +1,7 @@
+import assert from '../nodelibs/browser/assert.js';
+import * as os from '../nodelibs/browser/os.js';
+
+assert.strictEqual(os.cpus().length, navigator.hardwareConcurrency);
+assert.strictEqual(typeof os.totalmem(), 'number');
+assert.strictEqual(typeof os.uptime(), 'number');
+assert.ok(['BE', 'LE'].includes(os.endianness()));

package/node_modules/@jspm/core/test/process.test.js

@@ -0,0 +1,15 @@
+import assert from '../nodelibs/browser/assert.js';
+import * as process from '../nodelibs/browser/process.js';
+
+assert.strictEqual(process.cwd(), '/');
+
+assert.strictEqual(process.cwd(), '/');
+
+assert.strictEqual(typeof process.uptime(), 'number');
+assert.ok(process.uptime() >= 0);
+assert.strictEqual(process.hrtime().length, 2);
+assert.strictEqual(typeof process.hrtime()[0], 'number');
+assert.strictEqual(typeof process.hrtime()[1], 'number');
+assert.ok(process.hrtime()[0] > 0);
+assert.ok(process.hrtime()[1] >= 0);
+assert.strictEqual(typeof process.hrtime.bigint(), typeof BigInt === 'undefined' ? 'number' : 'bigint');