@jointhedots/gear 1.0.21 → 1.1.4

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

@@ -0,0 +1,282 @@
+function unimplemented(name) {
+  throw new Error('Node.js process ' + name + ' is not supported by JSPM core outside of Node.js');
+}
+
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+  if (!draining || !currentQueue)
+    return;
+  draining = false;
+  if (currentQueue.length) {
+    queue = currentQueue.concat(queue);
+  }
+  else {
+    queueIndex = -1;
+  }
+  if (queue.length)
+    drainQueue();
+}
+
+function drainQueue() {
+  if (draining)
+    return;
+  var timeout = setTimeout(cleanUpNextTick, 0);
+  draining = true;
+
+  var len = queue.length;
+  while(len) {
+    currentQueue = queue;
+    queue = [];
+    while (++queueIndex < len) {
+      if (currentQueue)
+        currentQueue[queueIndex].run();
+    }
+    queueIndex = -1;
+    len = queue.length;
+  }
+  currentQueue = null;
+  draining = false;
+  clearTimeout(timeout);
+}
+
+export function nextTick (fun) {
+  var args = new Array(arguments.length - 1);
+  if (arguments.length > 1) {
+    for (var i = 1; i < arguments.length; i++)
+      args[i - 1] = arguments[i];
+  }
+  queue.push(new Item(fun, args));
+  if (queue.length === 1 && !draining)
+    setTimeout(drainQueue, 0);
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+  this.fun = fun;
+  this.array = array;
+}
+Item.prototype.run = function () {
+  this.fun.apply(null, this.array);
+};
+
+export var title = 'browser';
+export var arch = 'x64';
+export var platform = 'browser';
+export var env = {
+  PATH: '/usr/bin',
+  LANG: typeof navigator !== 'undefined' ? navigator.language + '.UTF-8' : undefined,
+  PWD: '/',
+  HOME: '/home',
+  TMP: '/tmp',
+};
+export var argv = ['/usr/bin/node'];
+export var execArgv = [];
+export var version = 'v16.8.0';
+export var versions = {};
+
+export var emitWarning = function(message, type) {
+  console.warn((type ? (type + ': ') : '') + message);
+};
+
+export var binding = function(name) { unimplemented('binding'); };
+
+export var umask = function(mask) { return 0; };
+
+export var cwd = function() { return '/'; };
+export var chdir = function(dir) {};
+
+export var release = {
+  name: 'node',
+  sourceUrl: '',
+  headersUrl: '',
+  libUrl: '',
+}
+
+function noop() {}
+
+export var browser = true;
+export var _rawDebug = noop;
+export var moduleLoadList = [];
+export function _linkedBinding(name) { unimplemented('_linkedBinding'); }
+export var domain = {};
+export var _exiting = false;
+export var config = {};
+export function dlopen(name) { unimplemented('dlopen'); }
+export function _getActiveRequests() { return []; }
+export function _getActiveHandles() { return []; }
+export var reallyExit = noop;
+export var _kill = noop;
+export var cpuUsage = function() { return {}; };
+export var resourceUsage = cpuUsage;
+export var memoryUsage = cpuUsage;
+export var kill = noop;
+export var exit = noop;
+export var openStdin = noop;
+export var allowedNodeEnvironmentFlags = {};
+export function assert(condition, message) {
+  if (!condition) throw new Error(message || 'assertion error');
+}
+export var features = {
+  inspector: false,
+  debug: false,
+  uv: false,
+  ipv6: false,
+  tls_alpn: false,
+  tls_sni: false,
+  tls_ocsp: false,
+  tls: false,
+  cached_builtins: true,
+};
+export var _fatalExceptions = noop;
+export var setUncaughtExceptionCaptureCallback = noop;
+export function hasUncaughtExceptionCaptureCallback() { return false; };
+export var _tickCallback = noop;
+export var _debugProcess = noop;
+export var _debugEnd = noop;
+export var _startProfilerIdleNotifier = noop;
+export var _stopProfilerIdleNotifier = noop;
+export var stdout = undefined;
+export var stderr = undefined;
+export var stdin = undefined;
+export var abort = noop;
+export var pid = 2;
+export var ppid = 1;
+export var execPath = '/bin/usr/node';
+export var debugPort = 9229;
+export var argv0 = 'node';
+export var _preload_modules = [];
+export var setSourceMapsEnabled = noop;
+
+var _performance = {
+  now: typeof performance !== 'undefined' ? performance.now.bind(performance) : undefined,
+  timing: typeof performance !== 'undefined' ? performance.timing : undefined,
+};
+if (_performance.now === undefined) {
+  var nowOffset = Date.now();
+
+  if (_performance.timing && _performance.timing.navigationStart) {
+    nowOffset = _performance.timing.navigationStart;
+  }
+  _performance.now = () => Date.now() - nowOffset;
+}
+
+export function uptime() {
+  return _performance.now() / 1000;
+}
+
+var nanoPerSec = 1000000000;
+export function hrtime(previousTimestamp) {
+  var baseNow = Math.floor((Date.now() - _performance.now()) * 1e-3);
+  var clocktime = _performance.now() * 1e-3;
+  var seconds = Math.floor(clocktime) + baseNow;
+  var nanoseconds = Math.floor((clocktime % 1) * 1e9);
+  if (previousTimestamp) {
+    seconds = seconds - previousTimestamp[0];
+    nanoseconds = nanoseconds - previousTimestamp[1];
+    if (nanoseconds < 0) {
+      seconds--;
+      nanoseconds += nanoPerSec;
+    }
+  }
+  return [seconds, nanoseconds];
+};
+hrtime.bigint = function(time) {
+  var diff = hrtime(time);
+  if (typeof BigInt === 'undefined') {
+    return diff[0] * nanoPerSec + diff[1];
+  }
+  return BigInt(diff[0] * nanoPerSec) + BigInt(diff[1]);
+};
+
+export var _maxListeners = 10;
+export var _events = {};
+export var _eventsCount = 0;
+export function on () { return process };
+export var addListener = on;
+export var once = on;
+export var off = on;
+export var removeListener = on;
+export var removeAllListeners = on;
+export var emit = noop;
+export var prependListener = on;
+export var prependOnceListener = on;
+export function listeners (name) { return []; };
+
+var process = {
+  version,
+  versions,
+  arch,
+  platform,
+  browser,
+  release,
+  _rawDebug,
+  moduleLoadList,
+  binding,
+  _linkedBinding,
+  _events,
+  _eventsCount,
+  _maxListeners,
+  on,
+  addListener,
+  once,
+  off,
+  removeListener,
+  removeAllListeners,
+  emit,
+  prependListener,
+  prependOnceListener,
+  listeners,
+  domain,
+  _exiting,
+  config,
+  dlopen,
+  uptime,
+  _getActiveRequests,
+  _getActiveHandles,
+  reallyExit,
+  _kill,
+  cpuUsage,
+  resourceUsage,
+  memoryUsage,
+  kill,
+  exit,
+  openStdin,
+  allowedNodeEnvironmentFlags,
+  assert,
+  features,
+  _fatalExceptions,
+  setUncaughtExceptionCaptureCallback,
+  hasUncaughtExceptionCaptureCallback,
+  emitWarning,
+  nextTick,
+  _tickCallback,
+  _debugProcess,
+  _debugEnd,
+  _startProfilerIdleNotifier,
+  _stopProfilerIdleNotifier,
+  stdout,
+  stdin,
+  stderr,
+  abort,
+  umask,
+  chdir,
+  cwd,
+  env,
+  title,
+  argv,
+  execArgv,
+  pid,
+  ppid,
+  execPath,
+  debugPort,
+  hrtime,
+  argv0,
+  _preload_modules,
+  setSourceMapsEnabled,
+};
+
+export default process;

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

