@jointhedots/gear 1.0.21 → 1.1.5

package/node_modules/@jspm/core/nodelibs/browser/module.js

@@ -0,0 +1,58 @@
+function unimplemented () {
+  throw new Error('Node.js module module is not supported by JSPM core in the browser');
+}
+
+var builtinModules = [
+  '_http_agent',         '_http_client',        '_http_common',
+  '_http_incoming',      '_http_outgoing',      '_http_server',
+  '_stream_duplex',      '_stream_passthrough', '_stream_readable',
+  '_stream_transform',   '_stream_wrap',        '_stream_writable',
+  '_tls_common',         '_tls_wrap',           'assert',
+  'assert/strict',       'async_hooks',         'buffer',
+  'child_process',       'cluster',             'console',
+  'constants',           'crypto',              'dgram',
+  'diagnostics_channel', 'dns',                 'dns/promises',
+  'domain',              'events',              'fs',
+  'fs/promises',         'http',                'http2',
+  'https',               'inspector',           'module',
+  'net',                 'os',                  'path',
+  'path/posix',          'path/win32',          'perf_hooks',
+  'process',             'punycode',            'querystring',
+  'readline',            'repl',                'stream',
+  'stream/consumers',    'stream/promises',     'stream/web',
+  'string_decoder',      'sys',                 'timers',
+  'timers/promises',     'tls',                 'trace_events',
+  'tty',                 'url',                 'util',
+  'util/types',          'v8',                  'vm',
+  'worker_threads',      'zlib'
+];
+
+var module = {
+  builtinModules: builtinModules,
+  _cache: null,
+  _pathCache: null,
+  _extensions: null,
+  globalPaths: null,
+  _debug: unimplemented,
+  _findPath: unimplemented,
+  _nodeModulePaths: unimplemented,
+  _resolveLookupPaths: unimplemented,
+  _load: unimplemented,
+  _resolveFilename: unimplemented,
+  createRequireFromPath: unimplemented,
+  createRequire: unimplemented,
+  _initPaths: unimplemented,
+  _preloadModules: unimplemented,
+  syncBuiltinESMExports: unimplemented,
+  Module: unimplemented,
+  runMain: unimplemented,
+  findSourceMap: unimplemented,
+  SourceMap: unimplemented
+};
+
+var _cache = null,
+  _pathCache = null,
+  _extensions = null,
+  globalPaths = null;
+
+export { unimplemented as Module, unimplemented as SourceMap, _cache, unimplemented as _debug, _extensions, unimplemented as _findPath, unimplemented as _initPaths, unimplemented as _load, unimplemented as _nodeModulePaths, _pathCache, unimplemented as _preloadModules, unimplemented as _resolveFilename, unimplemented as _resolveLookupPaths, builtinModules, unimplemented as createRequire, unimplemented as createRequireFromPath, module as default, unimplemented as findSourceMap, globalPaths, unimplemented as runMain, unimplemented as syncBuiltinESMExports };

package/node_modules/@jspm/core/nodelibs/browser/net.js

@@ -0,0 +1,20 @@
+function unimplemented () {
+  throw new Error('Node.js net module is not supported by JSPM core outside of Node.js');
+}
+
+var net = {
+  _createServerHandle: unimplemented,
+  _normalizeArgs: unimplemented,
+  _setSimultaneousAccepts: unimplemented,
+  connect: unimplemented,
+  createConnection: unimplemented,
+  createServer: unimplemented,
+  isIP: unimplemented,
+  isIPv4: unimplemented,
+  isIPv6: unimplemented,
+  Server: unimplemented,
+  Socket: unimplemented,
+  Stream: unimplemented
+};
+
+export { unimplemented as Server, unimplemented as Socket, unimplemented as Stream, unimplemented as _createServerHandle, unimplemented as _normalizeArgs, unimplemented as _setSimultaneousAccepts, unimplemented as connect, unimplemented as createConnection, unimplemented as createServer, net as default, unimplemented as isIP, unimplemented as isIPv4, unimplemented as isIPv6 };

package/node_modules/@jspm/core/nodelibs/browser/os.js

