@clazic/kordoc 2.4.19 → 2.5.0

package/dist/index.js

@@ -36,6 +36,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/page-range.ts
 var page_range_exports = {};
@@ -126,9 +127,9 @@ function sanitizeMeta(meta, cfg) {
   }
   return out;
 }
-function parsePositiveInt(input, fallback) {
+function parsePositiveInt(input, fallback2) {
   const n = Number(input);
-  if (!Number.isFinite(n) || n < 0) return fallback;
+  if (!Number.isFinite(n) || n < 0) return fallback2;
   return Math.floor(n);
 }
 function limitText(input, maxLen) {
@@ -293,9 +294,9 @@ var init_logger = __esm({
   }
 });
 
-// node_modules/cfb/cfb.js
+// ../../../node_modules/cfb/cfb.js
 var require_cfb = __commonJS({
-  "node_modules/cfb/cfb.js"(exports, module) {
+  "../../../node_modules/cfb/cfb.js"(exports, module) {
     "use strict";
     var Base64_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
     function Base64_encode(input) {
@@ -2475,7 +2476,7 @@ function createBatchCliProvider(mode, batchSize) {
   };
 }
 function spawnAsync(cmd, args, opts) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve4, reject2) => {
     const child = spawn(cmd, args, {
       cwd: opts.cwd,
       env: process.env,
@@ -2509,14 +2510,14 @@ function spawnAsync(cmd, args, opts) {
     child.on("close", (code) => {
       clearTimeout(timer);
       if (killed) {
-        reject(new Error(`\uD0C0\uC784\uC544\uC6C3 (${Math.round(opts.timeoutMs / 1e3)}\uCD08)`));
+        reject2(new Error(`\uD0C0\uC784\uC544\uC6C3 (${Math.round(opts.timeoutMs / 1e3)}\uCD08)`));
       } else {
         resolve4({ stdout, stderr, exitCode: code ?? 1 });
       }
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      reject(err);
+      reject2(err);
     });
   });
 }
@@ -2934,9 +2935,9 @@ async function ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warn
           });
         }
       } catch (err) {
-        const range = `${batchPageNums[0]}-${batchPageNums[batchPageNums.length - 1]}`;
+        const range2 = `${batchPageNums[0]}-${batchPageNums[batchPageNums.length - 1]}`;
         warnings?.push({
-          message: `\uBC30\uCE58 OCR \uC2E4\uD328 (\uD398\uC774\uC9C0 ${range}): ${err instanceof Error ? err.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"} \u2014 \uB2E8\uC77C \uD398\uC774\uC9C0\uB85C \uC7AC\uC2DC\uB3C4`,
+          message: `\uBC30\uCE58 OCR \uC2E4\uD328 (\uD398\uC774\uC9C0 ${range2}): ${err instanceof Error ? err.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"} \u2014 \uB2E8\uC77C \uD398\uC774\uC9C0\uB85C \uC7AC\uC2DC\uB3C4`,
           code: "OCR_PAGE_FAILED"
         });
         for (const { image, pageNum } of batchImages) {
@@ -2981,6 +2982,2320 @@ var init_provider = __esm({
   }
 });
 
+// ../../../node_modules/async/dist/async.mjs
+var async_exports = {};
+__export(async_exports, {
+  all: () => every$1,
+  allLimit: () => everyLimit$1,
+  allSeries: () => everySeries$1,
+  any: () => some$1,
+  anyLimit: () => someLimit$1,
+  anySeries: () => someSeries$1,
+  apply: () => apply,
+  applyEach: () => applyEach,
+  applyEachSeries: () => applyEachSeries,
+  asyncify: () => asyncify,
+  auto: () => auto,
+  autoInject: () => autoInject,
+  cargo: () => cargo$1,
+  cargoQueue: () => cargo,
+  compose: () => compose,
+  concat: () => concat$1,
+  concatLimit: () => concatLimit$1,
+  concatSeries: () => concatSeries$1,
+  constant: () => constant$1,
+  default: () => index,
+  detect: () => detect$1,
+  detectLimit: () => detectLimit$1,
+  detectSeries: () => detectSeries$1,
+  dir: () => dir,
+  doDuring: () => doWhilst$1,
+  doUntil: () => doUntil,
+  doWhilst: () => doWhilst$1,
+  during: () => whilst$1,
+  each: () => each,
+  eachLimit: () => eachLimit$1,
+  eachOf: () => eachOf$1,
+  eachOfLimit: () => eachOfLimit$1,
+  eachOfSeries: () => eachOfSeries$1,
+  eachSeries: () => eachSeries$1,
+  ensureAsync: () => ensureAsync,
+  every: () => every$1,
+  everyLimit: () => everyLimit$1,
+  everySeries: () => everySeries$1,
+  filter: () => filter$1,
+  filterLimit: () => filterLimit$1,
+  filterSeries: () => filterSeries$1,
+  find: () => detect$1,
+  findLimit: () => detectLimit$1,
+  findSeries: () => detectSeries$1,
+  flatMap: () => concat$1,
+  flatMapLimit: () => concatLimit$1,
+  flatMapSeries: () => concatSeries$1,
+  foldl: () => reduce$1,
+  foldr: () => reduceRight,
+  forEach: () => each,
+  forEachLimit: () => eachLimit$1,
+  forEachOf: () => eachOf$1,
+  forEachOfLimit: () => eachOfLimit$1,
+  forEachOfSeries: () => eachOfSeries$1,
+  forEachSeries: () => eachSeries$1,
+  forever: () => forever$1,
+  groupBy: () => groupBy,
+  groupByLimit: () => groupByLimit$1,
+  groupBySeries: () => groupBySeries,
+  inject: () => reduce$1,
+  log: () => log,
+  map: () => map$1,
+  mapLimit: () => mapLimit$1,
+  mapSeries: () => mapSeries$1,
+  mapValues: () => mapValues,
+  mapValuesLimit: () => mapValuesLimit$1,
+  mapValuesSeries: () => mapValuesSeries,
+  memoize: () => memoize,
+  nextTick: () => nextTick,
+  parallel: () => parallel,
+  parallelLimit: () => parallelLimit,
+  priorityQueue: () => priorityQueue,
+  queue: () => queue,
+  race: () => race$1,
+  reduce: () => reduce$1,
+  reduceRight: () => reduceRight,
+  reflect: () => reflect,
+  reflectAll: () => reflectAll,
+  reject: () => reject$1,
+  rejectLimit: () => rejectLimit$1,
+  rejectSeries: () => rejectSeries$1,
+  retry: () => retry,
+  retryable: () => retryable,
+  select: () => filter$1,
+  selectLimit: () => filterLimit$1,
+  selectSeries: () => filterSeries$1,
+  seq: () => seq,
+  series: () => series,
+  setImmediate: () => setImmediate$1,
+  some: () => some$1,
+  someLimit: () => someLimit$1,
+  someSeries: () => someSeries$1,
+  sortBy: () => sortBy$1,
+  timeout: () => timeout,
+  times: () => times,
+  timesLimit: () => timesLimit,
+  timesSeries: () => timesSeries,
+  transform: () => transform,
+  tryEach: () => tryEach$1,
+  unmemoize: () => unmemoize,
+  until: () => until,
+  waterfall: () => waterfall$1,
+  whilst: () => whilst$1,
+  wrapSync: () => asyncify
+});
+function apply(fn, ...args) {
+  return (...callArgs) => fn(...args, ...callArgs);
+}
+function initialParams(fn) {
+  return function(...args) {
+    var callback = args.pop();
+    return fn.call(this, args, callback);
+  };
+}
+function fallback(fn) {
+  setTimeout(fn, 0);
+}
+function wrap(defer) {
+  return (fn, ...args) => defer(() => fn(...args));
+}
+function asyncify(func) {
+  if (isAsync(func)) {
+    return function(...args) {
+      const callback = args.pop();
+      const promise = func.apply(this, args);
+      return handlePromise(promise, callback);
+    };
+  }
+  return initialParams(function(args, callback) {
+    var result;
+    try {
+      result = func.apply(this, args);
+    } catch (e) {
+      return callback(e);
+    }
+    if (result && typeof result.then === "function") {
+      return handlePromise(result, callback);
+    } else {
+      callback(null, result);
+    }
+  });
+}
+function handlePromise(promise, callback) {
+  return promise.then((value) => {
+    invokeCallback(callback, null, value);
+  }, (err) => {
+    invokeCallback(callback, err && (err instanceof Error || err.message) ? err : new Error(err));
+  });
+}
+function invokeCallback(callback, error, value) {
+  try {
+    callback(error, value);
+  } catch (err) {
+    setImmediate$1((e) => {
+      throw e;
+    }, err);
+  }
+}
+function isAsync(fn) {
+  return fn[Symbol.toStringTag] === "AsyncFunction";
+}
+function isAsyncGenerator(fn) {
+  return fn[Symbol.toStringTag] === "AsyncGenerator";
+}
+function isAsyncIterable(obj) {
+  return typeof obj[Symbol.asyncIterator] === "function";
+}
+function wrapAsync(asyncFn) {
+  if (typeof asyncFn !== "function") throw new Error("expected a function");
+  return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
+}
+function awaitify(asyncFn, arity) {
+  if (!arity) arity = asyncFn.length;
+  if (!arity) throw new Error("arity is undefined");
+  function awaitable(...args) {
+    if (typeof args[arity - 1] === "function") {
+      return asyncFn.apply(this, args);
+    }
+    return new Promise((resolve4, reject2) => {
+      args[arity - 1] = (err, ...cbArgs) => {
+        if (err) return reject2(err);
+        resolve4(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+      };
+      asyncFn.apply(this, args);
+    });
+  }
+  return awaitable;
+}
+function applyEach$1(eachfn) {
+  return function applyEach2(fns, ...callArgs) {
+    const go = awaitify(function(callback) {
+      var that = this;
+      return eachfn(fns, (fn, cb) => {
+        wrapAsync(fn).apply(that, callArgs.concat(cb));
+      }, callback);
+    });
+    return go;
+  };
+}
+function _asyncMap(eachfn, arr, iteratee, callback) {
+  arr = arr || [];
+  var results = [];
+  var counter = 0;
+  var _iteratee = wrapAsync(iteratee);
+  return eachfn(arr, (value, _, iterCb) => {
+    var index2 = counter++;
+    _iteratee(value, (err, v) => {
+      results[index2] = v;
+      iterCb(err);
+    });
+  }, (err) => {
+    callback(err, results);
+  });
+}
+function isArrayLike(value) {
+  return value && typeof value.length === "number" && value.length >= 0 && value.length % 1 === 0;
+}
+function once(fn) {
+  function wrapper(...args) {
+    if (fn === null) return;
+    var callFn = fn;
+    fn = null;
+    callFn.apply(this, args);
+  }
+  Object.assign(wrapper, fn);
+  return wrapper;
+}
+function getIterator(coll) {
+  return coll[Symbol.iterator] && coll[Symbol.iterator]();
+}
+function createArrayIterator(coll) {
+  var i = -1;
+  var len = coll.length;
+  return function next() {
+    return ++i < len ? { value: coll[i], key: i } : null;
+  };
+}
+function createES2015Iterator(iterator) {
+  var i = -1;
+  return function next() {
+    var item = iterator.next();
+    if (item.done)
+      return null;
+    i++;
+    return { value: item.value, key: i };
+  };
+}
+function createObjectIterator(obj) {
+  var okeys = obj ? Object.keys(obj) : [];
+  var i = -1;
+  var len = okeys.length;
+  return function next() {
+    var key = okeys[++i];
+    if (key === "__proto__") {
+      return next();
+    }
+    return i < len ? { value: obj[key], key } : null;
+  };
+}
+function createIterator(coll) {
+  if (isArrayLike(coll)) {
+    return createArrayIterator(coll);
+  }
+  var iterator = getIterator(coll);
+  return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);
+}
+function onlyOnce(fn) {
+  return function(...args) {
+    if (fn === null) throw new Error("Callback was already called.");
+    var callFn = fn;
+    fn = null;
+    callFn.apply(this, args);
+  };
+}
+function asyncEachOfLimit(generator, limit, iteratee, callback) {
+  let done = false;
+  let canceled = false;
+  let awaiting = false;
+  let running = 0;
+  let idx = 0;
+  function replenish() {
+    if (running >= limit || awaiting || done) return;
+    awaiting = true;
+    generator.next().then(({ value, done: iterDone }) => {
+      if (canceled || done) return;
+      awaiting = false;
+      if (iterDone) {
+        done = true;
+        if (running <= 0) {
+          callback(null);
+        }
+        return;
+      }
+      running++;
+      iteratee(value, idx, iterateeCallback);
+      idx++;
+      replenish();
+    }).catch(handleError);
+  }
+  function iterateeCallback(err, result) {
+    running -= 1;
+    if (canceled) return;
+    if (err) return handleError(err);
+    if (err === false) {
+      done = true;
+      canceled = true;
+      return;
+    }
+    if (result === breakLoop || done && running <= 0) {
+      done = true;
+      return callback(null);
+    }
+    replenish();
+  }
+  function handleError(err) {
+    if (canceled) return;
+    awaiting = false;
+    done = true;
+    callback(err);
+  }
+  replenish();
+}
+function eachOfLimit(coll, limit, iteratee, callback) {
+  return eachOfLimit$2(limit)(coll, wrapAsync(iteratee), callback);
+}
+function eachOfArrayLike(coll, iteratee, callback) {
+  callback = once(callback);
+  var index2 = 0, completed = 0, { length } = coll, canceled = false;
+  if (length === 0) {
+    callback(null);
+  }
+  function iteratorCallback(err, value) {
+    if (err === false) {
+      canceled = true;
+    }
+    if (canceled === true) return;
+    if (err) {
+      callback(err);
+    } else if (++completed === length || value === breakLoop) {
+      callback(null);
+    }
+  }
+  for (; index2 < length; index2++) {
+    iteratee(coll[index2], index2, onlyOnce(iteratorCallback));
+  }
+}
+function eachOfGeneric(coll, iteratee, callback) {
+  return eachOfLimit$1(coll, Infinity, iteratee, callback);
+}
+function eachOf(coll, iteratee, callback) {
+  var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
+  return eachOfImplementation(coll, wrapAsync(iteratee), callback);
+}
+function map(coll, iteratee, callback) {
+  return _asyncMap(eachOf$1, coll, iteratee, callback);
+}
+function eachOfSeries(coll, iteratee, callback) {
+  return eachOfLimit$1(coll, 1, iteratee, callback);
+}
+function mapSeries(coll, iteratee, callback) {
+  return _asyncMap(eachOfSeries$1, coll, iteratee, callback);
+}
+function promiseCallback() {
+  let resolve4, reject2;
+  function callback(err, ...args) {
+    if (err) return reject2(err);
+    resolve4(args.length > 1 ? args : args[0]);
+  }
+  callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
+    resolve4 = res, reject2 = rej;
+  });
+  return callback;
+}
+function auto(tasks, concurrency, callback) {
+  if (typeof concurrency !== "number") {
+    callback = concurrency;
+    concurrency = null;
+  }
+  callback = once(callback || promiseCallback());
+  var numTasks = Object.keys(tasks).length;
+  if (!numTasks) {
+    return callback(null);
+  }
+  if (!concurrency) {
+    concurrency = numTasks;
+  }
+  var results = {};
+  var runningTasks = 0;
+  var canceled = false;
+  var hasError = false;
+  var listeners = /* @__PURE__ */ Object.create(null);
+  var readyTasks = [];
+  var readyToCheck = [];
+  var uncheckedDependencies = {};
+  Object.keys(tasks).forEach((key) => {
+    var task = tasks[key];
+    if (!Array.isArray(task)) {
+      enqueueTask(key, [task]);
+      readyToCheck.push(key);
+      return;
+    }
+    var dependencies = task.slice(0, task.length - 1);
+    var remainingDependencies = dependencies.length;
+    if (remainingDependencies === 0) {
+      enqueueTask(key, task);
+      readyToCheck.push(key);
+      return;
+    }
+    uncheckedDependencies[key] = remainingDependencies;
+    dependencies.forEach((dependencyName) => {
+      if (!tasks[dependencyName]) {
+        throw new Error("async.auto task `" + key + "` has a non-existent dependency `" + dependencyName + "` in " + dependencies.join(", "));
+      }
+      addListener(dependencyName, () => {
+        remainingDependencies--;
+        if (remainingDependencies === 0) {
+          enqueueTask(key, task);
+        }
+      });
+    });
+  });
+  checkForDeadlocks();
+  processQueue();
+  function enqueueTask(key, task) {
+    readyTasks.push(() => runTask(key, task));
+  }
+  function processQueue() {
+    if (canceled) return;
+    if (readyTasks.length === 0 && runningTasks === 0) {
+      return callback(null, results);
+    }
+    while (readyTasks.length && runningTasks < concurrency) {
+      var run = readyTasks.shift();
+      run();
+    }
+  }
+  function addListener(taskName, fn) {
+    var taskListeners = listeners[taskName];
+    if (!taskListeners) {
+      taskListeners = listeners[taskName] = [];
+    }
+    taskListeners.push(fn);
+  }
+  function taskComplete(taskName) {
+    var taskListeners = listeners[taskName] || [];
+    taskListeners.forEach((fn) => fn());
+    processQueue();
+  }
+  function runTask(key, task) {
+    if (hasError) return;
+    var taskCallback = onlyOnce((err, ...result) => {
+      runningTasks--;
+      if (err === false) {
+        canceled = true;
+        return;
+      }
+      if (result.length < 2) {
+        [result] = result;
+      }
+      if (err) {
+        var safeResults = {};
+        Object.keys(results).forEach((rkey) => {
+          safeResults[rkey] = results[rkey];
+        });
+        safeResults[key] = result;
+        hasError = true;
+        listeners = /* @__PURE__ */ Object.create(null);
+        if (canceled) return;
+        callback(err, safeResults);
+      } else {
+        results[key] = result;
+        taskComplete(key);
+      }
+    });
+    runningTasks++;
+    var taskFn = wrapAsync(task[task.length - 1]);
+    if (task.length > 1) {
+      taskFn(results, taskCallback);
+    } else {
+      taskFn(taskCallback);
+    }
+  }
+  function checkForDeadlocks() {
+    var currentTask;
+    var counter = 0;
+    while (readyToCheck.length) {
+      currentTask = readyToCheck.pop();
+      counter++;
+      getDependents(currentTask).forEach((dependent) => {
+        if (--uncheckedDependencies[dependent] === 0) {
+          readyToCheck.push(dependent);
+        }
+      });
+    }
+    if (counter !== numTasks) {
+      throw new Error(
+        "async.auto cannot execute tasks due to a recursive dependency"
+      );
+    }
+  }
+  function getDependents(taskName) {
+    var result = [];
+    Object.keys(tasks).forEach((key) => {
+      const task = tasks[key];
+      if (Array.isArray(task) && task.indexOf(taskName) >= 0) {
+        result.push(key);
+      }
+    });
+    return result;
+  }
+  return callback[PROMISE_SYMBOL];
+}
+function stripComments(string) {
+  let stripped = "";
+  let index2 = 0;
+  let endBlockComment = string.indexOf("*/");
+  while (index2 < string.length) {
+    if (string[index2] === "/" && string[index2 + 1] === "/") {
+      let endIndex = string.indexOf("\n", index2);
+      index2 = endIndex === -1 ? string.length : endIndex;
+    } else if (endBlockComment !== -1 && string[index2] === "/" && string[index2 + 1] === "*") {
+      let endIndex = string.indexOf("*/", index2);
+      if (endIndex !== -1) {
+        index2 = endIndex + 2;
+        endBlockComment = string.indexOf("*/", index2);
+      } else {
+        stripped += string[index2];
+        index2++;
+      }
+    } else {
+      stripped += string[index2];
+      index2++;
+    }
+  }
+  return stripped;
+}
+function parseParams(func) {
+  const src = stripComments(func.toString());
+  let match = src.match(FN_ARGS);
+  if (!match) {
+    match = src.match(ARROW_FN_ARGS);
+  }
+  if (!match) throw new Error("could not parse args in autoInject\nSource:\n" + src);
+  let [, args] = match;
+  return args.replace(/\s/g, "").split(FN_ARG_SPLIT).map((arg) => arg.replace(FN_ARG, "").trim());
+}
+function autoInject(tasks, callback) {
+  var newTasks = {};
+  Object.keys(tasks).forEach((key) => {
+    var taskFn = tasks[key];
+    var params;
+    var fnIsAsync = isAsync(taskFn);
+    var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;
+    if (Array.isArray(taskFn)) {
+      params = [...taskFn];
+      taskFn = params.pop();
+      newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
+    } else if (hasNoDeps) {
+      newTasks[key] = taskFn;
+    } else {
+      params = parseParams(taskFn);
+      if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
+        throw new Error("autoInject task functions require explicit parameters.");
+      }
+      if (!fnIsAsync) params.pop();
+      newTasks[key] = params.concat(newTask);
+    }
+    function newTask(results, taskCb) {
+      var newArgs = params.map((name) => results[name]);
+      newArgs.push(taskCb);
+      wrapAsync(taskFn)(...newArgs);
+    }
+  });
+  return auto(newTasks, callback);
+}
+function setInitial(dll, node) {
+  dll.length = 1;
+  dll.head = dll.tail = node;
+}
+function queue$1(worker, concurrency, payload) {
+  if (concurrency == null) {
+    concurrency = 1;
+  } else if (concurrency === 0) {
+    throw new RangeError("Concurrency must not be zero");
+  }
+  var _worker = wrapAsync(worker);
+  var numRunning = 0;
+  var workersList = [];
+  const events = {
+    error: [],
+    drain: [],
+    saturated: [],
+    unsaturated: [],
+    empty: []
+  };
+  function on(event, handler) {
+    events[event].push(handler);
+  }
+  function once2(event, handler) {
+    const handleAndRemove = (...args) => {
+      off(event, handleAndRemove);
+      handler(...args);
+    };
+    events[event].push(handleAndRemove);
+  }
+  function off(event, handler) {
+    if (!event) return Object.keys(events).forEach((ev) => events[ev] = []);
+    if (!handler) return events[event] = [];
+    events[event] = events[event].filter((ev) => ev !== handler);
+  }
+  function trigger(event, ...args) {
+    events[event].forEach((handler) => handler(...args));
+  }
+  var processingScheduled = false;
+  function _insert(data, insertAtFront, rejectOnError, callback) {
+    if (callback != null && typeof callback !== "function") {
+      throw new Error("task callback must be a function");
+    }
+    q.started = true;
+    var res, rej;
+    function promiseCallback2(err, ...args) {
+      if (err) return rejectOnError ? rej(err) : res();
+      if (args.length <= 1) return res(args[0]);
+      res(args);
+    }
+    var item = q._createTaskItem(
+      data,
+      rejectOnError ? promiseCallback2 : callback || promiseCallback2
+    );
+    if (insertAtFront) {
+      q._tasks.unshift(item);
+    } else {
+      q._tasks.push(item);
+    }
+    if (!processingScheduled) {
+      processingScheduled = true;
+      setImmediate$1(() => {
+        processingScheduled = false;
+        q.process();
+      });
+    }
+    if (rejectOnError || !callback) {
+      return new Promise((resolve4, reject2) => {
+        res = resolve4;
+        rej = reject2;
+      });
+    }
+  }
+  function _createCB(tasks) {
+    return function(err, ...args) {
+      numRunning -= 1;
+      for (var i = 0, l = tasks.length; i < l; i++) {
+        var task = tasks[i];
+        var index2 = workersList.indexOf(task);
+        if (index2 === 0) {
+          workersList.shift();
+        } else if (index2 > 0) {
+          workersList.splice(index2, 1);
+        }
+        task.callback(err, ...args);
+        if (err != null) {
+          trigger("error", err, task.data);
+        }
+      }
+      if (numRunning <= q.concurrency - q.buffer) {
+        trigger("unsaturated");
+      }
+      if (q.idle()) {
+        trigger("drain");
+      }
+      q.process();
+    };
+  }
+  function _maybeDrain(data) {
+    if (data.length === 0 && q.idle()) {
+      setImmediate$1(() => trigger("drain"));
+      return true;
+    }
+    return false;
+  }
+  const eventMethod = (name) => (handler) => {
+    if (!handler) {
+      return new Promise((resolve4, reject2) => {
+        once2(name, (err, data) => {
+          if (err) return reject2(err);
+          resolve4(data);
+        });
+      });
+    }
+    off(name);
+    on(name, handler);
+  };
+  var isProcessing = false;
+  var q = {
+    _tasks: new DLL(),
+    _createTaskItem(data, callback) {
+      return {
+        data,
+        callback
+      };
+    },
+    *[Symbol.iterator]() {
+      yield* q._tasks[Symbol.iterator]();
+    },
+    concurrency,
+    payload,
+    buffer: concurrency / 4,
+    started: false,
+    paused: false,
+    push(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, false, false, callback));
+      }
+      return _insert(data, false, false, callback);
+    },
+    pushAsync(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, false, true, callback));
+      }
+      return _insert(data, false, true, callback);
+    },
+    kill() {
+      off();
+      q._tasks.empty();
+    },
+    unshift(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, true, false, callback));
+      }
+      return _insert(data, true, false, callback);
+    },
+    unshiftAsync(data, callback) {
+      if (Array.isArray(data)) {
+        if (_maybeDrain(data)) return;
+        return data.map((datum) => _insert(datum, true, true, callback));
+      }
+      return _insert(data, true, true, callback);
+    },
+    remove(testFn) {
+      q._tasks.remove(testFn);
+    },
+    process() {
+      if (isProcessing) {
+        return;
+      }
+      isProcessing = true;
+      while (!q.paused && numRunning < q.concurrency && q._tasks.length) {
+        var tasks = [], data = [];
+        var l = q._tasks.length;
+        if (q.payload) l = Math.min(l, q.payload);
+        for (var i = 0; i < l; i++) {
+          var node = q._tasks.shift();
+          tasks.push(node);
+          workersList.push(node);
+          data.push(node.data);
+        }
+        numRunning += 1;
+        if (q._tasks.length === 0) {
+          trigger("empty");
+        }
+        if (numRunning === q.concurrency) {
+          trigger("saturated");
+        }
+        var cb = onlyOnce(_createCB(tasks));
+        _worker(data, cb);
+      }
+      isProcessing = false;
+    },
+    length() {
+      return q._tasks.length;
+    },
+    running() {
+      return numRunning;
+    },
+    workersList() {
+      return workersList;
+    },
+    idle() {
+      return q._tasks.length + numRunning === 0;
+    },
+    pause() {
+      q.paused = true;
+    },
+    resume() {
+      if (q.paused === false) {
+        return;
+      }
+      q.paused = false;
+      setImmediate$1(q.process);
+    }
+  };
+  Object.defineProperties(q, {
+    saturated: {
+      writable: false,
+      value: eventMethod("saturated")
+    },
+    unsaturated: {
+      writable: false,
+      value: eventMethod("unsaturated")
+    },
+    empty: {
+      writable: false,
+      value: eventMethod("empty")
+    },
+    drain: {
+      writable: false,
+      value: eventMethod("drain")
+    },
+    error: {
+      writable: false,
+      value: eventMethod("error")
+    }
+  });
+  return q;
+}
+function cargo$1(worker, payload) {
+  return queue$1(worker, 1, payload);
+}
+function cargo(worker, concurrency, payload) {
+  return queue$1(worker, concurrency, payload);
+}
+function reduce(coll, memo, iteratee, callback) {
+  callback = once(callback);
+  var _iteratee = wrapAsync(iteratee);
+  return eachOfSeries$1(coll, (x, i, iterCb) => {
+    _iteratee(memo, x, (err, v) => {
+      memo = v;
+      iterCb(err);
+    });
+  }, (err) => callback(err, memo));
+}
+function seq(...functions) {
+  var _functions = functions.map(wrapAsync);
+  return function(...args) {
+    var that = this;
+    var cb = args[args.length - 1];
+    if (typeof cb == "function") {
+      args.pop();
+    } else {
+      cb = promiseCallback();
+    }
+    reduce$1(
+      _functions,
+      args,
+      (newargs, fn, iterCb) => {
+        fn.apply(that, newargs.concat((err, ...nextargs) => {
+          iterCb(err, nextargs);
+        }));
+      },
+      (err, results) => cb(err, ...results)
+    );
+    return cb[PROMISE_SYMBOL];
+  };
+}
+function compose(...args) {
+  return seq(...args.reverse());
+}
+function mapLimit(coll, limit, iteratee, callback) {
+  return _asyncMap(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function concatLimit(coll, limit, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return mapLimit$1(coll, limit, (val, iterCb) => {
+    _iteratee(val, (err, ...args) => {
+      if (err) return iterCb(err);
+      return iterCb(err, args);
+    });
+  }, (err, mapResults) => {
+    var result = [];
+    for (var i = 0; i < mapResults.length; i++) {
+      if (mapResults[i]) {
+        result = result.concat(...mapResults[i]);
+      }
+    }
+    return callback(err, result);
+  });
+}
+function concat(coll, iteratee, callback) {
+  return concatLimit$1(coll, Infinity, iteratee, callback);
+}
+function concatSeries(coll, iteratee, callback) {
+  return concatLimit$1(coll, 1, iteratee, callback);
+}
+function constant$1(...args) {
+  return function(...ignoredArgs) {
+    var callback = ignoredArgs.pop();
+    return callback(null, ...args);
+  };
+}
+function _createTester(check, getResult) {
+  return (eachfn, arr, _iteratee, cb) => {
+    var testPassed = false;
+    var testResult;
+    const iteratee = wrapAsync(_iteratee);
+    eachfn(arr, (value, _, callback) => {
+      iteratee(value, (err, result) => {
+        if (err || err === false) return callback(err);
+        if (check(result) && !testResult) {
+          testPassed = true;
+          testResult = getResult(true, value);
+          return callback(null, breakLoop);
+        }
+        callback();
+      });
+    }, (err) => {
+      if (err) return cb(err);
+      cb(null, testPassed ? testResult : getResult(false));
+    });
+  };
+}
+function detect(coll, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOf$1, coll, iteratee, callback);
+}
+function detectLimit(coll, limit, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function detectSeries(coll, iteratee, callback) {
+  return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(1), coll, iteratee, callback);
+}
+function consoleFunc(name) {
+  return (fn, ...args) => wrapAsync(fn)(...args, (err, ...resultArgs) => {
+    if (typeof console === "object") {
+      if (err) {
+        if (console.error) {
+          console.error(err);
+        }
+      } else if (console[name]) {
+        resultArgs.forEach((x) => console[name](x));
+      }
+    }
+  });
+}
+function doWhilst(iteratee, test, callback) {
+  callback = onlyOnce(callback);
+  var _fn = wrapAsync(iteratee);
+  var _test = wrapAsync(test);
+  var results;
+  function next(err, ...args) {
+    if (err) return callback(err);
+    if (err === false) return;
+    results = args;
+    _test(...args, check);
+  }
+  function check(err, truth) {
+    if (err) return callback(err);
+    if (err === false) return;
+    if (!truth) return callback(null, ...results);
+    _fn(next);
+  }
+  return check(null, true);
+}
+function doUntil(iteratee, test, callback) {
+  const _test = wrapAsync(test);
+  return doWhilst$1(iteratee, (...args) => {
+    const cb = args.pop();
+    _test(...args, (err, truth) => cb(err, !truth));
+  }, callback);
+}
+function _withoutIndex(iteratee) {
+  return (value, index2, callback) => iteratee(value, callback);
+}
+function eachLimit$2(coll, iteratee, callback) {
+  return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);
+}
+function eachLimit(coll, limit, iteratee, callback) {
+  return eachOfLimit$2(limit)(coll, _withoutIndex(wrapAsync(iteratee)), callback);
+}
+function eachSeries(coll, iteratee, callback) {
+  return eachLimit$1(coll, 1, iteratee, callback);
+}
+function ensureAsync(fn) {
+  if (isAsync(fn)) return fn;
+  return function(...args) {
+    var callback = args.pop();
+    var sync = true;
+    args.push((...innerArgs) => {
+      if (sync) {
+        setImmediate$1(() => callback(...innerArgs));
+      } else {
+        callback(...innerArgs);
+      }
+    });
+    fn.apply(this, args);
+    sync = false;
+  };
+}
+function every(coll, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOf$1, coll, iteratee, callback);
+}
+function everyLimit(coll, limit, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function everySeries(coll, iteratee, callback) {
+  return _createTester((bool) => !bool, (res) => !res)(eachOfSeries$1, coll, iteratee, callback);
+}
+function filterArray(eachfn, arr, iteratee, callback) {
+  var truthValues = new Array(arr.length);
+  eachfn(arr, (x, index2, iterCb) => {
+    iteratee(x, (err, v) => {
+      truthValues[index2] = !!v;
+      iterCb(err);
+    });
+  }, (err) => {
+    if (err) return callback(err);
+    var results = [];
+    for (var i = 0; i < arr.length; i++) {
+      if (truthValues[i]) results.push(arr[i]);
+    }
+    callback(null, results);
+  });
+}
+function filterGeneric(eachfn, coll, iteratee, callback) {
+  var results = [];
+  eachfn(coll, (x, index2, iterCb) => {
+    iteratee(x, (err, v) => {
+      if (err) return iterCb(err);
+      if (v) {
+        results.push({ index: index2, value: x });
+      }
+      iterCb(err);
+    });
+  }, (err) => {
+    if (err) return callback(err);
+    callback(null, results.sort((a, b) => a.index - b.index).map((v) => v.value));
+  });
+}
+function _filter(eachfn, coll, iteratee, callback) {
+  var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
+  return filter2(eachfn, coll, wrapAsync(iteratee), callback);
+}
+function filter(coll, iteratee, callback) {
+  return _filter(eachOf$1, coll, iteratee, callback);
+}
+function filterLimit(coll, limit, iteratee, callback) {
+  return _filter(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function filterSeries(coll, iteratee, callback) {
+  return _filter(eachOfSeries$1, coll, iteratee, callback);
+}
+function forever(fn, errback) {
+  var done = onlyOnce(errback);
+  var task = wrapAsync(ensureAsync(fn));
+  function next(err) {
+    if (err) return done(err);
+    if (err === false) return;
+    task(next);
+  }
+  return next();
+}
+function groupByLimit(coll, limit, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return mapLimit$1(coll, limit, (val, iterCb) => {
+    _iteratee(val, (err, key) => {
+      if (err) return iterCb(err);
+      return iterCb(err, { key, val });
+    });
+  }, (err, mapResults) => {
+    var result = {};
+    var { hasOwnProperty } = Object.prototype;
+    for (var i = 0; i < mapResults.length; i++) {
+      if (mapResults[i]) {
+        var { key } = mapResults[i];
+        var { val } = mapResults[i];
+        if (hasOwnProperty.call(result, key)) {
+          result[key].push(val);
+        } else {
+          result[key] = [val];
+        }
+      }
+    }
+    return callback(err, result);
+  });
+}
+function groupBy(coll, iteratee, callback) {
+  return groupByLimit$1(coll, Infinity, iteratee, callback);
+}
+function groupBySeries(coll, iteratee, callback) {
+  return groupByLimit$1(coll, 1, iteratee, callback);
+}
+function mapValuesLimit(obj, limit, iteratee, callback) {
+  callback = once(callback);
+  var newObj = {};
+  var _iteratee = wrapAsync(iteratee);
+  return eachOfLimit$2(limit)(obj, (val, key, next) => {
+    _iteratee(val, key, (err, result) => {
+      if (err) return next(err);
+      newObj[key] = result;
+      next(err);
+    });
+  }, (err) => callback(err, newObj));
+}
+function mapValues(obj, iteratee, callback) {
+  return mapValuesLimit$1(obj, Infinity, iteratee, callback);
+}
+function mapValuesSeries(obj, iteratee, callback) {
+  return mapValuesLimit$1(obj, 1, iteratee, callback);
+}
+function memoize(fn, hasher = (v) => v) {
+  var memo = /* @__PURE__ */ Object.create(null);
+  var queues = /* @__PURE__ */ Object.create(null);
+  var _fn = wrapAsync(fn);
+  var memoized = initialParams((args, callback) => {
+    var key = hasher(...args);
+    if (key in memo) {
+      setImmediate$1(() => callback(null, ...memo[key]));
+    } else if (key in queues) {
+      queues[key].push(callback);
+    } else {
+      queues[key] = [callback];
+      _fn(...args, (err, ...resultArgs) => {
+        if (!err) {
+          memo[key] = resultArgs;
+        }
+        var q = queues[key];
+        delete queues[key];
+        for (var i = 0, l = q.length; i < l; i++) {
+          q[i](err, ...resultArgs);
+        }
+      });
+    }
+  });
+  memoized.memo = memo;
+  memoized.unmemoized = fn;
+  return memoized;
+}
+function parallel(tasks, callback) {
+  return _parallel(eachOf$1, tasks, callback);
+}
+function parallelLimit(tasks, limit, callback) {
+  return _parallel(eachOfLimit$2(limit), tasks, callback);
+}
+function queue(worker, concurrency) {
+  var _worker = wrapAsync(worker);
+  return queue$1((items, cb) => {
+    _worker(items[0], cb);
+  }, concurrency, 1);
+}
+function leftChi(i) {
+  return (i << 1) + 1;
+}
+function parent(i) {
+  return (i + 1 >> 1) - 1;
+}
+function smaller(x, y) {
+  if (x.priority !== y.priority) {
+    return x.priority < y.priority;
+  } else {
+    return x.pushCount < y.pushCount;
+  }
+}
+function priorityQueue(worker, concurrency) {
+  var q = queue(worker, concurrency);
+  var {
+    push,
+    pushAsync
+  } = q;
+  q._tasks = new Heap();
+  q._createTaskItem = ({ data, priority }, callback) => {
+    return {
+      data,
+      priority,
+      callback
+    };
+  };
+  function createDataItems(tasks, priority) {
+    if (!Array.isArray(tasks)) {
+      return { data: tasks, priority };
+    }
+    return tasks.map((data) => {
+      return { data, priority };
+    });
+  }
+  q.push = function(data, priority = 0, callback) {
+    return push(createDataItems(data, priority), callback);
+  };
+  q.pushAsync = function(data, priority = 0, callback) {
+    return pushAsync(createDataItems(data, priority), callback);
+  };
+  delete q.unshift;
+  delete q.unshiftAsync;
+  return q;
+}
+function race(tasks, callback) {
+  callback = once(callback);
+  if (!Array.isArray(tasks)) return callback(new TypeError("First argument to race must be an array of functions"));
+  if (!tasks.length) return callback();
+  for (var i = 0, l = tasks.length; i < l; i++) {
+    wrapAsync(tasks[i])(callback);
+  }
+}
+function reduceRight(array, memo, iteratee, callback) {
+  var reversed = [...array].reverse();
+  return reduce$1(reversed, memo, iteratee, callback);
+}
+function reflect(fn) {
+  var _fn = wrapAsync(fn);
+  return initialParams(function reflectOn(args, reflectCallback) {
+    args.push((error, ...cbArgs) => {
+      let retVal = {};
+      if (error) {
+        retVal.error = error;
+      }
+      if (cbArgs.length > 0) {
+        var value = cbArgs;
+        if (cbArgs.length <= 1) {
+          [value] = cbArgs;
+        }
+        retVal.value = value;
+      }
+      reflectCallback(null, retVal);
+    });
+    return _fn.apply(this, args);
+  });
+}
+function reflectAll(tasks) {
+  var results;
+  if (Array.isArray(tasks)) {
+    results = tasks.map(reflect);
+  } else {
+    results = {};
+    Object.keys(tasks).forEach((key) => {
+      results[key] = reflect.call(this, tasks[key]);
+    });
+  }
+  return results;
+}
+function reject$2(eachfn, arr, _iteratee, callback) {
+  const iteratee = wrapAsync(_iteratee);
+  return _filter(eachfn, arr, (value, cb) => {
+    iteratee(value, (err, v) => {
+      cb(err, !v);
+    });
+  }, callback);
+}
+function reject(coll, iteratee, callback) {
+  return reject$2(eachOf$1, coll, iteratee, callback);
+}
+function rejectLimit(coll, limit, iteratee, callback) {
+  return reject$2(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function rejectSeries(coll, iteratee, callback) {
+  return reject$2(eachOfSeries$1, coll, iteratee, callback);
+}
+function constant(value) {
+  return function() {
+    return value;
+  };
+}
+function retry(opts, task, callback) {
+  var options = {
+    times: DEFAULT_TIMES,
+    intervalFunc: constant(DEFAULT_INTERVAL)
+  };
+  if (arguments.length < 3 && typeof opts === "function") {
+    callback = task || promiseCallback();
+    task = opts;
+  } else {
+    parseTimes(options, opts);
+    callback = callback || promiseCallback();
+  }
+  if (typeof task !== "function") {
+    throw new Error("Invalid arguments for async.retry");
+  }
+  var _task = wrapAsync(task);
+  var attempt = 1;
+  function retryAttempt() {
+    _task((err, ...args) => {
+      if (err === false) return;
+      if (err && attempt++ < options.times && (typeof options.errorFilter != "function" || options.errorFilter(err))) {
+        setTimeout(retryAttempt, options.intervalFunc(attempt - 1));
+      } else {
+        callback(err, ...args);
+      }
+    });
+  }
+  retryAttempt();
+  return callback[PROMISE_SYMBOL];
+}
+function parseTimes(acc, t) {
+  if (typeof t === "object") {
+    acc.times = +t.times || DEFAULT_TIMES;
+    acc.intervalFunc = typeof t.interval === "function" ? t.interval : constant(+t.interval || DEFAULT_INTERVAL);
+    acc.errorFilter = t.errorFilter;
+  } else if (typeof t === "number" || typeof t === "string") {
+    acc.times = +t || DEFAULT_TIMES;
+  } else {
+    throw new Error("Invalid arguments for async.retry");
+  }
+}
+function retryable(opts, task) {
+  if (!task) {
+    task = opts;
+    opts = null;
+  }
+  let arity = opts && opts.arity || task.length;
+  if (isAsync(task)) {
+    arity += 1;
+  }
+  var _task = wrapAsync(task);
+  return initialParams((args, callback) => {
+    if (args.length < arity - 1 || callback == null) {
+      args.push(callback);
+      callback = promiseCallback();
+    }
+    function taskFn(cb) {
+      _task(...args, cb);
+    }
+    if (opts) retry(opts, taskFn, callback);
+    else retry(taskFn, callback);
+    return callback[PROMISE_SYMBOL];
+  });
+}
+function series(tasks, callback) {
+  return _parallel(eachOfSeries$1, tasks, callback);
+}
+function some(coll, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOf$1, coll, iteratee, callback);
+}
+function someLimit(coll, limit, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOfLimit$2(limit), coll, iteratee, callback);
+}
+function someSeries(coll, iteratee, callback) {
+  return _createTester(Boolean, (res) => res)(eachOfSeries$1, coll, iteratee, callback);
+}
+function sortBy(coll, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return map$1(coll, (x, iterCb) => {
+    _iteratee(x, (err, criteria) => {
+      if (err) return iterCb(err);
+      iterCb(err, { value: x, criteria });
+    });
+  }, (err, results) => {
+    if (err) return callback(err);
+    callback(null, results.sort(comparator).map((v) => v.value));
+  });
+  function comparator(left, right) {
+    var a = left.criteria, b = right.criteria;
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+}
+function timeout(asyncFn, milliseconds, info) {
+  var fn = wrapAsync(asyncFn);
+  return initialParams((args, callback) => {
+    var timedOut = false;
+    var timer;
+    function timeoutCallback() {
+      var name = asyncFn.name || "anonymous";
+      var error = new Error('Callback function "' + name + '" timed out.');
+      error.code = "ETIMEDOUT";
+      if (info) {
+        error.info = info;
+      }
+      timedOut = true;
+      callback(error);
+    }
+    args.push((...cbArgs) => {
+      if (!timedOut) {
+        callback(...cbArgs);
+        clearTimeout(timer);
+      }
+    });
+    timer = setTimeout(timeoutCallback, milliseconds);
+    fn(...args);
+  });
+}
+function range(size) {
+  var result = Array(size);
+  while (size--) {
+    result[size] = size;
+  }
+  return result;
+}
+function timesLimit(count, limit, iteratee, callback) {
+  var _iteratee = wrapAsync(iteratee);
+  return mapLimit$1(range(count), limit, _iteratee, callback);
+}
+function times(n, iteratee, callback) {
+  return timesLimit(n, Infinity, iteratee, callback);
+}
+function timesSeries(n, iteratee, callback) {
+  return timesLimit(n, 1, iteratee, callback);
+}
+function transform(coll, accumulator, iteratee, callback) {
+  if (arguments.length <= 3 && typeof accumulator === "function") {
+    callback = iteratee;
+    iteratee = accumulator;
+    accumulator = Array.isArray(coll) ? [] : {};
+  }
+  callback = once(callback || promiseCallback());
+  var _iteratee = wrapAsync(iteratee);
+  eachOf$1(coll, (v, k, cb) => {
+    _iteratee(accumulator, v, k, cb);
+  }, (err) => callback(err, accumulator));
+  return callback[PROMISE_SYMBOL];
+}
+function tryEach(tasks, callback) {
+  var error = null;
+  var result;
+  return eachSeries$1(tasks, (task, taskCb) => {
+    wrapAsync(task)((err, ...args) => {
+      if (err === false) return taskCb(err);
+      if (args.length < 2) {
+        [result] = args;
+      } else {
+        result = args;
+      }
+      error = err;
+      taskCb(err ? null : {});
+    });
+  }, () => callback(error, result));
+}
+function unmemoize(fn) {
+  return (...args) => {
+    return (fn.unmemoized || fn)(...args);
+  };
+}
+function whilst(test, iteratee, callback) {
+  callback = onlyOnce(callback);
+  var _fn = wrapAsync(iteratee);
+  var _test = wrapAsync(test);
+  var results = [];
+  function next(err, ...rest) {
+    if (err) return callback(err);
+    results = rest;
+    if (err === false) return;
+    _test(check);
+  }
+  function check(err, truth) {
+    if (err) return callback(err);
+    if (err === false) return;
+    if (!truth) return callback(null, ...results);
+    _fn(next);
+  }
+  return _test(check);
+}
+function until(test, iteratee, callback) {
+  const _test = wrapAsync(test);
+  return whilst$1((cb) => _test((err, truth) => cb(err, !truth)), iteratee, callback);
+}
+function waterfall(tasks, callback) {
+  callback = once(callback);
+  if (!Array.isArray(tasks)) return callback(new Error("First argument to waterfall must be an array of functions"));
+  if (!tasks.length) return callback();
+  var taskIndex = 0;
+  function nextTask(args) {
+    var task = wrapAsync(tasks[taskIndex++]);
+    task(...args, onlyOnce(next));
+  }
+  function next(err, ...args) {
+    if (err === false) return;
+    if (err || taskIndex === tasks.length) {
+      return callback(err, ...args);
+    }
+    nextTask(args);
+  }
+  nextTask([]);
+}
+var hasQueueMicrotask, hasSetImmediate, hasNextTick, _defer$1, setImmediate$1, breakLoop, eachOfLimit$2, eachOfLimit$1, eachOf$1, map$1, applyEach, eachOfSeries$1, mapSeries$1, applyEachSeries, PROMISE_SYMBOL, FN_ARGS, ARROW_FN_ARGS, FN_ARG_SPLIT, FN_ARG, DLL, reduce$1, mapLimit$1, concatLimit$1, concat$1, concatSeries$1, detect$1, detectLimit$1, detectSeries$1, dir, doWhilst$1, each, eachLimit$1, eachSeries$1, every$1, everyLimit$1, everySeries$1, filter$1, filterLimit$1, filterSeries$1, forever$1, groupByLimit$1, log, mapValuesLimit$1, _defer, nextTick, _parallel, Heap, race$1, reject$1, rejectLimit$1, rejectSeries$1, DEFAULT_TIMES, DEFAULT_INTERVAL, some$1, someLimit$1, someSeries$1, sortBy$1, tryEach$1, whilst$1, waterfall$1, index;
+var init_async = __esm({
+  "../../../node_modules/async/dist/async.mjs"() {
+    "use strict";
+    hasQueueMicrotask = typeof queueMicrotask === "function" && queueMicrotask;
+    hasSetImmediate = typeof setImmediate === "function" && setImmediate;
+    hasNextTick = typeof process === "object" && typeof process.nextTick === "function";
+    if (hasQueueMicrotask) {
+      _defer$1 = queueMicrotask;
+    } else if (hasSetImmediate) {
+      _defer$1 = setImmediate;
+    } else if (hasNextTick) {
+      _defer$1 = process.nextTick;
+    } else {
+      _defer$1 = fallback;
+    }
+    setImmediate$1 = wrap(_defer$1);
+    breakLoop = {};
+    eachOfLimit$2 = (limit) => {
+      return (obj, iteratee, callback) => {
+        callback = once(callback);
+        if (limit <= 0) {
+          throw new RangeError("concurrency limit cannot be less than 1");
+        }
+        if (!obj) {
+          return callback(null);
+        }
+        if (isAsyncGenerator(obj)) {
+          return asyncEachOfLimit(obj, limit, iteratee, callback);
+        }
+        if (isAsyncIterable(obj)) {
+          return asyncEachOfLimit(obj[Symbol.asyncIterator](), limit, iteratee, callback);
+        }
+        var nextElem = createIterator(obj);
+        var done = false;
+        var canceled = false;
+        var running = 0;
+        var looping = false;
+        function iterateeCallback(err, value) {
+          if (canceled) return;
+          running -= 1;
+          if (err) {
+            done = true;
+            callback(err);
+          } else if (err === false) {
+            done = true;
+            canceled = true;
+          } else if (value === breakLoop || done && running <= 0) {
+            done = true;
+            return callback(null);
+          } else if (!looping) {
+            replenish();
+          }
+        }
+        function replenish() {
+          looping = true;
+          while (running < limit && !done) {
+            var elem = nextElem();
+            if (elem === null) {
+              done = true;
+              if (running <= 0) {
+                callback(null);
+              }
+              return;
+            }
+            running += 1;
+            iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
+          }
+          looping = false;
+        }
+        replenish();
+      };
+    };
+    eachOfLimit$1 = awaitify(eachOfLimit, 4);
+    eachOf$1 = awaitify(eachOf, 3);
+    map$1 = awaitify(map, 3);
+    applyEach = applyEach$1(map$1);
+    eachOfSeries$1 = awaitify(eachOfSeries, 3);
+    mapSeries$1 = awaitify(mapSeries, 3);
+    applyEachSeries = applyEach$1(mapSeries$1);
+    PROMISE_SYMBOL = /* @__PURE__ */ Symbol("promiseCallback");
+    FN_ARGS = /^(?:async\s)?(?:function)?\s*(?:\w+\s*)?\(([^)]+)\)(?:\s*{)/;
+    ARROW_FN_ARGS = /^(?:async\s)?\s*(?:\(\s*)?((?:[^)=\s]\s*)*)(?:\)\s*)?=>/;
+    FN_ARG_SPLIT = /,/;
+    FN_ARG = /(=.+)?(\s*)$/;
+    DLL = class {
+      constructor() {
+        this.head = this.tail = null;
+        this.length = 0;
+      }
+      removeLink(node) {
+        if (node.prev) node.prev.next = node.next;
+        else this.head = node.next;
+        if (node.next) node.next.prev = node.prev;
+        else this.tail = node.prev;
+        node.prev = node.next = null;
+        this.length -= 1;
+        return node;
+      }
+      empty() {
+        while (this.head) this.shift();
+        return this;
+      }
+      insertAfter(node, newNode) {
+        newNode.prev = node;
+        newNode.next = node.next;
+        if (node.next) node.next.prev = newNode;
+        else this.tail = newNode;
+        node.next = newNode;
+        this.length += 1;
+      }
+      insertBefore(node, newNode) {
+        newNode.prev = node.prev;
+        newNode.next = node;
+        if (node.prev) node.prev.next = newNode;
+        else this.head = newNode;
+        node.prev = newNode;
+        this.length += 1;
+      }
+      unshift(node) {
+        if (this.head) this.insertBefore(this.head, node);
+        else setInitial(this, node);
+      }
+      push(node) {
+        if (this.tail) this.insertAfter(this.tail, node);
+        else setInitial(this, node);
+      }
+      shift() {
+        return this.head && this.removeLink(this.head);
+      }
+      pop() {
+        return this.tail && this.removeLink(this.tail);
+      }
+      toArray() {
+        return [...this];
+      }
+      *[Symbol.iterator]() {
+        var cur = this.head;
+        while (cur) {
+          yield cur.data;
+          cur = cur.next;
+        }
+      }
+      remove(testFn) {
+        var curr = this.head;
+        while (curr) {
+          var { next } = curr;
+          if (testFn(curr)) {
+            this.removeLink(curr);
+          }
+          curr = next;
+        }
+        return this;
+      }
+    };
+    reduce$1 = awaitify(reduce, 4);
+    mapLimit$1 = awaitify(mapLimit, 4);
+    concatLimit$1 = awaitify(concatLimit, 4);
+    concat$1 = awaitify(concat, 3);
+    concatSeries$1 = awaitify(concatSeries, 3);
+    detect$1 = awaitify(detect, 3);
+    detectLimit$1 = awaitify(detectLimit, 4);
+    detectSeries$1 = awaitify(detectSeries, 3);
+    dir = consoleFunc("dir");
+    doWhilst$1 = awaitify(doWhilst, 3);
+    each = awaitify(eachLimit$2, 3);
+    eachLimit$1 = awaitify(eachLimit, 4);
+    eachSeries$1 = awaitify(eachSeries, 3);
+    every$1 = awaitify(every, 3);
+    everyLimit$1 = awaitify(everyLimit, 4);
+    everySeries$1 = awaitify(everySeries, 3);
+    filter$1 = awaitify(filter, 3);
+    filterLimit$1 = awaitify(filterLimit, 4);
+    filterSeries$1 = awaitify(filterSeries, 3);
+    forever$1 = awaitify(forever, 2);
+    groupByLimit$1 = awaitify(groupByLimit, 4);
+    log = consoleFunc("log");
+    mapValuesLimit$1 = awaitify(mapValuesLimit, 4);
+    if (hasNextTick) {
+      _defer = process.nextTick;
+    } else if (hasSetImmediate) {
+      _defer = setImmediate;
+    } else {
+      _defer = fallback;
+    }
+    nextTick = wrap(_defer);
+    _parallel = awaitify((eachfn, tasks, callback) => {
+      var results = isArrayLike(tasks) ? [] : {};
+      eachfn(tasks, (task, key, taskCb) => {
+        wrapAsync(task)((err, ...result) => {
+          if (result.length < 2) {
+            [result] = result;
+          }
+          results[key] = result;
+          taskCb(err);
+        });
+      }, (err) => callback(err, results));
+    }, 3);
+    Heap = class {
+      constructor() {
+        this.heap = [];
+        this.pushCount = Number.MIN_SAFE_INTEGER;
+      }
+      get length() {
+        return this.heap.length;
+      }
+      empty() {
+        this.heap = [];
+        return this;
+      }
+      percUp(index2) {
+        let p;
+        while (index2 > 0 && smaller(this.heap[index2], this.heap[p = parent(index2)])) {
+          let t = this.heap[index2];
+          this.heap[index2] = this.heap[p];
+          this.heap[p] = t;
+          index2 = p;
+        }
+      }
+      percDown(index2) {
+        let l;
+        while ((l = leftChi(index2)) < this.heap.length) {
+          if (l + 1 < this.heap.length && smaller(this.heap[l + 1], this.heap[l])) {
+            l = l + 1;
+          }
+          if (smaller(this.heap[index2], this.heap[l])) {
+            break;
+          }
+          let t = this.heap[index2];
+          this.heap[index2] = this.heap[l];
+          this.heap[l] = t;
+          index2 = l;
+        }
+      }
+      push(node) {
+        node.pushCount = ++this.pushCount;
+        this.heap.push(node);
+        this.percUp(this.heap.length - 1);
+      }
+      unshift(node) {
+        return this.heap.push(node);
+      }
+      shift() {
+        let [top] = this.heap;
+        this.heap[0] = this.heap[this.heap.length - 1];
+        this.heap.pop();
+        this.percDown(0);
+        return top;
+      }
+      toArray() {
+        return [...this];
+      }
+      *[Symbol.iterator]() {
+        for (let i = 0; i < this.heap.length; i++) {
+          yield this.heap[i].data;
+        }
+      }
+      remove(testFn) {
+        let j = 0;
+        for (let i = 0; i < this.heap.length; i++) {
+          if (!testFn(this.heap[i])) {
+            this.heap[j] = this.heap[i];
+            j++;
+          }
+        }
+        this.heap.splice(j);
+        for (let i = parent(this.heap.length - 1); i >= 0; i--) {
+          this.percDown(i);
+        }
+        return this;
+      }
+    };
+    race$1 = awaitify(race, 2);
+    reject$1 = awaitify(reject, 3);
+    rejectLimit$1 = awaitify(rejectLimit, 4);
+    rejectSeries$1 = awaitify(rejectSeries, 3);
+    DEFAULT_TIMES = 5;
+    DEFAULT_INTERVAL = 0;
+    some$1 = awaitify(some, 3);
+    someLimit$1 = awaitify(someLimit, 4);
+    someSeries$1 = awaitify(someSeries, 3);
+    sortBy$1 = awaitify(sortBy, 3);
+    tryEach$1 = awaitify(tryEach);
+    whilst$1 = awaitify(whilst, 3);
+    waterfall$1 = awaitify(waterfall);
+    index = {
+      apply,
+      applyEach,
+      applyEachSeries,
+      asyncify,
+      auto,
+      autoInject,
+      cargo: cargo$1,
+      cargoQueue: cargo,
+      compose,
+      concat: concat$1,
+      concatLimit: concatLimit$1,
+      concatSeries: concatSeries$1,
+      constant: constant$1,
+      detect: detect$1,
+      detectLimit: detectLimit$1,
+      detectSeries: detectSeries$1,
+      dir,
+      doUntil,
+      doWhilst: doWhilst$1,
+      each,
+      eachLimit: eachLimit$1,
+      eachOf: eachOf$1,
+      eachOfLimit: eachOfLimit$1,
+      eachOfSeries: eachOfSeries$1,
+      eachSeries: eachSeries$1,
+      ensureAsync,
+      every: every$1,
+      everyLimit: everyLimit$1,
+      everySeries: everySeries$1,
+      filter: filter$1,
+      filterLimit: filterLimit$1,
+      filterSeries: filterSeries$1,
+      forever: forever$1,
+      groupBy,
+      groupByLimit: groupByLimit$1,
+      groupBySeries,
+      log,
+      map: map$1,
+      mapLimit: mapLimit$1,
+      mapSeries: mapSeries$1,
+      mapValues,
+      mapValuesLimit: mapValuesLimit$1,
+      mapValuesSeries,
+      memoize,
+      nextTick,
+      parallel,
+      parallelLimit,
+      priorityQueue,
+      queue,
+      race: race$1,
+      reduce: reduce$1,
+      reduceRight,
+      reflect,
+      reflectAll,
+      reject: reject$1,
+      rejectLimit: rejectLimit$1,
+      rejectSeries: rejectSeries$1,
+      retry,
+      retryable,
+      seq,
+      series,
+      setImmediate: setImmediate$1,
+      some: some$1,
+      someLimit: someLimit$1,
+      someSeries: someSeries$1,
+      sortBy: sortBy$1,
+      timeout,
+      times,
+      timesLimit,
+      timesSeries,
+      transform,
+      tryEach: tryEach$1,
+      unmemoize,
+      until,
+      waterfall: waterfall$1,
+      whilst: whilst$1,
+      // aliases
+      all: every$1,
+      allLimit: everyLimit$1,
+      allSeries: everySeries$1,
+      any: some$1,
+      anyLimit: someLimit$1,
+      anySeries: someSeries$1,
+      find: detect$1,
+      findLimit: detectLimit$1,
+      findSeries: detectSeries$1,
+      flatMap: concat$1,
+      flatMapLimit: concatLimit$1,
+      flatMapSeries: concatSeries$1,
+      forEach: each,
+      forEachSeries: eachSeries$1,
+      forEachLimit: eachLimit$1,
+      forEachOf: eachOf$1,
+      forEachOfSeries: eachOfSeries$1,
+      forEachOfLimit: eachOfLimit$1,
+      inject: reduce$1,
+      foldl: reduce$1,
+      foldr: reduceRight,
+      select: filter$1,
+      selectLimit: filterLimit$1,
+      selectSeries: filterSeries$1,
+      wrapSync: asyncify,
+      during: whilst$1,
+      doDuring: doWhilst$1
+    };
+  }
+});
+
+// ../../../node_modules/tmp/lib/tmp.js
+var require_tmp = __commonJS({
+  "../../../node_modules/tmp/lib/tmp.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var os = __require("os");
+    var path = __require("path");
+    var crypto = __require("crypto");
+    var _c = { fs: fs.constants, os: os.constants };
+    var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    var TEMPLATE_PATTERN = /XXXXXX/;
+    var DEFAULT_TRIES = 3;
+    var CREATE_FLAGS = (_c.O_CREAT || _c.fs.O_CREAT) | (_c.O_EXCL || _c.fs.O_EXCL) | (_c.O_RDWR || _c.fs.O_RDWR);
+    var IS_WIN32 = os.platform() === "win32";
+    var EBADF = _c.EBADF || _c.os.errno.EBADF;
+    var ENOENT = _c.ENOENT || _c.os.errno.ENOENT;
+    var DIR_MODE = 448;
+    var FILE_MODE = 384;
+    var EXIT = "exit";
+    var _removeObjects = [];
+    var FN_RMDIR_SYNC = fs.rmdirSync.bind(fs);
+    var _gracefulCleanup = false;
+    function rimraf(dirPath, callback) {
+      return fs.rm(dirPath, { recursive: true }, callback);
+    }
+    function FN_RIMRAF_SYNC(dirPath) {
+      return fs.rmSync(dirPath, { recursive: true });
+    }
+    function tmpName(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      _assertAndSanitizeOptions(opts, function(err, sanitizedOptions) {
+        if (err) return cb(err);
+        let tries = sanitizedOptions.tries;
+        (function _getUniqueName() {
+          try {
+            const name = _generateTmpName(sanitizedOptions);
+            fs.stat(name, function(err2) {
+              if (!err2) {
+                if (tries-- > 0) return _getUniqueName();
+                return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
+              }
+              cb(null, name);
+            });
+          } catch (err2) {
+            cb(err2);
+          }
+        })();
+      });
+    }
+    function tmpNameSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
+      let tries = sanitizedOptions.tries;
+      do {
+        const name = _generateTmpName(sanitizedOptions);
+        try {
+          fs.statSync(name);
+        } catch (e) {
+          return name;
+        }
+      } while (tries-- > 0);
+      throw new Error("Could not get a unique tmp filename, max tries reached");
+    }
+    function file(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      tmpName(opts, function _tmpNameCreated(err, name) {
+        if (err) return cb(err);
+        fs.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+          if (err2) return cb(err2);
+          if (opts.discardDescriptor) {
+            return fs.close(fd, function _discardCallback(possibleErr) {
+              return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
+            });
+          } else {
+            const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+            cb(null, name, fd, _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, false));
+          }
+        });
+      });
+    }
+    function fileSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+      const name = tmpNameSync(opts);
+      let fd = fs.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      if (opts.discardDescriptor) {
+        fs.closeSync(fd);
+        fd = void 0;
+      }
+      return {
+        name,
+        fd,
+        removeCallback: _prepareTmpFileRemoveCallback(name, discardOrDetachDescriptor ? -1 : fd, opts, true)
+      };
+    }
+    function dir2(options, callback) {
+      const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
+      tmpName(opts, function _tmpNameCreated(err, name) {
+        if (err) return cb(err);
+        fs.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+          if (err2) return cb(err2);
+          cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
+        });
+      });
+    }
+    function dirSync(options) {
+      const args = _parseArguments(options), opts = args[0];
+      const name = tmpNameSync(opts);
+      fs.mkdirSync(name, opts.mode || DIR_MODE);
+      return {
+        name,
+        removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
+      };
+    }
+    function _removeFileAsync(fdPath, next) {
+      const _handler = function(err) {
+        if (err && !_isENOENT(err)) {
+          return next(err);
+        }
+        next();
+      };
+      if (0 <= fdPath[0])
+        fs.close(fdPath[0], function() {
+          fs.unlink(fdPath[1], _handler);
+        });
+      else fs.unlink(fdPath[1], _handler);
+    }
+    function _removeFileSync(fdPath) {
+      let rethrownException = null;
+      try {
+        if (0 <= fdPath[0]) fs.closeSync(fdPath[0]);
+      } catch (e) {
+        if (!_isEBADF(e) && !_isENOENT(e)) throw e;
+      } finally {
+        try {
+          fs.unlinkSync(fdPath[1]);
+        } catch (e) {
+          if (!_isENOENT(e)) rethrownException = e;
+        }
+      }
+      if (rethrownException !== null) {
+        throw rethrownException;
+      }
+    }
+    function _prepareTmpFileRemoveCallback(name, fd, opts, sync) {
+      const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name], sync);
+      const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name], sync, removeCallbackSync);
+      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+      return sync ? removeCallbackSync : removeCallback;
+    }
+    function _prepareTmpDirRemoveCallback(name, opts, sync) {
+      const removeFunction = opts.unsafeCleanup ? rimraf : fs.rmdir.bind(fs);
+      const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
+      const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
+      const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
+      if (!opts.keep) _removeObjects.unshift(removeCallbackSync);
+      return sync ? removeCallbackSync : removeCallback;
+    }
+    function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
+      let called = false;
+      return function _cleanupCallback(next) {
+        if (!called) {
+          const toRemove = cleanupCallbackSync || _cleanupCallback;
+          const index2 = _removeObjects.indexOf(toRemove);
+          if (index2 >= 0) _removeObjects.splice(index2, 1);
+          called = true;
+          if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
+            return removeFunction(fileOrDirName);
+          } else {
+            return removeFunction(fileOrDirName, next || function() {
+            });
+          }
+        }
+      };
+    }
+    function _garbageCollector() {
+      if (!_gracefulCleanup) return;
+      while (_removeObjects.length) {
+        try {
+          _removeObjects[0]();
+        } catch (e) {
+        }
+      }
+    }
+    function _randomChars(howMany) {
+      let value = [], rnd = null;
+      try {
+        rnd = crypto.randomBytes(howMany);
+      } catch (e) {
+        rnd = crypto.pseudoRandomBytes(howMany);
+      }
+      for (let i = 0; i < howMany; i++) {
+        value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
+      }
+      return value.join("");
+    }
+    function _isUndefined(obj) {
+      return typeof obj === "undefined";
+    }
+    function _parseArguments(options, callback) {
+      if (typeof options === "function") {
+        return [{}, options];
+      }
+      if (_isUndefined(options)) {
+        return [{}, callback];
+      }
+      const actualOptions = {};
+      for (const key of Object.getOwnPropertyNames(options)) {
+        actualOptions[key] = options[key];
+      }
+      return [actualOptions, callback];
+    }
+    function _resolvePath(name, tmpDir, cb) {
+      const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+      fs.stat(pathToResolve, function(err) {
+        if (err) {
+          fs.realpath(path.dirname(pathToResolve), function(err2, parentDir) {
+            if (err2) return cb(err2);
+            cb(null, path.join(parentDir, path.basename(pathToResolve)));
+          });
+        } else {
+          fs.realpath(pathToResolve, cb);
+        }
+      });
+    }
+    function _resolvePathSync(name, tmpDir) {
+      const pathToResolve = path.isAbsolute(name) ? name : path.join(tmpDir, name);
+      try {
+        fs.statSync(pathToResolve);
+        return fs.realpathSync(pathToResolve);
+      } catch (_err) {
+        const parentDir = fs.realpathSync(path.dirname(pathToResolve));
+        return path.join(parentDir, path.basename(pathToResolve));
+      }
+    }
+    function _generateTmpName(opts) {
+      const tmpDir = opts.tmpdir;
+      if (!_isUndefined(opts.name)) {
+        return path.join(tmpDir, opts.dir, opts.name);
+      }
+      if (!_isUndefined(opts.template)) {
+        return path.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+      }
+      const name = [
+        opts.prefix ? opts.prefix : "tmp",
+        "-",
+        process.pid,
+        "-",
+        _randomChars(12),
+        opts.postfix ? "-" + opts.postfix : ""
+      ].join("");
+      return path.join(tmpDir, opts.dir, name);
+    }
+    function _assertOptionsBase(options) {
+      if (!_isUndefined(options.name)) {
+        const name = options.name;
+        if (path.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
+        const basename3 = path.basename(name);
+        if (basename3 === ".." || basename3 === "." || basename3 !== name)
+          throw new Error(`name option must not contain a path, found "${name}".`);
+      }
+      if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
+        throw new Error(`Invalid template, found "${options.template}".`);
+      }
+      if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0) {
+        throw new Error(`Invalid tries, found "${options.tries}".`);
+      }
+      options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
+      options.keep = !!options.keep;
+      options.detachDescriptor = !!options.detachDescriptor;
+      options.discardDescriptor = !!options.discardDescriptor;
+      options.unsafeCleanup = !!options.unsafeCleanup;
+      options.prefix = _isUndefined(options.prefix) ? "" : options.prefix;
+      options.postfix = _isUndefined(options.postfix) ? "" : options.postfix;
+    }
+    function _getRelativePath(option, name, tmpDir, cb) {
+      if (_isUndefined(name)) return cb(null);
+      _resolvePath(name, tmpDir, function(err, resolvedPath) {
+        if (err) return cb(err);
+        const relativePath = path.relative(tmpDir, resolvedPath);
+        if (!resolvedPath.startsWith(tmpDir)) {
+          return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+        }
+        cb(null, relativePath);
+      });
+    }
+    function _getRelativePathSync(option, name, tmpDir) {
+      if (_isUndefined(name)) return;
+      const resolvedPath = _resolvePathSync(name, tmpDir);
+      const relativePath = path.relative(tmpDir, resolvedPath);
+      if (!resolvedPath.startsWith(tmpDir)) {
+        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
+      }
+      return relativePath;
+    }
+    function _assertAndSanitizeOptions(options, cb) {
+      _getTmpDir(options, function(err, tmpDir) {
+        if (err) return cb(err);
+        options.tmpdir = tmpDir;
+        try {
+          _assertOptionsBase(options, tmpDir);
+        } catch (err2) {
+          return cb(err2);
+        }
+        _getRelativePath("dir", options.dir, tmpDir, function(err2, dir3) {
+          if (err2) return cb(err2);
+          options.dir = _isUndefined(dir3) ? "" : dir3;
+          _getRelativePath("template", options.template, tmpDir, function(err3, template) {
+            if (err3) return cb(err3);
+            options.template = template;
+            cb(null, options);
+          });
+        });
+      });
+    }
+    function _assertAndSanitizeOptionsSync(options) {
+      const tmpDir = options.tmpdir = _getTmpDirSync(options);
+      _assertOptionsBase(options, tmpDir);
+      const dir3 = _getRelativePathSync("dir", options.dir, tmpDir);
+      options.dir = _isUndefined(dir3) ? "" : dir3;
+      options.template = _getRelativePathSync("template", options.template, tmpDir);
+      return options;
+    }
+    function _isEBADF(error) {
+      return _isExpectedError(error, -EBADF, "EBADF");
+    }
+    function _isENOENT(error) {
+      return _isExpectedError(error, -ENOENT, "ENOENT");
+    }
+    function _isExpectedError(error, errno, code) {
+      return IS_WIN32 ? error.code === code : error.code === code && error.errno === errno;
+    }
+    function setGracefulCleanup() {
+      _gracefulCleanup = true;
+    }
+    function _getTmpDir(options, cb) {
+      return fs.realpath(options && options.tmpdir || os.tmpdir(), cb);
+    }
+    function _getTmpDirSync(options) {
+      return fs.realpathSync(options && options.tmpdir || os.tmpdir());
+    }
+    process.addListener(EXIT, _garbageCollector);
+    Object.defineProperty(module.exports, "tmpdir", {
+      enumerable: true,
+      configurable: false,
+      get: function() {
+        return _getTmpDirSync();
+      }
+    });
+    module.exports.dir = dir2;
+    module.exports.dirSync = dirSync;
+    module.exports.file = file;
+    module.exports.fileSync = fileSync;
+    module.exports.tmpName = tmpName;
+    module.exports.tmpNameSync = tmpNameSync;
+    module.exports.setGracefulCleanup = setGracefulCleanup;
+  }
+});
+
+// ../../../node_modules/libreoffice-convert/index.js
+var require_libreoffice_convert = __commonJS({
+  "../../../node_modules/libreoffice-convert/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var url = __require("url");
+    var async = (init_async(), __toCommonJS(async_exports));
+    var tmp = require_tmp();
+    var { execFile } = __require("child_process");
+    var convertWithOptions = (document, format, filter2, options, callback) => {
+      const tmpOptions = (options || {}).tmpOptions || {};
+      const asyncOptions = (options || {}).asyncOptions || {};
+      const execOptions = (options || {}).execOptions || {};
+      const fileName = (options || {}).fileName || "source";
+      const sofficeAdditionalArgs = (options || {}).sofficeAdditionalArgs || [];
+      const tempDir = tmp.dirSync({ prefix: "libreofficeConvert_", unsafeCleanup: true, ...tmpOptions });
+      const installDir = tmp.dirSync({ prefix: "soffice", unsafeCleanup: true, ...tmpOptions });
+      return async.auto({
+        soffice: (callback2) => {
+          let paths = (options || {}).sofficeBinaryPaths || [];
+          switch (process.platform) {
+            case "darwin":
+              paths = [...paths, "/Applications/LibreOffice.app/Contents/MacOS/soffice"];
+              break;
+            case "linux":
+              paths = [...paths, "/usr/bin/libreoffice", "/usr/bin/soffice", "/snap/bin/libreoffice", "/opt/libreoffice/program/soffice", "/opt/libreoffice7.6/program/soffice"];
+              break;
+            case "win32":
+              paths = [
+                ...paths,
+                path.join(process.env["PROGRAMFILES(X86)"] || "", "LIBREO~1/program/soffice.exe"),
+                path.join(process.env["PROGRAMFILES(X86)"] || "", "LibreOffice/program/soffice.exe"),
+                path.join(process.env.PROGRAMFILES_X86 || "", "LibreOffice/program/soffice.exe"),
+                path.join(process.env.PROGRAMFILES || "", "LibreOffice/program/soffice.exe"),
+                process.env.LIBRE_OFFICE_EXE || "",
+                "C:/Program Files/LibreOffice/program/soffice.exe"
+              ];
+              break;
+            default:
+              return callback2(new Error(`Operating system not yet supported: ${process.platform}`));
+          }
+          return async.filter(
+            paths,
+            (filePath, callback3) => fs.access(filePath, (err) => callback3(null, !err)),
+            (err, res) => {
+              if (res.length === 0) {
+                return callback2(new Error("Could not find soffice binary"));
+              }
+              return callback2(null, res[0]);
+            }
+          );
+        },
+        saveSource: (callback2) => fs.writeFile(path.join(tempDir.name, fileName), document, callback2),
+        convert: ["soffice", "saveSource", (results, callback2) => {
+          let filterParam = filter2?.length ? `:${filter2}` : "";
+          let fmt = !(filter2 ?? "").includes(" ") ? `${format}${filterParam}` : `"${format}${filterParam}"`;
+          let args = [];
+          args.push(`-env:UserInstallation=${url.pathToFileURL(installDir.name)}`);
+          args.push("--headless");
+          args.push("--convert-to");
+          args.push(fmt);
+          args.push("--outdir");
+          args.push(tempDir.name);
+          args.push(...sofficeAdditionalArgs);
+          args.push(path.join(tempDir.name, fileName));
+          return execFile(results.soffice, args, execOptions, (err, stdout, stderr) => {
+            if (stderr && stderr.toLowerCase().includes("error"))
+              callback2(new Error("Error calling soffice: " + stderr));
+            else callback2(err, stdout, stderr);
+          });
+        }],
+        loadDestination: [
+          "convert",
+          (results, callback2) => async.retry({
+            times: asyncOptions.times || 3,
+            interval: asyncOptions.interval || 200
+          }, (callback3) => fs.readFile(path.join(tempDir.name, `${fileName.slice(0, fileName.length - path.extname(fileName).length)}.${format.split(":")[0]}`), callback3), callback2)
+        ]
+      }).then((res) => {
+        return callback(null, res.loadDestination);
+      }).catch((err) => {
+        return callback(err);
+      }).finally(() => {
+        tempDir.removeCallback();
+        installDir.removeCallback();
+      });
+    };
+    var convert = (document, format, filter2, callback) => {
+      return convertWithOptions(document, format, filter2, {}, callback);
+    };
+    module.exports = {
+      convert,
+      convertWithOptions
+    };
+  }
+});
+
 // src/index.ts
 import { readFile as readFile2 } from "fs/promises";
 
