@jointhedots/gear 1.0.21 → 1.1.5

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

@@ -0,0 +1,45 @@
+function unimplemented () {
+  throw new Error('Node.js dns is not supported by JSPM core outside of Node.js');
+}
+
+export {
+  unimplemented as lookup,
+  unimplemented as lookupService,
+  unimplemented as Resolver,
+  unimplemented as getServers,
+  unimplemented as resolve,
+  unimplemented as resolve4,
+  unimplemented as resolve6,
+  unimplemented as resolveAny,
+  unimplemented as resolveCname,
+  unimplemented as resolveMx,
+  unimplemented as resolveNaptr,
+  unimplemented as resolveNs,
+  unimplemented as resolvePtr,
+  unimplemented as resolveSoa,
+  unimplemented as resolveSrv,
+  unimplemented as resolveTxt,
+  unimplemented as reverse,
+  unimplemented as setServers
+};
+
+export default {
+  lookup: unimplemented,
+  lookupService: unimplemented,
+  Resolver: unimplemented,
+  getServers: unimplemented,
+  resolve: unimplemented,
+  resolve4: unimplemented,
+  resolve6: unimplemented,
+  resolveAny: unimplemented,
+  resolveCname: unimplemented,
+  resolveMx: unimplemented,
+  resolveNaptr: unimplemented,
+  resolveNs: unimplemented,
+  resolvePtr: unimplemented,
+  resolveSoa: unimplemented,
+  resolveSrv: unimplemented,
+  resolveTxt: unimplemented,
+  reverse: unimplemented,
+  setServers: unimplemented
+};

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

@@ -0,0 +1,121 @@
+function unimplemented () {
+  throw new Error('Node.js dns is not supported by JSPM core outside of Node.js');
+}
+
+var promises = {
+  lookup: unimplemented,
+  lookupService: unimplemented,
+  Resolver: unimplemented,
+  getServers: unimplemented,
+  resolve: unimplemented,
+  resolve4: unimplemented,
+  resolve6: unimplemented,
+  resolveAny: unimplemented,
+  resolveCname: unimplemented,
+  resolveMx: unimplemented,
+  resolveNaptr: unimplemented,
+  resolveNs: unimplemented,
+  resolvePtr: unimplemented,
+  resolveSoa: unimplemented,
+  resolveSrv: unimplemented,
+  resolveTxt: unimplemented,
+  reverse: unimplemented,
+  setServers: unimplemented
+};
+
+export default {
+  lookup: unimplemented,
+  lookupService: unimplemented,
+  Resolver: unimplemented,     
+  setServers: unimplemented,   
+  ADDRCONFIG: null,
+  V4MAPPED: null,
+  NODATA: null,
+  FORMERR: null,
+  SERVFAIL: null,
+  NOTFOUND: null,
+  NOTIMP: null,
+  REFUSED: null,
+  BADQUERY: null,
+  BADNAME: null,
+  BADFAMILY: null,
+  BADRESP: null,
+  CONNREFUSED: null,
+  TIMEOUT: null,
+  EOF: null,
+  FILE: null,
+  NOMEM: null,
+  DESTRUCTION: null,
+  BADSTR: null,
+  BADFLAGS: null,
+  NONAME: null,
+  BADHINTS: null,
+  NOTINITIALIZED: null,
+  LOADIPHLPAPI: null,
+  ADDRGETNETWORKPARAMS: null,
+  CANCELLED: null,
+  getServers: unimplemented,
+  resolve: unimplemented,
+  resolve4: unimplemented,
+  resolve6: unimplemented,
+  resolveAny: unimplemented,
+  resolveCname: unimplemented,
+  resolveMx: unimplemented,
+  resolveNaptr: unimplemented,
+  resolveNs: unimplemented,
+  resolvePtr: unimplemented,
+  resolveSoa: unimplemented,
+  resolveSrv: unimplemented,
+  resolveTxt: unimplemented,
+  reverse: unimplemented,
+  promises: promises
+};
+
+export var ADDRCONFIG = null,
+  V4MAPPED = null,
+  NODATA = null,
+  FORMERR = null, 
+  SERVFAIL = null,
+  NOTFOUND = null,
+  NOTIMP = null,
+  REFUSED = null,
+  BADQUERY = null,
+  BADNAME = null,
+  BADFAMILY = null,
+  BADRESP = null,
+  CONNREFUSED = null,
+  TIMEOUT = null,
+  EOF = null,
+  FILE = null,
+  NOMEM = null,
+  DESTRUCTION = null,
+  BADSTR = null,
+  BADFLAGS = null,
+  NONAME = null,
+  BADHINTS = null,
+  NOTINITIALIZED = null,
+  LOADIPHLPAPI = null,
+  ADDRGETNETWORKPARAMS = null,
+  CANCELLED = null;
+
+export {
+  unimplemented as lookup,
+  unimplemented as lookupService,
+  unimplemented as Resolver,
+  unimplemented as setServers,
+  unimplemented as getServers,
+  unimplemented as resolve,
+  unimplemented as resolve4,
+  unimplemented as resolve6,
+  unimplemented as resolveAny,
+  unimplemented as resolveCname,
+  unimplemented as resolveMx,
+  unimplemented as resolveNaptr,
+  unimplemented as resolveNs,
+  unimplemented as resolvePtr,
+  unimplemented as resolveSoa,
+  unimplemented as resolveSrv,
+  unimplemented as resolveTxt,
+  unimplemented as reverse,
+  promises
+}

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

