ptoect

node_modules/tinypool/dist/esm/chunk-DSRZHYCS.js

@@ -0,0 +1,49 @@
+// src/entry/utils.ts
+import { pathToFileURL } from "url";
+var importESMCached;
+function getImportESM() {
+  if (importESMCached === void 0) {
+    importESMCached = new Function("specifier", "return import(specifier)");
+  }
+  return importESMCached;
+}
+var handlerCache = /* @__PURE__ */ new Map();
+async function getHandler(filename, name) {
+  let handler = handlerCache.get(`${filename}/${name}`);
+  if (handler !== void 0) {
+    return handler;
+  }
+  try {
+    const handlerModule = await import(filename);
+    handler = typeof handlerModule.default !== "function" && handlerModule.default || handlerModule;
+    if (typeof handler !== "function") {
+      handler = await handler[name];
+    }
+  } catch {
+  }
+  if (typeof handler !== "function") {
+    handler = await getImportESM()(pathToFileURL(filename).href);
+    if (typeof handler !== "function") {
+      handler = await handler[name];
+    }
+  }
+  if (typeof handler !== "function") {
+    return null;
+  }
+  if (handlerCache.size > 1e3) {
+    const [[key]] = handlerCache;
+    handlerCache.delete(key);
+  }
+  handlerCache.set(`${filename}/${name}`, handler);
+  return handler;
+}
+function throwInNextTick(error) {
+  process.nextTick(() => {
+    throw error;
+  });
+}
+
+export {
+  getHandler,
+  throwInNextTick
+};

node_modules/tinypool/dist/esm/chunk-FJA3Y3DX.js

@@ -0,0 +1,38 @@
+// src/common.ts
+var kMovable = Symbol("Tinypool.kMovable");
+var kTransferable = Symbol.for("Tinypool.transferable");
+var kValue = Symbol.for("Tinypool.valueOf");
+var kQueueOptions = Symbol.for("Tinypool.queueOptions");
+function isTransferable(value) {
+  return value != null && typeof value === "object" && kTransferable in value && kValue in value;
+}
+function isMovable(value) {
+  return isTransferable(value) && value[kMovable] === true;
+}
+function markMovable(value) {
+  Object.defineProperty(value, kMovable, {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: true
+  });
+}
+function isTaskQueue(value) {
+  return typeof value === "object" && value !== null && "size" in value && typeof value.shift === "function" && typeof value.remove === "function" && typeof value.push === "function";
+}
+var kRequestCountField = 0;
+var kResponseCountField = 1;
+var kFieldCount = 2;
+
+export {
+  kTransferable,
+  kValue,
+  kQueueOptions,
+  isTransferable,
+  isMovable,
+  markMovable,
+  isTaskQueue,
+  kRequestCountField,
+  kResponseCountField,
+  kFieldCount
+};

node_modules/tinypool/dist/esm/chunk-OECBSOR6.js

@@ -0,0 +1,12 @@
+// src/utils.ts
+function stdout() {
+  return console._stdout || process.stdout || void 0;
+}
+function stderr() {
+  return console._stderr || process.stderr || void 0;
+}
+
+export {
+  stdout,
+  stderr
+};

node_modules/tinypool/dist/esm/chunk-T6A5DJAH.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// node_modules/.pnpm/tsup@5.12.9_@swc+core@1.2.204_typescript@4.3.5/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+import path from "path";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+
+export {
+  __publicField,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __dirname
+};

node_modules/tinypool/dist/esm/entry/process.js

@@ -0,0 +1,88 @@
+"use strict";
+import {
+  stderr,
+  stdout
+} from "../chunk-OECBSOR6.js";
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-DSRZHYCS.js";
+import "../chunk-T6A5DJAH.js";
+
+// src/entry/process.ts
+process.__tinypool_state__ = {
+  isChildProcess: true,
+  isTinypoolWorker: true,
+  workerData: null,
+  workerId: Number(process.env.TINYPOOL_WORKER_ID)
+};
+var memoryUsage = process.memoryUsage.bind(process);
+var send = process.send.bind(process);
+process.on("message", (message) => {
+  if (!message || !message.__tinypool_worker_message__)
+    return;
+  if (message.source === "pool") {
+    const { filename, name } = message;
+    (async function() {
+      if (filename !== null) {
+        await getHandler(filename, name);
+      }
+      send({
+        ready: true,
+        source: "pool",
+        __tinypool_worker_message__: true
+      });
+    })().catch(throwInNextTick);
+    return;
+  }
+  if (message.source === "port") {
+    return onMessage(message).catch(throwInNextTick);
+  }
+  throw new Error(`Unexpected TinypoolWorkerMessage ${JSON.stringify(message)}`);
+});
+async function onMessage(message) {
+  const { taskId, task, filename, name } = message;
+  let response;
+  try {
+    const handler = await getHandler(filename, name);
+    if (handler === null) {
+      throw new Error(`No handler function exported from ${filename}`);
+    }
+    const result = await handler(task);
+    response = {
+      source: "port",
+      __tinypool_worker_message__: true,
+      taskId,
+      result,
+      error: null,
+      usedMemory: memoryUsage().heapUsed
+    };
+    if (stdout()?.writableLength > 0) {
+      await new Promise((resolve) => process.stdout.write("", resolve));
+    }
+    if (stderr()?.writableLength > 0) {
+      await new Promise((resolve) => process.stderr.write("", resolve));
+    }
+  } catch (error) {
+    response = {
+      source: "port",
+      __tinypool_worker_message__: true,
+      taskId,
+      result: null,
+      error: serializeError(error),
+      usedMemory: memoryUsage().heapUsed
+    };
+  }
+  send(response);
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      ...error,
+      name: error.name,
+      stack: error.stack,
+      message: error.message
+    };
+  }
+  return String(error);
+}