@@ -0,0 +1,94 @@
+import { uptime } from './process.js';
+
+var exports$1 = {},
+  _dewExec = false;
+function dew() {
+  if (_dewExec) return exports$1;
+  _dewExec = true;
+  exports$1.endianness = function () {
+    return "LE";
+  };
+  exports$1.hostname = function () {
+    if (typeof location !== "undefined") {
+      return location.hostname;
+    } else return "";
+  };
+  exports$1.loadavg = function () {
+    return [];
+  };
+  exports$1.uptime = function () {
+    return 0;
+  };
+  exports$1.freemem = function () {
+    return Number.MAX_VALUE;
+  };
+  exports$1.totalmem = function () {
+    return Number.MAX_VALUE;
+  };
+  exports$1.cpus = function () {
+    return [];
+  };
+  exports$1.type = function () {
+    return "Browser";
+  };
+  exports$1.release = function () {
+    if (typeof navigator !== "undefined") {
+      return navigator.appVersion;
+    }
+    return "";
+  };
+  exports$1.networkInterfaces = exports$1.getNetworkInterfaces = function () {
+    return {};
+  };
+  exports$1.arch = function () {
+    return "javascript";
+  };
+  exports$1.platform = function () {
+    return "browser";
+  };
+  exports$1.tmpdir = exports$1.tmpDir = function () {
+    return "/tmp";
+  };
+  exports$1.EOL = "\n";
+  exports$1.homedir = function () {
+    return "/";
+  };
+  return exports$1;
+}
+
+const exports = dew();
+exports['endianness']; exports['hostname']; exports['loadavg']; exports['uptime']; exports['freemem']; exports['totalmem']; exports['cpus']; exports['type']; exports['release']; exports['networkInterfaces']; exports['getNetworkInterfaces']; exports['arch']; exports['platform']; exports['tmpdir']; exports['tmpDir']; exports['EOL']; exports['homedir'];
+
+var _endianness = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1 ? 'LE' : 'BE';
+exports.endianness = function() { return _endianness; };
+exports.homedir = function() { return '/home'; };
+exports.version = function() { return ''; };
+exports.arch = function() { return 'x64'; };
+exports.totalmem = function() {
+  return navigator.deviceMemory !== undefined ? navigator.deviceMemory * (1 << 30) : 2 * (1 << 30);
+};
+exports.cpus = function () {
+  return Array(navigator.hardwareConcurrency || 0).fill({ model: '', times: {} });
+};
+exports.uptime = uptime;
+exports.constants = {};
+var version = exports.version;
+var constants = exports.constants;
+var EOL = exports.EOL;
+var arch = exports.arch;
+var cpus = exports.cpus;
+var endianness = exports.endianness;
+var freemem = exports.freemem;
+var getNetworkInterfaces = exports.getNetworkInterfaces;
+var homedir = exports.homedir;
+var hostname = exports.hostname;
+var loadavg = exports.loadavg;
+var networkInterfaces = exports.networkInterfaces;
+var platform = exports.platform;
+var release = exports.release;
+var tmpDir = exports.tmpDir;
+var tmpdir = exports.tmpdir;
+var totalmem = exports.totalmem;
+var type = exports.type;
+
+export { EOL, arch, constants, cpus, exports as default, endianness, freemem, getNetworkInterfaces, homedir, hostname, loadavg, networkInterfaces, platform, release, tmpDir, tmpdir, totalmem, type, uptime, version };

package/node_modules/@jspm/core/nodelibs/browser/path/posix.js

@@ -0,0 +1,40 @@
+import { posix as posix$1 } from '../path.js';
+import '../chunk-BlJi4mNy.js';
+import '../chunk-DEMDiNwt.js';
+
+const {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  _makeLong,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+  win32
+} = posix$1;
+
+var posix = {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  _makeLong,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+  posix: posix$1,
+  win32
+};
+
+export { _makeLong, basename, posix as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, posix$1 as posix, relative, resolve, sep, win32 };

package/node_modules/@jspm/core/nodelibs/browser/path/win32.js

@@ -0,0 +1,27 @@
+import { posix } from '../path.js';
+import '../chunk-BlJi4mNy.js';
+import '../chunk-DEMDiNwt.js';
+
+function unimplemented () {
+  throw new Error('Node.js path/win32 module is not supported by JSPM core in the browser');
+}
+
+const win32 = {
+  resolve: unimplemented,
+  normalize: unimplemented,
+  isAbsolute: unimplemented,
+  join: unimplemented,
+  relative: unimplemented,
+  _makeLong: unimplemented,
+  dirname: unimplemented,
+  basename: unimplemented,
+  extname: unimplemented,
+  format: unimplemented,
+  parse: unimplemented,
+  sep: unimplemented,
+  delimiter: unimplemented,
+  posix,
+};
+win32.win32 = win32;
+
+export { unimplemented as _makeLong, unimplemented as basename, win32 as default, unimplemented as delimiter, unimplemented as dirname, unimplemented as extname, unimplemented as format, unimplemented as isAbsolute, unimplemented as join, unimplemented as normalize, unimplemented as parse, posix, unimplemented as relative, unimplemented as resolve, unimplemented as sep, win32 };

package/node_modules/@jspm/core/nodelibs/browser/path.js

@@ -0,0 +1,20 @@
+import { e as exports } from './chunk-BlJi4mNy.js';
+import './chunk-DEMDiNwt.js';
+
+var _makeLong = exports._makeLong;
+var basename = exports.basename;
+var delimiter = exports.delimiter;
+var dirname = exports.dirname;
+var extname = exports.extname;
+var format = exports.format;
+var isAbsolute = exports.isAbsolute;
+var join = exports.join;
+var normalize = exports.normalize;
+var parse = exports.parse;
+var posix = exports.posix;
+var relative = exports.relative;
+var resolve = exports.resolve;
+var sep = exports.sep;
+var win32 = exports.win32;
+
+export { _makeLong, basename, exports as default, delimiter, dirname, extname, format, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, win32 };

package/node_modules/@jspm/core/nodelibs/browser/perf_hooks.js

