@tachybase/module-pdf 0.23.8

package/dist/node_modules/@babel/core/lib/errors/rewrite-stack-trace.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.beginHiddenCallStack = beginHiddenCallStack;
+exports.endHiddenCallStack = endHiddenCallStack;
+exports.expectedError = expectedError;
+exports.injectVirtualStackFrame = injectVirtualStackFrame;
+var _Object$getOwnPropert;
+const ErrorToString = Function.call.bind(Error.prototype.toString);
+const SUPPORTED = !!Error.captureStackTrace && ((_Object$getOwnPropert = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit")) == null ? void 0 : _Object$getOwnPropert.writable) === true;
+const START_HIDING = "startHiding - secret - don't use this - v1";
+const STOP_HIDING = "stopHiding - secret - don't use this - v1";
+const expectedErrors = new WeakSet();
+const virtualFrames = new WeakMap();
+function CallSite(filename) {
+  return Object.create({
+    isNative: () => false,
+    isConstructor: () => false,
+    isToplevel: () => true,
+    getFileName: () => filename,
+    getLineNumber: () => undefined,
+    getColumnNumber: () => undefined,
+    getFunctionName: () => undefined,
+    getMethodName: () => undefined,
+    getTypeName: () => undefined,
+    toString: () => filename
+  });
+}
+function injectVirtualStackFrame(error, filename) {
+  if (!SUPPORTED) return;
+  let frames = virtualFrames.get(error);
+  if (!frames) virtualFrames.set(error, frames = []);
+  frames.push(CallSite(filename));
+  return error;
+}
+function expectedError(error) {
+  if (!SUPPORTED) return;
+  expectedErrors.add(error);
+  return error;
+}
+function beginHiddenCallStack(fn) {
+  if (!SUPPORTED) return fn;
+  return Object.defineProperty(function (...args) {
+    setupPrepareStackTrace();
+    return fn(...args);
+  }, "name", {
+    value: STOP_HIDING
+  });
+}
+function endHiddenCallStack(fn) {
+  if (!SUPPORTED) return fn;
+  return Object.defineProperty(function (...args) {
+    return fn(...args);
+  }, "name", {
+    value: START_HIDING
+  });
+}
+function setupPrepareStackTrace() {
+  setupPrepareStackTrace = () => {};
+  const {
+    prepareStackTrace = defaultPrepareStackTrace
+  } = Error;
+  const MIN_STACK_TRACE_LIMIT = 50;
+  Error.stackTraceLimit && (Error.stackTraceLimit = Math.max(Error.stackTraceLimit, MIN_STACK_TRACE_LIMIT));
+  Error.prepareStackTrace = function stackTraceRewriter(err, trace) {
+    let newTrace = [];
+    const isExpected = expectedErrors.has(err);
+    let status = isExpected ? "hiding" : "unknown";
+    for (let i = 0; i < trace.length; i++) {
+      const name = trace[i].getFunctionName();
+      if (name === START_HIDING) {
+        status = "hiding";
+      } else if (name === STOP_HIDING) {
+        if (status === "hiding") {
+          status = "showing";
+          if (virtualFrames.has(err)) {
+            newTrace.unshift(...virtualFrames.get(err));
+          }
+        } else if (status === "unknown") {
+          newTrace = trace;
+          break;
+        }
+      } else if (status !== "hiding") {
+        newTrace.push(trace[i]);
+      }
+    }
+    return prepareStackTrace(err, newTrace);
+  };
+}
+function defaultPrepareStackTrace(err, trace) {
+  if (trace.length === 0) return ErrorToString(err);
+  return `${ErrorToString(err)}\n    at ${trace.join("\n    at ")}`;
+}
+0 && 0;
+
+//# sourceMappingURL=rewrite-stack-trace.js.map

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

@@ -0,0 +1,90 @@
+"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(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+const runGenerator = _gensync()(function* (item) {
+  return yield* item;
+});
+const isAsync = exports.isAsync = _gensync()({
+  sync: () => false,
+  errback: cb => cb(null, true)
+});
+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 = exports.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();
+    }
+  }
+});
+const waitFor = exports.waitFor = _gensync()({
+  sync: x => x,
+  async: function () {
+    var _ref2 = _asyncToGenerator(function* (x) {
+      return x;
+    });
+    return function async(_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }()
+});
+function isThenable(val) {
+  return !!val && (typeof val === "object" || typeof val === "function") && !!val.then && typeof val.then === "function";
+}
+0 && 0;
+
+//# sourceMappingURL=async.js.map

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

@@ -0,0 +1,31 @@
+"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 = exports.readFile = _gensync()({
+  sync: _fs().readFileSync,
+  errback: _fs().readFile
+});
+const stat = exports.stat = _gensync()({
+  sync: _fs().statSync,
+  errback: _fs().stat
+});
+0 && 0;
+
+//# sourceMappingURL=fs.js.map

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

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