first

node_modules/@babel/core/lib/gensync-utils/async.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.forwardAsync = forwardAsync;
+exports.isAsync = void 0;
+exports.isThenable = isThenable;
+exports.maybeAsync = maybeAsync;
+exports.waitFor = exports.onFirstPause = void 0;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const runGenerator = _gensync()(function* (item) {
+  return yield* item;
+});
+const isAsync = _gensync()({
+  sync: () => false,
+  errback: cb => cb(null, true)
+});
+exports.isAsync = isAsync;
+function maybeAsync(fn, message) {
+  return _gensync()({
+    sync(...args) {
+      const result = fn.apply(this, args);
+      if (isThenable(result)) throw new Error(message);
+      return result;
+    },
+    async(...args) {
+      return Promise.resolve(fn.apply(this, args));
+    }
+  });
+}
+const withKind = _gensync()({
+  sync: cb => cb("sync"),
+  async: function () {
+    var _ref = _asyncToGenerator(function* (cb) {
+      return cb("async");
+    });
+    return function async(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }()
+});
+function forwardAsync(action, cb) {
+  const g = _gensync()(action);
+  return withKind(kind => {
+    const adapted = g[kind];
+    return cb(adapted);
+  });
+}
+const onFirstPause = _gensync()({
+  name: "onFirstPause",
+  arity: 2,
+  sync: function (item) {
+    return runGenerator.sync(item);
+  },
+  errback: function (item, firstPause, cb) {
+    let completed = false;
+    runGenerator.errback(item, (err, value) => {
+      completed = true;
+      cb(err, value);
+    });
+    if (!completed) {
+      firstPause();
+    }
+  }
+});
+exports.onFirstPause = onFirstPause;
+const waitFor = _gensync()({
+  sync: x => x,
+  async: function () {
+    var _ref2 = _asyncToGenerator(function* (x) {
+      return x;
+    });
+    return function async(_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }()
+});
+exports.waitFor = waitFor;
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
+}
+0 && 0;
+
+//# sourceMappingURL=async.js.map

node_modules/@babel/core/lib/gensync-utils/fs.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stat = exports.readFile = void 0;
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+const readFile = _gensync()({
+  sync: _fs().readFileSync,
+  errback: _fs().readFile
+});
+exports.readFile = readFile;
+const stat = _gensync()({
+  sync: _fs().statSync,
+  errback: _fs().stat
+});
+exports.stat = stat;
+0 && 0;
+
+//# sourceMappingURL=fs.js.map

node_modules/@babel/core/lib/gensync-utils/fs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_fs","data","require","_gensync","readFile","gensync","sync","fs","readFileSync","errback","exports","stat","statSync"],"sources":["../../src/gensync-utils/fs.ts"],"sourcesContent":["import fs from \"fs\";\nimport gensync from \"gensync\";\n\nexport const readFile = gensync<[filepath: string, encoding: \"utf8\"], string>({\n  sync: fs.readFileSync,\n  errback: fs.readFile,\n});\n\nexport const stat = gensync({\n  sync: fs.statSync,\n  errback: fs.stat,\n});\n"],"mappings":";;;;;;AAAA,SAAAA,IAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,GAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,SAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,QAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,QAAQ,GAAGC,SAAMA,CAAC,CAA+C;EAC5EC,IAAI,EAAEC,IAACA,CAAC,CAACC,YAAY;EACrBC,OAAO,EAAEF,IAACA,CAAC,CAACH;AACd,CAAC,CAAC;AAACM,OAAA,CAAAN,QAAA,GAAAA,QAAA;AAEI,MAAMO,IAAI,GAAGN,SAAMA,CAAC,CAAC;EAC1BC,IAAI,EAAEC,IAACA,CAAC,CAACK,QAAQ;EACjBH,OAAO,EAAEF,IAACA,CAAC,CAACI;AACd,CAAC,CAAC;AAACD,OAAA,CAAAC,IAAA,GAAAA,IAAA;AAAA"}

node_modules/@babel/core/lib/gensync-utils/functional.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.once = once;
+var _async = require("./async");
+function once(fn) {
+  let result;
+  let resultP;
+  return function* () {
+    if (result) return result;
+    if (!(yield* (0, _async.isAsync)())) return result = yield* fn();
+    if (resultP) return yield* (0, _async.waitFor)(resultP);
+    let resolve, reject;
+    resultP = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    try {
+      result = yield* fn();
+      resultP = null;
+      resolve(result);
+      return result;
+    } catch (error) {
+      reject(error);
+      throw error;
+    }
+  };
+}
+0 && 0;
+
+//# sourceMappingURL=functional.js.map

node_modules/@babel/core/lib/gensync-utils/functional.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_async","require","once","fn","result","resultP","isAsync","waitFor","resolve","reject","Promise","res","rej","error"],"sources":["../../src/gensync-utils/functional.ts"],"sourcesContent":["import type { Handler } from \"gensync\";\n\nimport { isAsync, waitFor } from \"./async\";\n\nexport function once<R>(fn: () => Handler<R>): () => Handler<R> {\n  let result: R;\n  let resultP: Promise<R>;\n  return function* () {\n    if (result) return result;\n    if (!(yield* isAsync())) return (result = yield* fn());\n    if (resultP) return yield* waitFor(resultP);\n\n    let resolve: (result: R) => void, reject: (error: unknown) => void;\n    resultP = new Promise((res, rej) => {\n      resolve = res;\n      reject = rej;\n    });\n\n    try {\n      result = yield* fn();\n      // Avoid keeping the promise around\n      // now that we have the result.\n      resultP = null;\n      resolve(result);\n      return result;\n    } catch (error) {\n      reject(error);\n      throw error;\n    }\n  };\n}\n"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAEO,SAASC,IAAIA,CAAIC,EAAoB,EAAoB;EAC9D,IAAIC,MAAS;EACb,IAAIC,OAAmB;EACvB,OAAO,aAAa;IAClB,IAAID,MAAM,EAAE,OAAOA,MAAM;IACzB,IAAI,EAAE,OAAO,IAAAE,cAAO,EAAC,CAAC,CAAC,EAAE,OAAQF,MAAM,GAAG,OAAOD,EAAE,CAAC,CAAC;IACrD,IAAIE,OAAO,EAAE,OAAO,OAAO,IAAAE,cAAO,EAACF,OAAO,CAAC;IAE3C,IAAIG,OAA4B,EAAEC,MAAgC;IAClEJ,OAAO,GAAG,IAAIK,OAAO,CAAC,CAACC,GAAG,EAAEC,GAAG,KAAK;MAClCJ,OAAO,GAAGG,GAAG;MACbF,MAAM,GAAGG,GAAG;IACd,CAAC,CAAC;IAEF,IAAI;MACFR,MAAM,GAAG,OAAOD,EAAE,CAAC,CAAC;MAGpBE,OAAO,GAAG,IAAI;MACdG,OAAO,CAACJ,MAAM,CAAC;MACf,OAAOA,MAAM;IACf,CAAC,CAAC,OAAOS,KAAK,EAAE;MACdJ,MAAM,CAACI,KAAK,CAAC;MACb,MAAMA,KAAK;IACb;EACF,CAAC;AACH;AAAC"}