@jointhedots/gear 1.0.21 → 1.1.4

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

@@ -0,0 +1,118 @@
+var exports$3 = {},
+  _dewExec$2 = false;
+function dew$2() {
+  if (_dewExec$2) return exports$3;
+  _dewExec$2 = true;
+  // If obj.hasOwnProperty has been overridden, then calling
+  // obj.hasOwnProperty(prop) will break.
+  // See: https://github.com/joyent/node/issues/1707
+  function hasOwnProperty(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+  }
+  exports$3 = function (qs, sep, eq, options) {
+    sep = sep || "&";
+    eq = eq || "=";
+    var obj = {};
+    if (typeof qs !== "string" || qs.length === 0) {
+      return obj;
+    }
+    var regexp = /\+/g;
+    qs = qs.split(sep);
+    var maxKeys = 1000;
+    if (options && typeof options.maxKeys === "number") {
+      maxKeys = options.maxKeys;
+    }
+    var len = qs.length;
+    // maxKeys <= 0 means that we should not limit keys count
+    if (maxKeys > 0 && len > maxKeys) {
+      len = maxKeys;
+    }
+    for (var i = 0; i < len; ++i) {
+      var x = qs[i].replace(regexp, "%20"),
+        idx = x.indexOf(eq),
+        kstr,
+        vstr,
+        k,
+        v;
+      if (idx >= 0) {
+        kstr = x.substr(0, idx);
+        vstr = x.substr(idx + 1);
+      } else {
+        kstr = x;
+        vstr = "";
+      }
+      k = decodeURIComponent(kstr);
+      v = decodeURIComponent(vstr);
+      if (!hasOwnProperty(obj, k)) {
+        obj[k] = v;
+      } else if (Array.isArray(obj[k])) {
+        obj[k].push(v);
+      } else {
+        obj[k] = [obj[k], v];
+      }
+    }
+    return obj;
+  };
+  return exports$3;
+}
+
+var exports$2 = {},
+  _dewExec$1 = false;
+function dew$1() {
+  if (_dewExec$1) return exports$2;
+  _dewExec$1 = true;
+  var stringifyPrimitive = function (v) {
+    switch (typeof v) {
+      case "string":
+        return v;
+      case "boolean":
+        return v ? "true" : "false";
+      case "number":
+        return isFinite(v) ? v : "";
+      default:
+        return "";
+    }
+  };
+  exports$2 = function (obj, sep, eq, name) {
+    sep = sep || "&";
+    eq = eq || "=";
+    if (obj === null) {
+      obj = undefined;
+    }
+    if (typeof obj === "object") {
+      return Object.keys(obj).map(function (k) {
+        var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+        if (Array.isArray(obj[k])) {
+          return obj[k].map(function (v) {
+            return ks + encodeURIComponent(stringifyPrimitive(v));
+          }).join(sep);
+        } else {
+          return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+        }
+      }).filter(Boolean).join(sep);
+    }
+    if (!name) return "";
+    return encodeURIComponent(stringifyPrimitive(name)) + eq + encodeURIComponent(stringifyPrimitive(obj));
+  };
+  return exports$2;
+}
+
+var exports$1 = {},
+  _dewExec = false;
+function dew() {
+  if (_dewExec) return exports$1;
+  _dewExec = true;
+  exports$1.decode = exports$1.parse = dew$2();
+  exports$1.encode = exports$1.stringify = dew$1();
+  return exports$1;
+}
+
+const exports = dew();
+exports['decode']; exports['parse']; exports['encode']; exports['stringify'];
+
+var decode = exports.decode;
+var encode = exports.encode;
+var parse = exports.parse;
+var stringify = exports.stringify;
+
+export { decode, exports as default, encode, parse, stringify };

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

@@ -0,0 +1,15 @@
+function unimplemented () {
+  throw new Error('Node.js readline module is not supported by JSPM core outside of Node.js');
+}
+
+var readline = {
+  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, readline as default, unimplemented as emitKeypressEvents, unimplemented as moveCursor };

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

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

package/node_modules/@jspm/core/nodelibs/browser/stream/consumers.js

@@ -0,0 +1,61 @@
+import { Buffer } from '../buffer.js';
+import '../chunk-DtuTasat.js';
+
+// no need to lazy load this, because if stream/consumers are used, buffer has necessarily already been imported.
+
+// https://github.com/nodejs/node/blob/449147ebab8d91e5326b839a1ae61e45b1e73582/lib/stream/consumers.js
+
+async function blob(stream) {
+  const chunks = [];
+  for await (const chunk of stream)
+    chunks.push(chunk);
+  return new Blob(chunks);
+}
+
+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;
+}
+
+async function buffer(stream) {
+  return Buffer.from(await arrayBuffer(stream));
+}
+
+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;
+}
+
+async function json(stream) {
+  return JSON.parse(await text(stream));
+}
+
+var consumers = {
+  blob,
+  arrayBuffer,
+  buffer,
+  text,
+  json,
+};
+
+export { arrayBuffer, blob, buffer, consumers as default, json, text };

package/node_modules/@jspm/core/nodelibs/browser/stream/promises.js

@@ -0,0 +1,12 @@
+import { promises } from '../stream.js';
+import '../chunk-DtuTasat.js';
+import '../events.js';
+import '../chunk-DEMDiNwt.js';
+import '../chunk-CcCWfKp1.js';
+import '../util.js';
+import '../chunk-DtcTpLWz.js';
+import '../chunk-CkFCi-G1.js';
+
+const { finished, pipeline } = promises;
+
+export { promises as default, finished, pipeline };

package/node_modules/@jspm/core/nodelibs/browser/stream/web.js

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