@@ -0,0 +1,30 @@
+function unimplemented(functionName) {
+  throw new Error(
+    `Node.js performance method ${functionName} is not currently supported by JSPM core in the browser`
+  );
+}
+
+const PerformanceObserver = globalThis.PerformanceObserver;
+const constants = {};
+
+const performance = {
+  clearMarks: globalThis.performance.clearMarks,
+  eventLoopUtilization: () => unimplemented("eventLoopUtilization"),
+  mark: globalThis.performance.mark,
+  measure: globalThis.performance.measure,
+  nodeTiming: {},
+  now: globalThis.performance.now,
+  timeOrigin: globalThis.performance.timeOrigin,
+  timerify: () => unimplemented("timerify"),
+};
+
+const monitorEventLoopDelay = () => unimplemented("monitorEventLoopDelay");
+
+var perf_hooks = {
+  performance,
+  PerformanceObserver,
+  monitorEventLoopDelay,
+  constants,
+};
+
+export { PerformanceObserver, constants, perf_hooks as default, monitorEventLoopDelay, performance };

package/node_modules/@jspm/core/nodelibs/browser/process-production.js

@@ -0,0 +1,274 @@
+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);
+}
+
+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);
+};
+
+var title = 'browser';
+var arch = 'x64';
+var platform = 'browser';
+var env = {
+  NODE_ENV: 'production',
+  PATH: '/usr/bin',
+  LANG: typeof navigator !== 'undefined' ? navigator.language + '.UTF-8' : undefined,
+  PWD: '/',
+  HOME: '/home',
+  TMP: '/tmp'
+};
+var argv = ['/usr/bin/node'];
+var execArgv = [];
+var version = 'v16.8.0';
+var versions = {};
+
+var emitWarning = function(message, type) {
+  console.warn((type ? (type + ': ') : '') + message);
+};
+
+var binding = null;
+
+var umask = function(mask) { return 0; };
+
+var cwd = function() { return '/'; };
+var chdir = function(dir) {};
+
+var release = {
+  name: 'node',
+  sourceUrl: '',
+  headersUrl: '',
+  libUrl: '',
+};
+
+function noop() {}
+
+var browser = true;
+var _rawDebug = noop;
+var moduleLoadList = [];
+var _linkedBinding = null;
+var domain = {};
+var _exiting = false;
+var config = {};
+var dlopen = null;
+function _getActiveRequests() { return []; }
+function _getActiveHandles() { return []; }
+var reallyExit = noop;
+var _kill = noop;
+var cpuUsage = function() { return {}; };
+var resourceUsage = cpuUsage;
+var memoryUsage = cpuUsage;
+var kill = noop;
+var exit = noop;
+var openStdin = noop;
+var allowedNodeEnvironmentFlags = {};
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'assertion error');
+}
+var features = {
+  inspector: false,
+  debug: false,
+  uv: false,
+  ipv6: false,
+  tls_alpn: false,
+  tls_sni: false,
+  tls_ocsp: false,
+  tls: false,
+  cached_builtins: true,
+};
+var _fatalExceptions = noop;
+var setUncaughtExceptionCaptureCallback = noop;
+function hasUncaughtExceptionCaptureCallback() { return false; }var _tickCallback = noop;
+var _debugProcess = noop;
+var _debugEnd = noop;
+var _startProfilerIdleNotifier = noop;
+var _stopProfilerIdleNotifier = noop;
+var stdout = undefined;
+var stderr = undefined;
+var stdin = undefined;
+var abort = noop;
+var pid = 2;
+var ppid = 1;
+var execPath = '/bin/usr/node';
+var debugPort = 9229;
+var argv0 = 'node';
+var _preload_modules = [];
+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;
+}
+
+function uptime() {
+  return _performance.now() / 1000;
+}
+
+var nanoPerSec = 1000000000;
+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]);
+};
+
+var _maxListeners = 10;
+var _events = {};
+var _eventsCount = 0;
+function on () { return process }var addListener = on;
+var once = on;
+var off = on;
+var removeListener = on;
+var removeAllListeners = on;
+var emit = noop;
+var prependListener = on;
+var prependOnceListener = on;
+function listeners () { 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 { _debugEnd, _debugProcess, _events, _eventsCount, _exiting, _fatalExceptions, _getActiveHandles, _getActiveRequests, _kill, _linkedBinding, _maxListeners, _preload_modules, _rawDebug, _startProfilerIdleNotifier, _stopProfilerIdleNotifier, _tickCallback, abort, addListener, allowedNodeEnvironmentFlags, arch, argv, argv0, assert, binding, browser, chdir, config, cpuUsage, cwd, debugPort, process as default, dlopen, domain, emit, emitWarning, env, execArgv, execPath, exit, features, hasUncaughtExceptionCaptureCallback, hrtime, kill, listeners, memoryUsage, moduleLoadList, nextTick, off, on, once, openStdin, pid, platform, ppid, prependListener, prependOnceListener, reallyExit, release, removeAllListeners, removeListener, resourceUsage, setSourceMapsEnabled, setUncaughtExceptionCaptureCallback, stderr, stdin, stdout, title, umask, uptime, version, versions };