node_modules/tinypool/dist/esm/entry/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-DSRZHYCS.js";
+import "../chunk-T6A5DJAH.js";
+export {
+  getHandler,
+  throwInNextTick
+};

node_modules/tinypool/dist/esm/entry/worker.js

@@ -0,0 +1,102 @@
+"use strict";
+import {
+  isMovable,
+  kRequestCountField,
+  kResponseCountField,
+  kTransferable,
+  kValue
+} from "../chunk-FJA3Y3DX.js";
+import {
+  stderr,
+  stdout
+} from "../chunk-OECBSOR6.js";
+import {
+  getHandler,
+  throwInNextTick
+} from "../chunk-DSRZHYCS.js";
+import "../chunk-T6A5DJAH.js";
+
+// src/entry/worker.ts
+import {
+  parentPort,
+  receiveMessageOnPort,
+  workerData as tinypoolData
+} from "worker_threads";
+var [tinypoolPrivateData, workerData] = tinypoolData;
+process.__tinypool_state__ = {
+  isWorkerThread: true,
+  isTinypoolWorker: true,
+  workerData,
+  workerId: tinypoolPrivateData.workerId
+};
+var memoryUsage = process.memoryUsage.bind(process);
+var useAtomics = process.env.PISCINA_DISABLE_ATOMICS !== "1";
+parentPort.on("message", (message) => {
+  useAtomics = process.env.PISCINA_DISABLE_ATOMICS === "1" ? false : message.useAtomics;
+  const { port, sharedBuffer, filename, name } = message;
+  (async function() {
+    if (filename !== null) {
+      await getHandler(filename, name);
+    }
+    const readyMessage = { ready: true };
+    parentPort.postMessage(readyMessage);
+    port.on("message", onMessage.bind(null, port, sharedBuffer));
+    atomicsWaitLoop(port, sharedBuffer);
+  })().catch(throwInNextTick);
+});
+var currentTasks = 0;
+var lastSeenRequestCount = 0;
+function atomicsWaitLoop(port, sharedBuffer) {
+  if (!useAtomics)
+    return;
+  while (currentTasks === 0) {
+    Atomics.wait(sharedBuffer, kRequestCountField, lastSeenRequestCount);
+    lastSeenRequestCount = Atomics.load(sharedBuffer, kRequestCountField);
+    let entry;
+    while ((entry = receiveMessageOnPort(port)) !== void 0) {
+      onMessage(port, sharedBuffer, entry.message);
+    }
+  }
+}
+function onMessage(port, sharedBuffer, message) {
+  currentTasks++;
+  const { taskId, task, filename, name } = message;
+  (async function() {
+    let response;
+    let transferList = [];
+    try {
+      const handler = await getHandler(filename, name);
+      if (handler === null) {
+        throw new Error(`No handler function exported from ${filename}`);
+      }
+      let result = await handler(task);
+      if (isMovable(result)) {
+        transferList = transferList.concat(result[kTransferable]);
+        result = result[kValue];
+      }
+      response = {
+        taskId,
+        result,
+        error: null,
+        usedMemory: memoryUsage().heapUsed
+      };
+      if (stdout()?.writableLength > 0) {
+        await new Promise((resolve) => process.stdout.write("", resolve));
+      }
+      if (stderr()?.writableLength > 0) {
+        await new Promise((resolve) => process.stderr.write("", resolve));
+      }
+    } catch (error) {
+      response = {
+        taskId,
+        result: null,
+        error,
+        usedMemory: memoryUsage().heapUsed
+      };
+    }
+    currentTasks--;
+    port.postMessage(response, transferList);
+    Atomics.add(sharedBuffer, kResponseCountField, 1);
+    atomicsWaitLoop(port, sharedBuffer);
+  })().catch(throwInNextTick);
+}