@@ -0,0 +1,8 @@
+import punycode from 'punycode';
+export default punycode;
+export var decode = punycode.decode;
+export var encode = punycode.encode;
+export var toASCII = punycode.toASCII;
+export var toUnicode = punycode.toUnicode;
+export var ucs2 = punycode.ucs2;
+export var version = punycode.version;

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

@@ -0,0 +1,6 @@
+import querystring from 'querystring';
+export default querystring;
+export var decode = querystring.decode;
+export var encode = querystring.encode;
+export var parse = querystring.parse;
+export var stringify = querystring.stringify;

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

@@ -0,0 +1,23 @@
+function unimplemented () {
+  throw new Error('Node.js readline module is not supported by JSPM core outside of Node.js');
+}
+
+export default {
+  Interface: unimplemented,
+  clearLine: unimplemented,
+  clearScreenDown: unimplemented,
+  createInterface: unimplemented,
+  cursorTo: unimplemented,
+  emitKeypressEvents: unimplemented,
+  moveCursor: unimplemented
+};
+
+export {
+  unimplemented as Interface,
+  unimplemented as clearLine,
+  unimplemented as clearScreenDown,
+  unimplemented as createInterface,
+  unimplemented as cursorTo,
+  unimplemented as emitKeypressEvents,
+  unimplemented as moveCursor
+}

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

