@jointhedots/gear 1.0.21 → 1.1.4

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

@@ -0,0 +1,33 @@
+function unimplemented () {
+  throw new Error('Node.js net module is not supported by JSPM core outside of Node.js');
+}
+
+export default {
+  _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 _createServerHandle,
+  unimplemented as _normalizeArgs,
+  unimplemented as _setSimultaneousAccepts,
+  unimplemented as connect,
+  unimplemented as createConnection,
+  unimplemented as createServer,
+  unimplemented as isIP,
+  unimplemented as isIPv4,
+  unimplemented as isIPv6,
+  unimplemented as Server,
+  unimplemented as Socket,
+  unimplemented as Stream
+}

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

@@ -0,0 +1,35 @@
+import os from 'os-browserify';
+import { uptime } from './process.js';
+var _endianness = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1 ? 'LE' : 'BE';
+os.endianness = function() { return _endianness; };
+os.homedir = function() { return '/home'; };
+os.version = function() { return ''; };
+os.arch = function() { return 'x64'; };
+os.totalmem = function() {
+  return navigator.deviceMemory !== undefined ? navigator.deviceMemory * (1 << 30) : 2 * (1 << 30);
+};
+os.cpus = function () {
+  return Array(navigator.hardwareConcurrency || 0).fill({ model: '', times: {} });
+};
+os.uptime = uptime;
+os.constants = {};
+export default os;
+export var version = os.version;
+export var constants = os.constants;
+export var EOL = os.EOL;
+export var arch = os.arch;
+export var cpus = os.cpus;
+export var endianness = os.endianness;
+export var freemem = os.freemem;
+export var getNetworkInterfaces = os.getNetworkInterfaces;
+export var homedir = os.homedir;
+export var hostname = os.hostname;
+export var loadavg = os.loadavg;
+export var networkInterfaces = os.networkInterfaces;
+export var platform = os.platform;
+export var release = os.release;
+export var tmpDir = os.tmpDir;
+export var tmpdir = os.tmpdir;
+export var totalmem = os.totalmem;
+export var type = os.type;
+export { uptime };

package/node_modules/@jspm/core/src-browser/path/posix.js

@@ -0,0 +1,38 @@
+import { posix } from '../path.js';
+
+export const {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  _makeLong,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+  win32
+} = posix;
+
+export { posix }
+
+export default {
+  resolve,
+  normalize,
+  isAbsolute,
+  join,
+  relative,
+  _makeLong,
+  dirname,
+  basename,
+  extname,
+  format,
+  parse,
+  sep,
+  delimiter,
+  posix,
+  win32
+};

package/node_modules/@jspm/core/src-browser/path/win32.js

@@ -0,0 +1,42 @@
+import { posix } from './posix.js';
+
+function unimplemented () {
+  throw new Error('Node.js path/win32 module is not supported by JSPM core in the browser');
+}
+
+export {
+  unimplemented as resolve,
+  unimplemented as normalize,
+  unimplemented as isAbsolute,
+  unimplemented as join,
+  unimplemented as relative,
+  unimplemented as _makeLong,
+  unimplemented as dirname,
+  unimplemented as basename,
+  unimplemented as extname,
+  unimplemented as format,
+  unimplemented as parse,
+  unimplemented as sep,
+  unimplemented as delimiter,
+  posix
+}
+
+export 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 default win32;

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

@@ -0,0 +1,17 @@
+import path from 'path-browserify';
+export default path;
+export var _makeLong = path._makeLong;
+export var basename = path.basename;
+export var delimiter = path.delimiter;
+export var dirname = path.dirname;
+export var extname = path.extname;
+export var format = path.format;
+export var isAbsolute = path.isAbsolute;
+export var join = path.join;
+export var normalize = path.normalize;
+export var parse = path.parse;
+export var posix = path.posix;
+export var relative = path.relative;
+export var resolve = path.resolve;
+export var sep = path.sep;
+export var win32 = path.win32;

package/node_modules/@jspm/core/src-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");
+
+export default {
+  performance,
+  PerformanceObserver,
+  monitorEventLoopDelay,
+  constants,
+};
+
+export { PerformanceObserver, performance, constants, monitorEventLoopDelay };

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

@@ -0,0 +1,279 @@
+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 = {
+  NODE_ENV: 'production',
+  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 = null;
+
+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 var _linkedBinding = null;
+export var domain = {};
+export var _exiting = false;
+export var config = {};
+export var dlopen = null;
+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 () { 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;