@@ -0,0 +1,4 @@
+import domain from 'domain-browser';
+export default domain;
+export var create = domain.create;
+export var createDomain = domain.createDomain;

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

@@ -0,0 +1,105 @@
+import events from 'events';
+// https://github.com/denoland/deno_std/blob/d005433c709054af87aca54f57a446b4f7966f11/node/events.ts#L501-L638
+events.once = function (emitter, event) {
+  return new Promise((resolve, reject) => {
+    function eventListener(...args) {
+      if (errorListener !== undefined) {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve(args);
+    };
+
+    let errorListener;
+    if (event !== 'error') {
+      // deno-lint-ignore no-explicit-any
+      errorListener = (err) => {
+        emitter.removeListener(name, eventListener);
+        reject(err);
+      };
+
+      emitter.once('error', errorListener);
+    }
+
+    emitter.once(event, eventListener);
+  });
+};
+events.on = function (emitter, event) {
+  const unconsumedEventValues = [];
+  const unconsumedPromises = [];
+  let error = null;
+  let finished = false;
+
+  const iterator = {
+    async next() {
+      const value = unconsumedEventValues.shift();
+      if (value) {
+        return createIterResult(value, false);
+      }
+
+      if (error) {
+        const p = Promise.reject(error);
+        error = null;
+        return p;
+      }
+
+      if (finished) {
+        return createIterResult(undefined, true);
+      }
+
+      return new Promise((resolve, reject) => unconsumedPromises.push({ resolve, reject }));
+    },
+    async return() {
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener('error', errorHandler);
+      finished = true;
+
+      for (const promise of unconsumedPromises) {
+        promise.resolve(createIterResult(undefined, true));
+      }
+
+      return createIterResult(undefined, true);
+    },
+    throw(err) {
+      error = err;
+      emitter.removeListener(event, eventHandler);
+      emitter.removeListener('error', errorHandler);
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  emitter.on(event, eventHandler);
+  emitter.on('error', errorHandler);
+
+  return iterator;
+
+  function eventHandler(...args) {
+    const promise = unconsumedPromises.shift();
+    if (promise) {
+      promise.resolve(createIterResult(args, false));
+    } else {
+      unconsumedEventValues.push(args);
+    }
+  }
+
+  function errorHandler(err) {
+    finished = true;
+    const toError = unconsumedPromises.shift();
+    if (toError) {
+      toError.reject(err);
+    } else {
+      error = err;
+    }
+    iterator.return();
+  }
+}
+export default events;
+export const {
+  EventEmitter,
+  defaultMaxListeners,
+  init,
+  listenerCount,
+  on,
+  once,
+} = events;

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

@@ -0,0 +1,34 @@
+import { promises } from '../fs.js';
+
+export const {
+  access,
+  copyFile,
+  cp,
+  open,
+  opendir,
+  rename,
+  truncate,
+  rm,
+  rmdir,
+  mkdir,
+  readdir,
+  readlink,
+  symlink,
+  lstat,
+  stat,
+  link,
+  unlink,
+  chmod,
+  lchmod,
+  lchown,
+  chown,
+  utimes,
+  realpath,
+  mkdtemp,
+  writeFile,
+  appendFile,
+  readFile,
+  watch,
+} = promises;
+
+export default promises;

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

@@ -0,0 +1,209 @@
+import memfs from 'memfs';
+import volume from 'memfs/lib/volume.js';
+const { vol, createFsFromVolume } = memfs;
+import { Buffer } from './buffer.js';
+import { fileURLToPath } from './url.js';
+
+function unimplemented(name) {
+  throw new Error(`Node.js fs ${name} is not supported by JSPM core in the browser`);
+}
+
+vol.fromNestedJSON({
+  '/dev': { stdin: '', stdout: '', stderr: '' },
+  '/usr/bin': {},
+  '/home': {},
+  '/tmp': {},
+});
+
+vol.releasedFds = [2, 1, 0];
+vol.openSync('/dev/stdin', 'w');
+vol.openSync('/dev/stdout', 'r');
+vol.openSync('/dev/stderr', 'r');
+watchStdo('/dev/stdout', 1, console.log);
+watchStdo('/dev/stderr', 2, console.error);
+function watchStdo(path, fd, listener) {
+  let oldSize = 0;
+  const decoder = new TextDecoder();
+  vol.watch(path, 'utf8', () => {
+    const { size } = vol.fstatSync(fd);
+    const buf = Buffer.alloc(size - oldSize);
+    vol.readSync(fd, buf, 0, buf.length, oldSize);
+    oldSize = size;
+    listener(decoder.decode(buf, { stream: true }));
+  });
+}
+
+const fs = createFsFromVolume(vol);
+
+fs.opendir = () => unimplemented('opendir');
+fs.opendirSync = () => unimplemented('opendirSync');
+fs.promises.opendir = () => unimplemented('promises.opendir');
+fs.cp = () => unimplemented('cp');
+fs.cpSync = () => unimplemented('cpSync');
+fs.promises.cp = () => unimplemented('promises.cp');
+fs.readv = () => unimplemented('readv');
+fs.readvSync = () => unimplemented('readvSync');
+fs.rm = () => unimplemented('rm');
+fs.rmSync = () => unimplemented('rmSync');
+fs.promises.rm = () => unimplemented('promises.rm');
+fs.Dir = () => unimplemented('Dir');
+fs.promises.watch = () => unimplemented('promises.watch');
+
+fs.FileReadStream = fs.ReadStream;
+fs.FileWriteStream = fs.WriteStream;
+
+function handleFsUrl (url, isSync) {
+  if (url.protocol === 'file:')
+    return fileURLToPath(url);
+  if (url.protocol === 'https:' || url.protocol === 'http:') {
+    const path = '\\\\url\\' + url.href.replaceAll(/\//g, '\\\\');
+    if (existsSync(path))
+      return path;
+    if (isSync)
+      throw new Error(`Cannot sync request URL ${url} via FS. JSPM FS support for network URLs requires using async FS methods or priming the MemFS cache first with an async request before a sync request.`);
+    return (async () => {
+      const res = await fetch(url);
+      if (!res.ok)
+        throw new Error(`Unable to fetch ${url.href}, ${res.status}`);
+      const buf = await res.arrayBuffer();
+      writeFileSync(path, Buffer.from(buf));
+      return path;
+    })();
+  }
+  throw new Error('URL ' + url + ' not supported in JSPM FS implementation.');
+}
+
+function wrapFsSync (fn) {
+  return function (path, ...args) {
+    if (path instanceof URL)
+      return fn(handleFsUrl(path, true), ...args);
+    return fn(path, ...args);
+  };
+}
+
+function wrapFsPromise (fn) {
+  return async function (path, ...args) {
+    if (path instanceof URL)
+      return fn(await handleFsUrl(path), ...args);
+    return fn(path, ...args);
+  };
+}
+
+function wrapFsCallback (fn) {
+  return function (path, ...args) {
+    const cb = args[args.length - 1];
+    if (path instanceof URL && typeof cb === 'function') {
+      handleFsUrl(path).then(path => {
+        fn(path, ...args);
+      }, cb);
+    }
+    else {
+      fn(path, ...args);
+    }
+  }; 
+}
+
+fs.promises.readFile = wrapFsPromise(fs.promises.readFile);
+fs.readFile = wrapFsCallback(fs.readFile);
+fs.readFileSync = wrapFsSync(fs.readFileSync);
+
+export const {
+  appendFile,
+  appendFileSync,
+  access,
+  accessSync,
+  chown,
+  chownSync,
+  chmod,
+  chmodSync,
+  close,
+  closeSync,
+  copyFile,
+  copyFileSync,
+  cp,
+  cpSync,
+  createReadStream,
+  createWriteStream,
+  exists,
+  existsSync,
+  fchown,
+  fchownSync,
+  fchmod,
+  fchmodSync,
+  fdatasync,
+  fdatasyncSync,
+  fstat,
+  fstatSync,
+  fsync,
+  fsyncSync,
+  ftruncate,
+  ftruncateSync,
+  futimes,
+  futimesSync,
+  lchown,
+  lchownSync,
+  lchmod,
+  lchmodSync,
+  link,
+  linkSync,
+  lstat,
+  lstatSync,
+  mkdir,
+  mkdirSync,
+  mkdtemp,
+  mkdtempSync,
+  open,
+  openSync,
+  opendir,
+  opendirSync,
+  readdir,
+  readdirSync,
+  read,
+  readSync,
+  readv,
+  readvSync,
+  readFile,
+  readFileSync,
+  readlink,
+  readlinkSync,
+  realpath,
+  realpathSync,
+  rename,
+  renameSync,
+  rm,
+  rmSync,
+  rmdir,
+  rmdirSync,
+  stat,
+  statSync,
+  symlink,
+  symlinkSync,
+  truncate,
+  truncateSync,
+  unwatchFile,
+  unlink,
+  unlinkSync,
+  utimes,
+  utimesSync,
+  watch,
+  watchFile,
+  writeFile,
+  writeFileSync,
+  write,
+  writeSync,
+  writev,
+  writevSync,
+  Dir,
+  Dirent,
+  Stats,
+  ReadStream,
+  WriteStream,
+  FileReadStream,
+  FileWriteStream,
+  _toUnixTimestamp,
+  constants: { F_OK, R_OK, W_OK, X_OK },
+  constants,
+  promises,
+} = fs;
+
+export default fs;

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

@@ -0,0 +1,10 @@
+import http from 'stream-http';
+export default http;
+export var Agent = http.Agent;
+export var ClientRequest = http.ClientRequest;
+export var IncomingMessage = http.IncomingMessage;
+export var METHODS = http.METHODS;
+export var STATUS_CODES = http.STATUS_CODES;
+export var get = http.get;
+export var globalAgent = http.globalAgent;
+export var request = http.request;

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

@@ -0,0 +1,86 @@
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+
+function unimplemented(name) {
+  throw new Error(
+    `Node.js HTTP/2 ${name} is not currently supported by JSPM core in Deno`,
+  );
+}
+
+export class Http2Session {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class ServerHttp2Session {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class ClientHttp2Session {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class Http2Stream {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class ClientHttp2Stream {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class ServerHttp2Stream {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class Http2Server {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class Http2SecureServer {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export function createServer() {}
+export function createSecureServer() {}
+export function connect() {}
+export const constants = {};
+export function getDefaultSettings() {}
+export function getPackedSettings() {}
+export function getUnpackedSettings() {}
+export const sensitiveHeaders = Symbol("nodejs.http2.sensitiveHeaders");
+export class Http2ServerRequest {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export class Http2ServerResponse {
+  constructor() {
+    unimplemented(this.constructor.name);
+  }
+}
+export default {
+  Http2Session,
+  ServerHttp2Session,
+  ClientHttp2Session,
+  Http2Stream,
+  ClientHttp2Stream,
+  ServerHttp2Stream,
+  Http2Server,
+  Http2SecureServer,
+  createServer,
+  createSecureServer,
+  connect,
+  constants,
+  getDefaultSettings,
+  getPackedSettings,
+  getUnpackedSettings,
+  sensitiveHeaders,
+  Http2ServerRequest,
+  Http2ServerResponse,
+};

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

@@ -0,0 +1,10 @@
+import https from 'https-browserify';
+export default https;
+export var Agent = https.Agent;
+export var ClientRequest = https.ClientRequest;
+export var IncomingMessage = https.IncomingMessage;
+export var METHODS = https.METHODS;
+export var STATUS_CODES = https.STATUS_CODES;
+export var get = https.get;
+export var globalAgent = https.globalAgent;
+export var request = https.request;

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

@@ -0,0 +1,75 @@
+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'
+];
+
+export default {
+  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
+};
+
+export var _cache = null,
+  _pathCache = null,
+  _extensions = null,
+  globalPaths = null;
+
+export {
+  builtinModules,
+  unimplemented as _debug,
+  unimplemented as _findPath,
+  unimplemented as _nodeModulePaths,
+  unimplemented as _resolveLookupPaths,
+  unimplemented as _load,
+  unimplemented as _resolveFilename,
+  unimplemented as createRequireFromPath,
+  unimplemented as createRequire,
+  unimplemented as _initPaths,
+  unimplemented as _preloadModules,
+  unimplemented as syncBuiltinESMExports,
+  unimplemented as Module,
+  unimplemented as runMain,
+  unimplemented as findSourceMap,
+  unimplemented as SourceMap
+}