@@ -0,0 +1,26 @@
+function unimplemented () {
+  throw new Error('Node.js repl module is not supported by JSPM core in the browser');
+}
+
+export default {
+  writer: unimplemented,
+  _builtinLibs: null,
+  REPLServer: unimplemented,
+  REPL_MODE_SLOPPY: null,
+  REPL_MODE_STRICT: null,
+  start: unimplemented,
+  Recoverable: unimplemented,
+  repl: null
+};
+
+export var _builtinLibs = null,
+  REPL_MODE_SLOPPY = null,
+  REPL_MODE_STRICT = null,
+  repl = null;
+
+export {
+  unimplemented as writer,
+  unimplemented as REPLServer,
+  unimplemented as start,
+  unimplemented as Recoverable,
+}

package/node_modules/@jspm/core/src-browser/stream/consumers.js

@@ -0,0 +1,57 @@
+// no need to lazy load this, because if stream/consumers are used, buffer has necessarily already been imported.
+import { Buffer } from '../buffer.js';
+
+// https://github.com/nodejs/node/blob/449147ebab8d91e5326b839a1ae61e45b1e73582/lib/stream/consumers.js
+
+export async function blob(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return new Blob(chunks);
+}
+
+export async function arrayBuffer(stream) {
+  if (Blob.prototype.arrayBuffer) {
+    const blob = await blob(stream);
+    return blob.arrayBuffer();
+  }
+  // Firefox Android or Opera don't support arrayBuffer()
+  const chunks = [];
+  for await (const chunk of stream) {
+    try {
+      chunks.push(Buffer.from(chunk));
+    } catch (_) {
+      chanks.push(Buffer.from(`${chunk}`))
+    }
+  }
+  return Buffer.concat(chunks).buffer;
+}
+
+export async function buffer(stream) {
+  return Buffer.from(await arrayBuffer(stream));
+}
+
+export async function text(stream) {
+  const dec = new TextDecoder();
+  let str = '';
+  for await (const chunk of stream) {
+    if (typeof chunk === 'string')
+      str += chunk;
+    else
+      str += dec.decode(chunk, { stream: true });
+  }
+  str += dec.decode(undefined, { stream: false });
+  return str;
+}
+
+export async function json(stream) {
+  return JSON.parse(await text(stream));
+}
+
+export default {
+  blob,
+  arrayBuffer,
+  buffer,
+  text,
+  json,
+}

package/node_modules/@jspm/core/src-browser/stream/promises.js

@@ -0,0 +1,4 @@
+import { promises } from '../stream.js';
+
+export const { finished, pipeline } = promises;
+export default promises;

package/node_modules/@jspm/core/src-browser/stream/web.js

@@ -0,0 +1,33 @@
+export const ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy;
+export const CountQueuingStrategy = globalThis.CountQueuingStrategy;
+export const ReadableByteStreamController = globalThis.ReadableByteStreamController;
+export const ReadableStreamBYOBReader = globalThis.ReadableStreamBYOBReader;
+export const ReadableStreamBYOBRequest = globalThis.ReadableStreamBYOBRequest;
+export const ReadableStream = globalThis.ReadableStream;
+export const ReadableStreamDefaultController = globalThis.ReadableStreamDefaultController;
+export const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader;
+export const TextDecoderStream = globalThis.TextDecoderStream;
+export const TextEncoderStream = globalThis.TextEncoderStream;
+export const TransformStream = globalThis.TransformStream;
+export const TransformStreamDefaultController = globalThis.TransformStreamDefaultController;
+export const WritableStream = globalThis.WritableStream;
+export const WritableStreamDefaultController = globalThis.WritableStreamDefaultController;
+export const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter;
+
+export default {
+  ReadableStream,
+  ReadableStreamDefaultReader,
+  ReadableStreamBYOBReader,
+  ReadableStreamBYOBRequest,
+  ReadableByteStreamController,
+  ReadableStreamDefaultController,
+  TransformStream,
+  TransformStreamDefaultController,
+  WritableStream,
+  WritableStreamDefaultWriter,
+  WritableStreamDefaultController,
+  ByteLengthQueuingStrategy,
+  CountQueuingStrategy,
+  TextEncoderStream,
+  TextDecoderStream,
+}

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

