@markw65/monkeyc-optimizer 1.1.15 → 1.1.16

package/build/chunk-K32K3YD4.cjs

@@ -0,0 +1,145 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_K32K3YD4_exports = {};
+__export(chunk_K32K3YD4_exports, {
+  runTaskInPool: () => runTaskInPool,
+  startPool: () => startPool,
+  stopPool: () => stopPool
+});
+module.exports = __toCommonJS(chunk_K32K3YD4_exports);
+var import_chunk_WIPYYCBN = require("./chunk-WIPYYCBN.cjs");
+var import_node_async_hooks = require("node:async_hooks");
+var import_node_events = require("node:events");
+var import_node_worker_threads = require("node:worker_threads");
+var os = __toESM(require("node:os"));
+(0, import_chunk_WIPYYCBN.init_worker_task)();
+var kTaskInfo = Symbol("kTaskInfo");
+var kWorkerFreedEvent = Symbol("kWorkerFreedEvent");
+var WorkerPoolTaskInfo = class extends import_node_async_hooks.AsyncResource {
+  constructor(callback) {
+    super("WorkerPoolTaskInfo");
+    this.callback = callback;
+  }
+  done(err, result) {
+    this.runInAsyncScope(this.callback, null, err, result);
+    this.emitDestroy();
+  }
+};
+var WorkerPool = class extends import_node_events.EventEmitter {
+  constructor(numThreads) {
+    super();
+    this.numThreads = numThreads;
+    this.numThreads = numThreads;
+    this.workers = [];
+    this.freeWorkers = [];
+    this.tasks = [];
+    for (let i = 0; i < numThreads; i++)
+      this.addNewWorker();
+    this.on(kWorkerFreedEvent, () => {
+      if (this.tasks.length > 0) {
+        const { task, callback } = this.tasks.shift();
+        this.runTask(task, callback);
+      }
+    });
+  }
+  workers;
+  freeWorkers;
+  tasks;
+  addNewWorker() {
+    const worker = new import_node_worker_threads.Worker(
+      //new URL("worker-thread.cjs", import.meta.url)
+      `${__dirname}/worker-thread.cjs`
+    );
+    worker.on("message", (result) => {
+      worker[kTaskInfo].done(null, result);
+      worker[kTaskInfo] = null;
+      this.freeWorkers.push(worker);
+      this.emit(kWorkerFreedEvent);
+    });
+    worker.on("error", (err) => {
+      if (worker[kTaskInfo])
+        worker[kTaskInfo].done(err, null);
+      else
+        this.emit("error", err);
+      this.workers.splice(this.workers.indexOf(worker), 1);
+      this.addNewWorker();
+    });
+    this.workers.push(worker);
+    this.freeWorkers.push(worker);
+    this.emit(kWorkerFreedEvent);
+  }
+  runTask(task, callback) {
+    const worker = this.freeWorkers.pop();
+    if (!worker) {
+      this.tasks.push({ task, callback });
+      return;
+    }
+    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);
+    worker.postMessage(task);
+  }
+  close() {
+    for (const worker of this.workers)
+      worker.terminate();
+  }
+};
+var pool = null;
+function startPool(parallelism) {
+  if (!pool) {
+    const workers = Math.ceil(parallelism ?? os.cpus().length / 4);
+    if (workers > 1) {
+      pool = new WorkerPool(workers);
+    }
+  }
+}
+function stopPool() {
+  if (pool) {
+    pool.close();
+    pool = null;
+  }
+}
+function runTaskInPool(task) {
+  const p = pool;
+  if (p) {
+    return new Promise(
+      (resolve, reject) => p.runTask(task, (err, result) => {
+        if (err)
+          reject(err);
+        else
+          resolve(result);
+      })
+    );
+  }
+  return (0, import_chunk_WIPYYCBN.performTask)(task);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runTaskInPool,
+  startPool,
+  stopPool
+});