@@ -3035,7 +5350,7 @@ import JSZip2 from "jszip";
 import { DOMParser } from "@xmldom/xmldom";
 
 // src/utils.ts
-var VERSION = true ? "2.4.19" : "0.0.0-dev";
+var VERSION = true ? "2.5.0" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -3428,7 +5743,7 @@ async function extractHwpxStyles(zip, decompressed) {
   }
   return result;
 }
-function parseCharProperties(doc, map) {
+function parseCharProperties(doc, map2) {
   const tagNames = ["hh:charPr", "charPr", "hp:charPr"];
   for (const tagName of tagNames) {
     const elements = doc.getElementsByTagName(tagName);
@@ -3455,11 +5770,11 @@ function parseCharProperties(doc, map) {
           }
         }
       }
-      map.set(id, prop);
+      map2.set(id, prop);
     }
   }
 }
-function parseStyleElements(doc, map) {
+function parseStyleElements(doc, map2) {
   const tagNames = ["hh:style", "style", "hp:style"];
   for (const tagName of tagNames) {
     const elements = doc.getElementsByTagName(tagName);
@@ -3469,7 +5784,7 @@ function parseStyleElements(doc, map) {
       const name = el.getAttribute("name") || el.getAttribute("engName") || "";
       const charPrId = el.getAttribute("charPrIDRef") || void 0;
       const paraPrId = el.getAttribute("paraPrIDRef") || void 0;
-      map.set(id, { name, charPrId, paraPrId });
+      map2.set(id, { name, charPrId, paraPrId });
     }
   }
 }
@@ -3995,9 +6310,9 @@ function walkParagraphChildren(node, blocks, tableCtx, tableStack, styleMap, war
   if (depth > MAX_XML_DEPTH) return tableCtx;
   const children = node.childNodes;
   if (!children) return tableCtx;
-  const walkChildren = (parent, d) => {
+  const walkChildren = (parent2, d) => {
     if (d > MAX_XML_DEPTH) return;
-    const kids = parent.childNodes;
+    const kids = parent2.childNodes;
     if (!kids) return;
     for (let i = 0; i < kids.length; i++) {
       const el = kids[i];
@@ -6210,17 +8525,17 @@ function lineOverlapRatio(a1, a2, b1, b2) {
   return overlap / target;
 }
 function groupConnectedLines(lines) {
-  const parent = lines.map((_, i) => i);
+  const parent2 = lines.map((_, i) => i);
   function find2(x) {
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
+    while (parent2[x] !== x) {
+      parent2[x] = parent2[parent2[x]];
+      x = parent2[x];
     }
     return x;
   }
   function union(a, b) {
     const ra = find2(a), rb = find2(b);
-    if (ra !== rb) parent[ra] = rb;
+    if (ra !== rb) parent2[ra] = rb;
   }
   for (let i = 0; i < lines.length; i++) {
     for (let j = i + 1; j < lines.length; j++) {
@@ -6641,10 +8956,10 @@ async function loadPdfWithTimeout(buffer) {
   try {
     return await Promise.race([
       loadingTask.promise,
-      new Promise((_, reject) => {
+      new Promise((_, reject2) => {
         timer = setTimeout(() => {
           loadingTask.destroy();
-          reject(new KordocError(`PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (${timeoutSec}\uCD08 \uCD08\uACFC)`));
+          reject2(new KordocError(`PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (${timeoutSec}\uCD08 \uCD08\uACFC)`));
         }, timeoutMs);
       })
     ]);
@@ -6833,10 +9148,10 @@ async function parsePdfDocument(buffer, options) {
       }
       const { resolveOcrProvider: resolveOcrProvider2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
       const { ocrPages: ocrPages2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
-      const tryProvider = async (provider, filter) => {
+      const tryProvider = async (provider, filter2) => {
         try {
-          logger.log({ level: "debug", stage: "ocr", event: "progress", message: "OCR provider \uC2E4\uD589", meta: { filteredPages: filter?.size } });
-          return await ocrPages2(doc, provider, filter, effectivePageCount, warnings, concurrency, options?.onProgress);
+          logger.log({ level: "debug", stage: "ocr", event: "progress", message: "OCR provider \uC2E4\uD589", meta: { filteredPages: filter2?.size } });
+          return await ocrPages2(doc, provider, filter2, effectivePageCount, warnings, concurrency, options?.onProgress);
         } catch {
           logger.log({ level: "warn", stage: "ocr", event: "progress", message: "OCR provider \uC2E4\uD589 \uC2E4\uD328(\uBE48 \uACB0\uACFC\uB85C \uCC98\uB9AC)" });
           return [];
@@ -7851,8 +10166,8 @@ function parseMergeRef(ref) {
   if (!start || !end) return null;
   return { startCol: start.col, startRow: start.row, endCol: end.col, endRow: end.row };
 }
-function getElements(parent, tagName) {
-  const nodes = parent.getElementsByTagName(tagName);
+function getElements(parent2, tagName) {
+  const nodes = parent2.getElementsByTagName(tagName);
   const result = [];
   for (let i = 0; i < nodes.length; i++) result.push(nodes[i]);
   return result;
@@ -7888,14 +10203,14 @@ function parseWorkbook(xml) {
 }
 function parseRels(xml) {
   const doc = parseXml(xml);
-  const map = /* @__PURE__ */ new Map();
+  const map2 = /* @__PURE__ */ new Map();
   const rels = getElements(doc.documentElement, "Relationship");
   for (const rel of rels) {
     const id = rel.getAttribute("Id");
     const target = rel.getAttribute("Target");
-    if (id && target) map.set(id, target);
+    if (id && target) map2.set(id, target);
   }
-  return map;
+  return map2;
 }
 function parseWorksheet(xml, sharedStrings) {
   const doc = parseXml(xml);
@@ -8153,9 +10468,9 @@ import JSZip4 from "jszip";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 init_logger();
 var MAX_DECOMPRESS_SIZE4 = 500 * 1024 * 1024;
-function getChildElements(parent, localName) {
+function getChildElements(parent2, localName) {
   const result = [];
-  const children = parent.childNodes;
+  const children = parent2.childNodes;
   for (let i = 0; i < children.length; i++) {
     const node = children[i];
     if (node.nodeType === 1) {
@@ -8167,7 +10482,7 @@ function getChildElements(parent, localName) {
   }
   return result;
 }
-function findElements(parent, localName) {
+function findElements(parent2, localName) {
   const result = [];
   const walk = (node) => {
     const children = node.childNodes;
@@ -8182,7 +10497,7 @@ function findElements(parent, localName) {
       }
     }
   };
-  walk(parent);
+  walk(parent2);
   return result;
 }
 function getAttr(el, localName) {
@@ -8197,7 +10512,7 @@ function parseXml2(text) {
   return new DOMParser3().parseFromString(text, "text/xml");
 }
 function buildElementIndex(root) {
-  const index = /* @__PURE__ */ new Map();
+  const index2 = /* @__PURE__ */ new Map();
   const walk = (node) => {
     const children = node.childNodes;
     for (let i = 0; i < children.length; i++) {
@@ -8206,10 +10521,10 @@ function buildElementIndex(root) {
         const el = child;
         const name = el.localName ?? "";
         if (name) {
-          let list = index.get(name);
+          let list = index2.get(name);
           if (!list) {
             list = [];
-            index.set(name, list);
+            index2.set(name, list);
           }
           list.push(el);
         }
@@ -8218,7 +10533,7 @@ function buildElementIndex(root) {
     }
   };
   walk(root);
-  return index;
+  return index2;
 }
 function parseStyles(xml) {
   const doc = parseXml2(xml);
@@ -8284,14 +10599,14 @@ function parseNumbering(xml) {
 }
 function parseRels2(xml) {
   const doc = parseXml2(xml);
-  const map = /* @__PURE__ */ new Map();
+  const map2 = /* @__PURE__ */ new Map();
   const rels = findElements(doc, "Relationship");
   for (const rel of rels) {
     const id = getAttr(rel, "Id");
     const target = getAttr(rel, "Target");
-    if (id && target) map.set(id, target);
+    if (id && target) map2.set(id, target);
   }
-  return map;
+  return map2;
 }
 function parseFootnotes(xml) {
   const doc = parseXml2(xml);
@@ -10134,22 +12449,22 @@ function findCharPrByCharacteristic(charPrMap, characteristic) {
     italic: { minHeight: 800, maxHeight: 1100, needBold: false },
     normal: { minHeight: 900, maxHeight: 1100, needBold: false }
   };
-  const range = ranges[characteristic];
-  if (!range) return null;
+  const range2 = ranges[characteristic];
+  if (!range2) return null;
   let bestMatch = null;
   let bestScore = 0;
   for (const [id, prop] of charPrMap) {
     let score = 0;
     if (prop.height) {
-      if (prop.height >= range.minHeight && prop.height <= range.maxHeight) {
+      if (prop.height >= range2.minHeight && prop.height <= range2.maxHeight) {
         score += 50;
-      } else if (Math.abs(prop.height - (range.minHeight + range.maxHeight) / 2) < 100) {
+      } else if (Math.abs(prop.height - (range2.minHeight + range2.maxHeight) / 2) < 100) {
         score += 20;
       }
     }
-    if (range.needBold !== void 0) {
-      if (range.needBold && prop.bold) score += 30;
-      else if (!range.needBold && !prop.bold) score += 20;
+    if (range2.needBold !== void 0) {
+      if (range2.needBold && prop.bold) score += 30;
+      else if (!range2.needBold && !prop.bold) score += 20;
     }
     if (characteristic === "italic" && prop.italic) score += 20;
     if (score > bestScore) {
@@ -10988,10 +13303,10 @@ function mimeToExtension(mimeType) {
   return "png";
 }
 function buildImageMap(images) {
-  const map = /* @__PURE__ */ new Map();
-  if (!images) return map;
-  for (const img of images) map.set(img.filename, img);
-  return map;
+  const map2 = /* @__PURE__ */ new Map();
+  if (!images) return map2;
+  for (const img of images) map2.set(img.filename, img);
+  return map2;
 }
 async function fillBodySheet(sheet, workbook, blocks, imageMap) {
   sheet.getColumn(1).width = 80;
@@ -11193,8 +13508,8 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
     const s = this.find(keyId);
     s.failureCount++;
     s.consecutiveFailures++;
-    const retryable = this.isRetryableFailure(opts.status, opts.timeout);
-    if (!retryable) return;
+    const retryable2 = this.isRetryableFailure(opts.status, opts.timeout);
+    if (!retryable2) return;
     const exp = Math.max(0, s.consecutiveFailures - 1);
     const backoff = Math.min(this.baseCooldownMs * 2 ** exp, this.maxCooldownMs);
     const cooldown = Math.max(backoff, opts.retryAfterMs ?? 0);
@@ -11211,8 +13526,8 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
       cooldownUntil: s.cooldownUntil
     }));
   }
-  isRetryableFailure(status, timeout) {
-    if (timeout) return true;
+  isRetryableFailure(status, timeout2) {
+    if (timeout2) return true;
     if (status === 429) return true;
     if (typeof status === "number" && status >= 500) return true;
     return false;
@@ -11226,12 +13541,172 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
 
 // src/pipeline/unified-ocr.ts
 import { mkdir, readdir, readFile, stat, writeFile } from "fs/promises";
-import { basename as basename2, dirname as dirname3, extname, join as join4, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname3, extname, join as join5, resolve as resolve3 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { performance } from "perf_hooks";
-import libre from "libreoffice-convert";
 init_logger();
-var libreConvert = libre.convert;
+
+// src/setup/detect.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync } from "fs";
+import { join as join4 } from "path";
+var isWin = process.platform === "win32";
+function which(cmd) {
+  const finder = isWin ? "where" : "which";
+  const r = spawnSync2(finder, [cmd], { encoding: "utf8", shell: isWin });
+  if (r.status !== 0) return void 0;
+  return r.stdout.split(/\r?\n/).find(Boolean)?.trim();
+}
+function resolveCmd(cmd, envKey) {
+  const override = process.env[envKey];
+  if (override) return override;
+  const found = which(cmd);
+  if (found) return found;
+  if (isWin) return findWinCandidate(cmd);
+  return void 0;
+}
+function findWinCandidate(cmd) {
+  const exe = cmd.endsWith(".exe") ? cmd : `${cmd}.exe`;
+  const userProfile = process.env["USERPROFILE"] ?? "C:\\Users\\Default";
+  const localAppData = process.env["LOCALAPPDATA"] ?? join4(userProfile, "AppData", "Local");
+  const programFiles = process.env["ProgramFiles"] ?? "C:\\Program Files";
+  const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+  const isPopplerExe = ["pdftoppm.exe", "pdfinfo.exe", "pdftotext.exe"].includes(exe);
+  const isSoffice = exe === "soffice.exe";
+  if (isPopplerExe) return findPopplerWin(exe, { userProfile, localAppData, programFiles, programFilesX86 });
+  if (isSoffice) return findSofficeWin({ programFiles, programFilesX86, localAppData });
+  return void 0;
+}
+function findPopplerWin(exe, p) {
+  const scoopPath = join4(p.userProfile, "scoop", "apps", "poppler", "current", "bin", exe);
+  if (existsSync(scoopPath)) return scoopPath;
+  const wingetBase = join4(p.localAppData, "Microsoft", "WinGet", "Packages");
+  const wingetResult = globFirst(wingetBase, ["oschwartz10612.Poppler_*"], ["poppler-*", "Library", "bin", exe]);
+  if (wingetResult) return wingetResult;
+  const chocoBase = join4("C:", "ProgramData", "chocolatey", "lib", "poppler", "tools");
+  const chocoResult = globFirst(chocoBase, ["poppler-*"], ["bin", exe]);
+  if (chocoResult) return chocoResult;
+  for (const base of [
+    join4("C:", "poppler", "bin", exe),
+    join4("C:", "tools", "poppler", "bin", exe),
+    join4(p.programFiles, "poppler", "bin", exe),
+    join4(p.programFilesX86, "poppler", "bin", exe),
+    join4(p.localAppData, "Programs", "poppler", "bin", exe)
+  ]) {
+    if (existsSync(base)) return base;
+  }
+  return void 0;
+}
+function findSofficeWin(p) {
+  for (const candidate of [
+    join4(p.programFiles, "LibreOffice", "program", "soffice.exe"),
+    join4(p.programFilesX86, "LibreOffice", "program", "soffice.exe"),
+    join4(p.localAppData, "Programs", "LibreOffice", "program", "soffice.exe"),
+    // winget 설치는 Program Files와 동일
+    join4(p.programFiles, "LibreOffice 24", "program", "soffice.exe"),
+    join4(p.programFiles, "LibreOffice 25", "program", "soffice.exe")
+  ]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function globFirst(base, wildcardSegments, rest) {
+  if (!existsSync(base)) return void 0;
+  let current = base;
+  for (const seg of wildcardSegments) {
+    if (!seg.includes("*")) {
+      current = join4(current, seg);
+      if (!existsSync(current)) return void 0;
+      continue;
+    }
+    try {
+      const { readdirSync } = __require("fs");
+      const entries = readdirSync(current);
+      const pattern = seg.replace(/\*/g, ".*");
+      const re = new RegExp(`^${pattern}$`, "i");
+      const match = entries.find((e) => re.test(e));
+      if (!match) return void 0;
+      current = join4(current, match);
+    } catch {
+      return void 0;
+    }
+  }
+  const final = join4(current, ...rest);
+  return existsSync(final) ? final : void 0;
+}
+function probe(cmd, envKey, versionArgs = ["--version"]) {
+  const resolvedPath = resolveCmd(cmd, envKey);
+  if (!resolvedPath) return { name: cmd, found: false };
+  const v = spawnSync2(resolvedPath, versionArgs, { encoding: "utf8", shell: isWin });
+  const versionLine = (v.stdout || v.stderr).split(/\r?\n/)[0]?.trim();
+  return { name: cmd, found: true, path: resolvedPath, version: versionLine };
+}
+function probeOcrToolchain() {
+  return {
+    // poppler는 --version이 비표준이므로 -v 사용
+    pdftoppm: probe("pdftoppm", "KORDOC_PDFTOPPM_PATH", ["-v"]),
+    pdfinfo: probe("pdfinfo", "KORDOC_PDFINFO_PATH", ["-v"]),
+    pdftotext: probe("pdftotext", "KORDOC_PDFTOTEXT_PATH", ["-v"]),
+    soffice: probe("soffice", "KORDOC_SOFFICE_PATH", ["--version"])
+  };
+}
+
+// src/setup/pm.ts
+import { spawnSync as spawnSync3 } from "child_process";
+var isWin2 = process.platform === "win32";
+function which2(cmd) {
+  const finder = isWin2 ? "where" : "which";
+  const r = spawnSync3(finder, [cmd], { encoding: "utf8", shell: isWin2 });
+  return r.status === 0;
+}
+function detectPackageManager() {
+  if (process.platform === "darwin") {
+    return which2("brew") ? "brew" : "unknown";
+  }
+  if (isWin2) {
+    if (which2("winget")) return "winget";
+    if (which2("scoop")) return "scoop";
+    if (which2("choco")) return "choco";
+    return "unknown";
+  }
+  if (which2("apt-get") || which2("apt")) return "apt";
+  if (which2("dnf")) return "dnf";
+  if (which2("yum")) return "yum";
+  if (which2("pacman")) return "pacman";
+  if (which2("zypper")) return "zypper";
+  if (which2("apk")) return "apk";
+  return "unknown";
+}
+
+// src/setup/install-commands.ts
+var POPPLER_RECIPES = {
+  brew: { pm: "brew", cmd: "brew install poppler", needsSudo: false },
+  winget: { pm: "winget", cmd: "winget install --id oschwartz10612.Poppler", needsSudo: false, notes: "\uC2E4\uC874 \uD655\uC778\uB428 (winget-pkgs 25.07.0-0)" },
+  scoop: { pm: "scoop", cmd: "scoop install poppler", needsSudo: false, notes: "main \uBC84\uD0B7 \uD3EC\uD568, PATH \uC790\uB3D9 \uB4F1\uB85D" },
+  choco: { pm: "choco", cmd: "choco install poppler -y", needsSudo: true, notes: "\uAD00\uB9AC\uC790 PowerShell \uD544\uC694" },
+  apt: { pm: "apt", cmd: "sudo apt-get install -y poppler-utils", needsSudo: true },
+  dnf: { pm: "dnf", cmd: "sudo dnf install -y poppler-utils", needsSudo: true },
+  yum: { pm: "yum", cmd: "sudo yum install -y poppler-utils", needsSudo: true },
+  pacman: { pm: "pacman", cmd: "sudo pacman -S --noconfirm poppler", needsSudo: true },
+  zypper: { pm: "zypper", cmd: "sudo zypper install -y poppler-tools", needsSudo: true },
+  apk: { pm: "apk", cmd: "apk add --no-cache poppler-utils", needsSudo: false, notes: "Alpine/Docker \uCE5C\uD654" },
+  unknown: null
+};
+var LIBREOFFICE_RECIPES = {
+  brew: { pm: "brew", cmd: "brew install --cask libreoffice", needsSudo: false },
+  winget: { pm: "winget", cmd: "winget install --id TheDocumentFoundation.LibreOffice", needsSudo: false, notes: "\uC2E4\uC874 \uD655\uC778\uB428" },
+  scoop: { pm: "scoop", cmd: "scoop bucket add extras && scoop install libreoffice", needsSudo: false },
+  choco: { pm: "choco", cmd: "choco install libreoffice-fresh -y", needsSudo: true, notes: "\uAD00\uB9AC\uC790 PowerShell \uD544\uC694" },
+  apt: { pm: "apt", cmd: "sudo apt-get install -y libreoffice", needsSudo: true },
+  dnf: { pm: "dnf", cmd: "sudo dnf install -y libreoffice", needsSudo: true },
+  yum: { pm: "yum", cmd: "sudo yum install -y libreoffice", needsSudo: true },
+  pacman: { pm: "pacman", cmd: "sudo pacman -S --noconfirm libreoffice-still", needsSudo: true },
+  zypper: { pm: "zypper", cmd: "sudo zypper install -y libreoffice", needsSudo: true },
+  apk: { pm: "apk", cmd: "apk add --no-cache libreoffice", needsSudo: false, notes: "Alpine \uBBF8\uC9C0\uC6D0 \uAC00\uB2A5 \u2014 node:20-slim(Debian) \uAD8C\uC7A5" },
+  unknown: null
+};
+
+// src/pipeline/unified-ocr.ts
 var UnifiedOcrError = class extends Error {
   code;
   stage;
@@ -11305,13 +13780,13 @@ function elapsedMs(startAt) {
 async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const absInput = resolve3(inputPath);
   const stem = basename2(absInput, extname(absInput));
-  const workspaceDir = resolve3(options.workspaceDir ?? join4(dirname3(absInput), `${stem}_ocr_workspace`));
-  const imagesDir = join4(workspaceDir, "images");
-  const rawDir = join4(workspaceDir, "ocr", "raw");
-  const diffDir = join4(workspaceDir, "ocr", "diff");
-  const outputPath = resolve3(options.outputPath ?? join4(dirname3(absInput), `${stem}.md`));
-  const reportPath = join4(workspaceDir, "run-report.json");
-  const modelCachePath = join4(dirname3(absInput), ".kordoc-model-cache.json");
+  const workspaceDir = resolve3(options.workspaceDir ?? join5(dirname3(absInput), `${stem}_ocr_workspace`));
+  const imagesDir = join5(workspaceDir, "images");
+  const rawDir = join5(workspaceDir, "ocr", "raw");
+  const diffDir = join5(workspaceDir, "ocr", "diff");
+  const outputPath = resolve3(options.outputPath ?? join5(dirname3(absInput), `${stem}.md`));
+  const reportPath = join5(workspaceDir, "run-report.json");
+  const modelCachePath = join5(dirname3(absInput), ".kordoc-model-cache.json");
   const baseUrl = options.baseUrl ?? "https://integrate.api.nvidia.com/v1/chat/completions";
   const timeoutMs = options.timeoutMs ?? 6e4;
   const maxRetriesPerPage = options.maxRetriesPerPage ?? 5;
@@ -11338,14 +13813,15 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
   };
   try {
     ensureSupportedInput(absInput);
+    const isPdfInput = extname(absInput).toLowerCase() === ".pdf";
+    await assertOcrToolchain(isPdfInput);
     let workingPdfPath = absInput;
     const convertStart = performance.now();
     currentStage = "convert";
     markStageStart("convert", "\uBB38\uC11C\uB97C PDF\uB85C \uBCC0\uD658 \uC911");
     logStage("info", "convert", "start", "\uBB38\uC11C\uB97C PDF\uB85C \uBCC0\uD658 \uC2DC\uC791", { input: absInput });
-    if (extname(absInput).toLowerCase() !== ".pdf") {
-      await assertSofficeAvailable();
-      workingPdfPath = join4(workspaceDir, `${stem}.pdf`);
+    if (!isPdfInput) {
+      workingPdfPath = join5(workspaceDir, `${stem}.pdf`);
       const inputBuffer = await readFile(absInput);
       const out = await convertWithLibreOffice(inputBuffer, ".pdf");
       await writeFile(workingPdfPath, out);
@@ -11359,7 +13835,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     logStage("info", "render", "start", "PDF \uD398\uC774\uC9C0 \uB80C\uB354\uB9C1 \uC2DC\uC791", { pdf: workingPdfPath, dpi });
     const renderWithProgress = await renderPdfToPngWithProgress(
       workingPdfPath,
-      join4(imagesDir, "page"),
+      join5(imagesDir, "page"),
       dpi,
       (current, total) => {
         markStageProgress(
@@ -11398,10 +13874,10 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       keyPool,
       timeoutMs,
       logger,
-      onProbeResult: ({ index, model, result }) => {
+      onProbeResult: ({ index: index2, model, result }) => {
         probeDone += 1;
         markStageProgress("probe", Math.round(probeDone / models.length * 100), probeDone, models.length, `\uBAA8\uB378 \uD504\uB85C\uBE0C ${probeDone}/${models.length}`);
-        logStage("debug", "probe", "progress", "\uBAA8\uB378 \uD504\uB85C\uBE0C \uC9C4\uD589", { index: index + 1, total: models.length, model, result });
+        logStage("debug", "probe", "progress", "\uBAA8\uB378 \uD504\uB85C\uBE0C \uC9C4\uD589", { index: index2 + 1, total: models.length, model, result });
       }
     });
     const selected = await probeRuns.firstSuccess;
@@ -11432,7 +13908,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
         maxRetriesPerPage,
         logger
       });
-      const pagePath = join4(rawDir, `page_${String(i + 1).padStart(4, "0")}.md`);
+      const pagePath = join5(rawDir, `page_${String(i + 1).padStart(4, "0")}.md`);
       await writeFile(pagePath, markdown, "utf-8");
       rawPagePaths.push(pagePath);
       markStageProgress("ocr", Math.round((i + 1) / images.length * 100), i + 1, images.length, `OCR ${i + 1}/${images.length}`, selectedModel);
@@ -11524,11 +14000,24 @@ function emitProgress(cb, stage, stagePercent, weights, extra) {
     model: extra.model
   });
 }
+async function loadLibreConvert() {
+  try {
+    const m = await Promise.resolve().then(() => __toESM(require_libreoffice_convert(), 1));
+    return (m.default ?? m).convert;
+  } catch {
+    throw new UnifiedOcrError(
+      "LIBRE_NOT_INSTALLED",
+      "convert",
+      "libreoffice-convert npm \uD328\uD0A4\uC9C0\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.\n  npm install libreoffice-convert\n\uB610\uB294 npx kordoc setup \uC744 \uC2E4\uD589\uD558\uC138\uC694."
+    );
+  }
+}
 async function convertWithLibreOffice(buffer, ext) {
-  return await new Promise((resolvePromise, reject) => {
+  const libreConvert = await loadLibreConvert();
+  return await new Promise((resolvePromise, reject2) => {
     libreConvert(buffer, ext, void 0, (err, done) => {
       if (err || !done) {
-        reject(new UnifiedOcrError("CONVERT_FAILED", "convert", err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"));
+        reject2(new UnifiedOcrError("CONVERT_FAILED", "convert", err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"));
         return;
       }
       resolvePromise(done);
@@ -11586,21 +14075,21 @@ async function renderPdfToPngWithProgress(pdfPath, prefixPath, dpi, onPageDone)
   return { emittedPerPageProgress: false, pageCountSource: "fallback" };
 }
 async function runCommand(cmd, args) {
-  await new Promise((resolvePromise, reject) => {
+  await new Promise((resolvePromise, reject2) => {
     const child = spawn2(cmd, args, { stdio: "pipe" });
     let stderr = "";
     child.stderr.on("data", (d) => {
       stderr += String(d);
     });
-    child.on("error", reject);
+    child.on("error", reject2);
     child.on("close", (code) => {
       if (code === 0) resolvePromise();
-      else reject(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
+      else reject2(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
     });
   });
 }
 async function runCommandWithStdout(cmd, args) {
-  return await new Promise((resolvePromise, reject) => {
+  return await new Promise((resolvePromise, reject2) => {
     const child = spawn2(cmd, args, { stdio: "pipe" });
     let stdout = "";
     let stderr = "";
@@ -11610,23 +14099,35 @@ async function runCommandWithStdout(cmd, args) {
     child.stderr.on("data", (d) => {
       stderr += String(d);
     });
-    child.on("error", reject);
+    child.on("error", reject2);
     child.on("close", (code) => {
       if (code === 0) resolvePromise(stdout);
-      else reject(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
+      else reject2(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
     });
   });
 }
-async function assertSofficeAvailable() {
-  try {
-    await runCommand("soffice", ["--version"]);
-  } catch {
-    throw new UnifiedOcrError("SOFFICE_NOT_FOUND", "convert", "soffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.");
-  }
+async function assertOcrToolchain(isPdfInput = false) {
+  const t = probeOcrToolchain();
+  const pm = detectPackageManager();
+  const missing = [];
+  if (!t.pdftoppm.found || !t.pdfinfo.found) missing.push("poppler");
+  if (!isPdfInput && !t.soffice.found) missing.push("libreoffice");
+  if (missing.length === 0) return;
+  const lines = ["OCR \uD30C\uC774\uD504\uB77C\uC778\uC5D0 \uD544\uC694\uD55C \uC2DC\uC2A4\uD15C \uB3C4\uAD6C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."];
+  if (missing.includes("poppler")) {
+    const r = POPPLER_RECIPES[pm];
+    lines.push(`  - poppler (pdftoppm/pdfinfo): ${r ? r.cmd : "OS\uBCC4 \uC124\uCE58 \uC548\uB0B4\uB294 README \uCC38\uACE0"}`);
+  }
+  if (missing.includes("libreoffice")) {
+    const r = LIBREOFFICE_RECIPES[pm];
+    lines.push(`  - LibreOffice (soffice): ${r ? r.cmd : "OS\uBCC4 \uC124\uCE58 \uC548\uB0B4\uB294 README \uCC38\uACE0"}`);
+  }
+  lines.push("\uC790\uC138\uD55C \uC810\uAC80: npx kordoc doctor");
+  throw new UnifiedOcrError("TOOLCHAIN_MISSING", "convert", lines.join("\n"));
 }
 async function listPageImages(imagesDir) {
   const files = await readdir(imagesDir);
-  return files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b)).map((f) => join4(imagesDir, f));
+  return files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b)).map((f) => join5(imagesDir, f));
 }
 function naturalPageSort(a, b) {
   const na = Number((a.match(/\d+/g) || ["0"]).at(-1) || 0);
@@ -11664,12 +14165,12 @@ function startParallelProbeRuns(input) {
   let doneCount = 0;
   let resolveFirst;
   let rejectFirst;
-  const firstSuccess = new Promise((resolve4, reject) => {
+  const firstSuccess = new Promise((resolve4, reject2) => {
     resolveFirst = resolve4;
-    rejectFirst = reject;
+    rejectFirst = reject2;
   });
   let lastErr = "\uC18D\uB3C4 \uD504\uB85C\uBE0C \uC2E4\uD328: \uC0AC\uC6A9 \uAC00\uB2A5\uD55C OCR \uBAA8\uB378\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
-  const allResults = mapWithConcurrency(input.models, input.probeConcurrency, async (model, index) => {
+  const allResults = mapWithConcurrency(input.models, input.probeConcurrency, async (model, index2) => {
     const t0 = performance.now();
     try {
       await ocrImageViaNim({
@@ -11685,7 +14186,7 @@ function startParallelProbeRuns(input) {
         stage: "probe"
       });
       const result = { model, durationMs: elapsedMs(t0), success: true };
-      input.onProbeResult?.({ index, model, result });
+      input.onProbeResult?.({ index: index2, model, result });
       if (!firstResolved) {
         firstResolved = true;
         resolveFirst?.({ selectedModel: model, firstDurationMs: result.durationMs });
@@ -11699,7 +14200,7 @@ function startParallelProbeRuns(input) {
         error: err instanceof Error ? err.message : String(err)
       };
       lastErr = result.error ?? lastErr;
-      input.onProbeResult?.({ index, model, result });
+      input.onProbeResult?.({ index: index2, model, result });
       return result;
     } finally {
       doneCount += 1;
@@ -12106,5 +14607,14 @@ export {
 
 cfb/cfb.js:
   (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
+
+tmp/lib/tmp.js:
+  (*!
+   * Tmp
+   *
+   * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
+   *
+   * MIT Licensed
+   *)
 */
 //# sourceMappingURL=index.js.map