@@ -0,0 +1,26 @@
+import stream from 'readable-stream';
+import { promisify } from './util.js';
+export default stream;
+
+export var Readable = stream.Readable;
+Readable.wrap = function(src, options) {
+  options = Object.assign({ objectMode: src.readableObjectMode != null || src.objectMode != null || true }, options);
+  options.destroy = function(err, callback) {
+    src.destroy(err);
+    callback(err);
+  };
+  return new Readable(options).wrap(src);
+};
+
+export var Writable = stream.Writable;
+export var Duplex = stream.Duplex;
+export var Transform = stream.Transform;
+export var PassThrough = stream.PassThrough;
+export var finished = stream.finished;
+export var pipeline = stream.pipeline;
+export var Stream = stream.Stream;
+
+export const promises = {
+  finished: promisify(stream.finished),
+  pipeline: promisify(stream.pipeline)
+}

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

@@ -0,0 +1,3 @@
+import string_decoder from 'string_decoder';
+export default string_decoder;
+export var StringDecoder = string_decoder.StringDecoder;

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

@@ -0,0 +1,3 @@
+import util from './util.js';
+export * from './util.js';
+export default util;

package/node_modules/@jspm/core/src-browser/timers/promises.js

@@ -0,0 +1,12 @@
+import { promisify } from '../util.js';
+import timers from '../timers.js';
+
+export const setTimeout = promisify(timers.setTimeout),
+  setImmediate = promisify(timers.setImmediate),
+  setInterval = promisify(timers.setInterval);
+
+export default {
+  setTimeout,
+  setImmediate,
+  setInterval
+};

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

@@ -0,0 +1,13 @@
+import timers from 'timers-browserify';
+export default timers;
+
+export var _unrefActive = timers._unrefActive;
+export var active = timers.active;
+export var clearImmediate = timers.clearImmediate;
+export var clearInterval = timers.clearInterval;
+export var clearTimeout = timers.clearTimeout;
+export var enroll = timers.enroll;
+export var setImmediate = timers.setImmediate;
+export var setInterval = timers.setInterval;
+export var setTimeout = timers.setTimeout;
+export var unenroll = timers.unenroll;

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

@@ -0,0 +1,46 @@
+function unimplemented () {
+  throw new Error('Node.js tls module is not supported by JSPM core outside of Node.js');
+}
+
+export default {
+  CLIENT_RENEG_LIMIT: null,
+  CLIENT_RENEG_WINDOW: null,
+  DEFAULT_CIPHERS: null,
+  DEFAULT_ECDH_CURVE: null,
+  DEFAULT_MIN_VERSION: null,
+  DEFAULT_MAX_VERSION: null,
+  getCiphers: unimplemented,
+  rootCertificates: null,
+  convertALPNProtocols: unimplemented,
+  checkServerIdentity: unimplemented,
+  parseCertString: unimplemented,
+  createSecureContext: unimplemented,
+  SecureContext: unimplemented,
+  TLSSocket: unimplemented,
+  Server: unimplemented,
+  createServer: unimplemented,
+  connect: unimplemented,
+  createSecurePair: unimplemented
+};
+
+export var CLIENT_RENEG_LIMIT = null,
+  CLIENT_RENEG_WINDOW = null,
+  DEFAULT_CIPHERS = null,
+  DEFAULT_ECDH_CURVE = null,
+  DEFAULT_MIN_VERSION = null,
+  DEFAULT_MAX_VERSION = null,
+  rootCertificates = null;
+
+export {
+  unimplemented as getCiphers,
+  unimplemented as convertALPNProtocols,
+  unimplemented as checkServerIdentity,
+  unimplemented as parseCertString,
+  unimplemented as createSecureContext,
+  unimplemented as SecureContext,
+  unimplemented as TLSSocket,
+  unimplemented as Server,
+  unimplemented as createServer,
+  unimplemented as connect,
+  unimplemented as createSecurePair
+}

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

@@ -0,0 +1,3 @@
+export * from './__tty.js';
+import * as m from './__tty.js';
+export default m;