@clazic/kordoc 2.5.0 → 2.5.1

package/dist/index.js

@@ -36,7 +36,6 @@ 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 = {};
@@ -127,9 +126,9 @@ function sanitizeMeta(meta, cfg) {
   }
   return out;
 }
-function parsePositiveInt(input, fallback2) {
+function parsePositiveInt(input, fallback) {
   const n = Number(input);
-  if (!Number.isFinite(n) || n < 0) return fallback2;
+  if (!Number.isFinite(n) || n < 0) return fallback;
   return Math.floor(n);
 }
 function limitText(input, maxLen) {
@@ -294,9 +293,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) {
@@ -2476,7 +2475,7 @@ function createBatchCliProvider(mode, batchSize) {
   };
 }
 function spawnAsync(cmd, args, opts) {
-  return new Promise((resolve4, reject2) => {
+  return new Promise((resolve4, reject) => {
     const child = spawn(cmd, args, {
       cwd: opts.cwd,
       env: process.env,
@@ -2510,14 +2509,14 @@ function spawnAsync(cmd, args, opts) {
     child.on("close", (code) => {
       clearTimeout(timer);
       if (killed) {
-        reject2(new Error(`\uD0C0\uC784\uC544\uC6C3 (${Math.round(opts.timeoutMs / 1e3)}\uCD08)`));
+        reject(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);
-      reject2(err);
+      reject(err);
     });
   });
 }
@@ -2935,9 +2934,9 @@ async function ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warn
           });
         }
       } catch (err) {
-        const range2 = `${batchPageNums[0]}-${batchPageNums[batchPageNums.length - 1]}`;
+        const range = `${batchPageNums[0]}-${batchPageNums[batchPageNums.length - 1]}`;
         warnings?.push({
-          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`,
+          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`,
           code: "OCR_PAGE_FAILED"
         });
         for (const { image, pageNum } of batchImages) {
@@ -2982,2320 +2981,6 @@ 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";
 
@@ -5743,7 +3428,7 @@ async function extractHwpxStyles(zip, decompressed) {
   }
   return result;
 }
-function parseCharProperties(doc, map2) {
+function parseCharProperties(doc, map) {
   const tagNames = ["hh:charPr", "charPr", "hp:charPr"];
   for (const tagName of tagNames) {
     const elements = doc.getElementsByTagName(tagName);
@@ -5770,11 +3455,11 @@ function parseCharProperties(doc, map2) {
           }
         }
       }
-      map2.set(id, prop);
+      map.set(id, prop);
     }
   }
 }
-function parseStyleElements(doc, map2) {
+function parseStyleElements(doc, map) {
   const tagNames = ["hh:style", "style", "hp:style"];
   for (const tagName of tagNames) {
     const elements = doc.getElementsByTagName(tagName);
@@ -5784,7 +3469,7 @@ function parseStyleElements(doc, map2) {
       const name = el.getAttribute("name") || el.getAttribute("engName") || "";
       const charPrId = el.getAttribute("charPrIDRef") || void 0;
       const paraPrId = el.getAttribute("paraPrIDRef") || void 0;
-      map2.set(id, { name, charPrId, paraPrId });
+      map.set(id, { name, charPrId, paraPrId });
     }
   }
 }
@@ -6310,9 +3995,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 = (parent2, d) => {
+  const walkChildren = (parent, d) => {
     if (d > MAX_XML_DEPTH) return;
-    const kids = parent2.childNodes;
+    const kids = parent.childNodes;
     if (!kids) return;
     for (let i = 0; i < kids.length; i++) {
       const el = kids[i];
@@ -8525,17 +6210,17 @@ function lineOverlapRatio(a1, a2, b1, b2) {
   return overlap / target;
 }
 function groupConnectedLines(lines) {
-  const parent2 = lines.map((_, i) => i);
+  const parent = lines.map((_, i) => i);
   function find2(x) {
-    while (parent2[x] !== x) {
-      parent2[x] = parent2[parent2[x]];
-      x = parent2[x];
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
     }
     return x;
   }
   function union(a, b) {
     const ra = find2(a), rb = find2(b);
-    if (ra !== rb) parent2[ra] = rb;
+    if (ra !== rb) parent[ra] = rb;
   }
   for (let i = 0; i < lines.length; i++) {
     for (let j = i + 1; j < lines.length; j++) {
@@ -8956,10 +6641,10 @@ async function loadPdfWithTimeout(buffer) {
   try {
     return await Promise.race([
       loadingTask.promise,
-      new Promise((_, reject2) => {
+      new Promise((_, reject) => {
         timer = setTimeout(() => {
           loadingTask.destroy();
-          reject2(new KordocError(`PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (${timeoutSec}\uCD08 \uCD08\uACFC)`));
+          reject(new KordocError(`PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (${timeoutSec}\uCD08 \uCD08\uACFC)`));
         }, timeoutMs);
       })
     ]);
@@ -9148,10 +6833,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, filter2) => {
+      const tryProvider = async (provider, filter) => {
         try {
-          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);
+          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);
         } catch {
           logger.log({ level: "warn", stage: "ocr", event: "progress", message: "OCR provider \uC2E4\uD589 \uC2E4\uD328(\uBE48 \uACB0\uACFC\uB85C \uCC98\uB9AC)" });
           return [];
@@ -10166,8 +7851,8 @@ function parseMergeRef(ref) {
   if (!start || !end) return null;
   return { startCol: start.col, startRow: start.row, endCol: end.col, endRow: end.row };
 }
-function getElements(parent2, tagName) {
-  const nodes = parent2.getElementsByTagName(tagName);
+function getElements(parent, tagName) {
+  const nodes = parent.getElementsByTagName(tagName);
   const result = [];
   for (let i = 0; i < nodes.length; i++) result.push(nodes[i]);
   return result;
@@ -10203,14 +7888,14 @@ function parseWorkbook(xml) {
 }
 function parseRels(xml) {
   const doc = parseXml(xml);
-  const map2 = /* @__PURE__ */ new Map();
+  const map = /* @__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) map2.set(id, target);
+    if (id && target) map.set(id, target);
   }
-  return map2;
+  return map;
 }
 function parseWorksheet(xml, sharedStrings) {
   const doc = parseXml(xml);
@@ -10468,9 +8153,9 @@ import JSZip4 from "jszip";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 init_logger();
 var MAX_DECOMPRESS_SIZE4 = 500 * 1024 * 1024;
-function getChildElements(parent2, localName) {
+function getChildElements(parent, localName) {
   const result = [];
-  const children = parent2.childNodes;
+  const children = parent.childNodes;
   for (let i = 0; i < children.length; i++) {
     const node = children[i];
     if (node.nodeType === 1) {
@@ -10482,7 +8167,7 @@ function getChildElements(parent2, localName) {
   }
   return result;
 }
-function findElements(parent2, localName) {
+function findElements(parent, localName) {
   const result = [];
   const walk = (node) => {
     const children = node.childNodes;
@@ -10497,7 +8182,7 @@ function findElements(parent2, localName) {
       }
     }
   };
-  walk(parent2);
+  walk(parent);
   return result;
 }
 function getAttr(el, localName) {
@@ -10512,7 +8197,7 @@ function parseXml2(text) {
   return new DOMParser3().parseFromString(text, "text/xml");
 }
 function buildElementIndex(root) {
-  const index2 = /* @__PURE__ */ new Map();
+  const index = /* @__PURE__ */ new Map();
   const walk = (node) => {
     const children = node.childNodes;
     for (let i = 0; i < children.length; i++) {
@@ -10521,10 +8206,10 @@ function buildElementIndex(root) {
         const el = child;
         const name = el.localName ?? "";
         if (name) {
-          let list = index2.get(name);
+          let list = index.get(name);
           if (!list) {
             list = [];
-            index2.set(name, list);
+            index.set(name, list);
           }
           list.push(el);
         }
@@ -10533,7 +8218,7 @@ function buildElementIndex(root) {
     }
   };
   walk(root);
-  return index2;
+  return index;
 }
 function parseStyles(xml) {
   const doc = parseXml2(xml);
@@ -10599,14 +8284,14 @@ function parseNumbering(xml) {
 }
 function parseRels2(xml) {
   const doc = parseXml2(xml);
-  const map2 = /* @__PURE__ */ new Map();
+  const map = /* @__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) map2.set(id, target);
+    if (id && target) map.set(id, target);
   }
-  return map2;
+  return map;
 }
 function parseFootnotes(xml) {
   const doc = parseXml2(xml);
@@ -12449,22 +10134,22 @@ function findCharPrByCharacteristic(charPrMap, characteristic) {
     italic: { minHeight: 800, maxHeight: 1100, needBold: false },
     normal: { minHeight: 900, maxHeight: 1100, needBold: false }
   };
-  const range2 = ranges[characteristic];
-  if (!range2) return null;
+  const range = ranges[characteristic];
+  if (!range) return null;
   let bestMatch = null;
   let bestScore = 0;
   for (const [id, prop] of charPrMap) {
     let score = 0;
     if (prop.height) {
-      if (prop.height >= range2.minHeight && prop.height <= range2.maxHeight) {
+      if (prop.height >= range.minHeight && prop.height <= range.maxHeight) {
         score += 50;
-      } else if (Math.abs(prop.height - (range2.minHeight + range2.maxHeight) / 2) < 100) {
+      } else if (Math.abs(prop.height - (range.minHeight + range.maxHeight) / 2) < 100) {
         score += 20;
       }
     }
-    if (range2.needBold !== void 0) {
-      if (range2.needBold && prop.bold) score += 30;
-      else if (!range2.needBold && !prop.bold) score += 20;
+    if (range.needBold !== void 0) {
+      if (range.needBold && prop.bold) score += 30;
+      else if (!range.needBold && !prop.bold) score += 20;
     }
     if (characteristic === "italic" && prop.italic) score += 20;
     if (score > bestScore) {
@@ -13303,10 +10988,10 @@ function mimeToExtension(mimeType) {
   return "png";
 }
 function buildImageMap(images) {
-  const map2 = /* @__PURE__ */ new Map();
-  if (!images) return map2;
-  for (const img of images) map2.set(img.filename, img);
-  return map2;
+  const map = /* @__PURE__ */ new Map();
+  if (!images) return map;
+  for (const img of images) map.set(img.filename, img);
+  return map;
 }
 async function fillBodySheet(sheet, workbook, blocks, imageMap) {
   sheet.getColumn(1).width = 80;
@@ -13508,8 +11193,8 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
     const s = this.find(keyId);
     s.failureCount++;
     s.consecutiveFailures++;
-    const retryable2 = this.isRetryableFailure(opts.status, opts.timeout);
-    if (!retryable2) return;
+    const retryable = this.isRetryableFailure(opts.status, opts.timeout);
+    if (!retryable) 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);
@@ -13526,8 +11211,8 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
       cooldownUntil: s.cooldownUntil
     }));
   }
-  isRetryableFailure(status, timeout2) {
-    if (timeout2) return true;
+  isRetryableFailure(status, timeout) {
+    if (timeout) return true;
     if (status === 429) return true;
     if (typeof status === "number" && status >= 500) return true;
     return false;
@@ -13541,172 +11226,72 @@ 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 join5, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname3, extname, join as join4, resolve as resolve3 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { performance } from "perf_hooks";
+import libre from "libreoffice-convert";
 init_logger();
 
-// 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;
+// src/pipeline/bounded-queue.ts
+var QUEUE_DONE = /* @__PURE__ */ Symbol("QUEUE_DONE");
+var BoundedQueue = class {
+  buffer = [];
+  capacity;
+  closed = false;
+  producerWaiters = [];
+  consumerWaiters = [];
+  constructor(capacity) {
+    if (capacity < 1) throw new RangeError("BoundedQueue capacity must be >= 1");
+    this.capacity = capacity;
+  }
+  async enqueue(item) {
+    if (this.closed) throw new Error("BoundedQueue: cannot enqueue after close()");
+    if (this.consumerWaiters.length > 0) {
+      const resolve4 = this.consumerWaiters.shift();
+      resolve4(item);
+      return;
     }
-    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;
+    while (this.buffer.length >= this.capacity) {
+      await new Promise((resolve4) => this.producerWaiters.push(resolve4));
+      if (this.closed) throw new Error("BoundedQueue: closed while waiting to enqueue");
+    }
+    this.buffer.push(item);
+  }
+  async dequeue() {
+    if (this.buffer.length > 0) {
+      const item = this.buffer.shift();
+      this._wakeProducer();
+      return item;
+    }
+    if (this.closed) return QUEUE_DONE;
+    return new Promise((resolve4) => {
+      this.consumerWaiters.push(resolve4);
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const resolve4 of this.consumerWaiters) {
+      resolve4(QUEUE_DONE);
+    }
+    this.consumerWaiters = [];
+    for (const wake of this.producerWaiters) {
+      wake();
+    }
+    this.producerWaiters = [];
+  }
+  get size() {
+    return this.buffer.length;
+  }
+  _wakeProducer() {
+    if (this.producerWaiters.length > 0) {
+      this.producerWaiters.shift()();
     }
   }
-  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 libreConvert = libre.convert;
 var UnifiedOcrError = class extends Error {
   code;
   stage;
@@ -13737,11 +11322,11 @@ var DEFAULT_MODEL_MAX_TOKENS = {
 };
 var DEFAULT_STAGE_WEIGHTS = {
   convert: 15,
-  render: 20,
+  render: 15,
   probe: 5,
-  ocr: 45,
+  ocr: 55,
   proofread: 0,
-  merge: 5
+  merge: 10
 };
 var OCR_PROMPT2 = [
   "\uC774 PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0\uC5D0\uC11C \uD14D\uC2A4\uD2B8\uC640 \uD45C\uB97C \uCD94\uCD9C\uD558\uC5EC Markdown\uC73C\uB85C \uBCC0\uD658\uD558\uACE0, OCR \uC624\uC778\uC2DD \uC624\uB958\uB97C \uC989\uC2DC \uAD50\uC815\uD558\uC5EC \uCD5C\uC885 \uACB0\uACFC\uBB3C\uC744 \uCD9C\uB825\uD558\uC138\uC694.",
@@ -13780,13 +11365,13 @@ function elapsedMs(startAt) {
 async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const absInput = resolve3(inputPath);
   const stem = basename2(absInput, extname(absInput));
-  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 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 baseUrl = options.baseUrl ?? "https://integrate.api.nvidia.com/v1/chat/completions";
   const timeoutMs = options.timeoutMs ?? 6e4;
   const maxRetriesPerPage = options.maxRetriesPerPage ?? 5;
@@ -13813,15 +11398,14 @@ 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 (!isPdfInput) {
-      workingPdfPath = join5(workspaceDir, `${stem}.pdf`);
+    if (extname(absInput).toLowerCase() !== ".pdf") {
+      await assertSofficeAvailable();
+      workingPdfPath = join4(workspaceDir, `${stem}.pdf`);
       const inputBuffer = await readFile(absInput);
       const out = await convertWithLibreOffice(inputBuffer, ".pdf");
       await writeFile(workingPdfPath, out);
@@ -13831,39 +11415,19 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     logStage("info", "convert", "done", "PDF \uBCC0\uD658 \uC644\uB8CC", { elapsedMs: timingsMs.convert });
     const renderStart = performance.now();
     currentStage = "render";
+    const totalPages = await getPdfPageCount(workingPdfPath).catch(() => 0);
+    if (totalPages === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uD398\uC774\uC9C0 \uC218\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     markStageStart("render", "PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC911");
-    logStage("info", "render", "start", "PDF \uD398\uC774\uC9C0 \uB80C\uB354\uB9C1 \uC2DC\uC791", { pdf: workingPdfPath, dpi });
-    const renderWithProgress = await renderPdfToPngWithProgress(
-      workingPdfPath,
-      join5(imagesDir, "page"),
-      dpi,
-      (current, total) => {
-        markStageProgress(
-          "render",
-          Math.round(current / total * 100),
-          current,
-          total,
-          `\uD398\uC774\uC9C0 ${current}/${total} \uB80C\uB354\uB9C1`
-        );
-      }
-    );
-    const images = await listPageImages(imagesDir);
-    if (images.length === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC2E4\uD328: \uACB0\uACFC \uC774\uBBF8\uC9C0\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    if (!renderWithProgress.emittedPerPageProgress) {
-      markStageProgress("render", 100, images.length, images.length, `\uD398\uC774\uC9C0 ${images.length}\uC7A5 \uC0DD\uC131`);
-    }
-    timingsMs.render = elapsedMs(renderStart);
-    markStageDone("render", "\uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC");
-    logStage("info", "render", "done", "\uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC", {
-      pages: images.length,
-      elapsedMs: timingsMs.render,
-      pageCountSource: renderWithProgress.pageCountSource
-    });
+    logStage("info", "render", "start", "PDF \uD398\uC774\uC9C0 \uB80C\uB354\uB9C1 \uC2DC\uC791", { pdf: workingPdfPath, dpi, totalPages });
+    await runCommand("pdftoppm", ["-png", "-r", String(dpi), "-f", "1", "-l", "1", workingPdfPath, join4(imagesDir, "page")]);
+    const firstFiles = (await readdir(imagesDir)).filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
+    if (firstFiles.length === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uCCAB \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC2E4\uD328");
+    const probeImage = join4(imagesDir, firstFiles[0]);
+    markStageProgress("render", Math.round(1 / totalPages * 100), 1, totalPages, `\uD398\uC774\uC9C0 1/${totalPages} \uB80C\uB354\uB9C1`);
     const probeStart = performance.now();
     currentStage = "probe";
     markStageStart("probe", "\uBAA8\uB378 \uC18D\uB3C4 \uD504\uB85C\uBE0C \uC218\uD589 \uC911");
     logStage("info", "probe", "start", "\uBAA8\uB378 \uC18D\uB3C4 \uD504\uB85C\uBE0C \uC2DC\uC791", { models, probeConcurrency });
-    const probeImage = await pickRepresentativeImage(images);
     let probeDone = 0;
     const probeRuns = startParallelProbeRuns({
       models,
@@ -13874,10 +11438,10 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       keyPool,
       timeoutMs,
       logger,
-      onProbeResult: ({ index: index2, model, result }) => {
+      onProbeResult: ({ index, 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: index2 + 1, total: models.length, model, result });
+        logStage("debug", "probe", "progress", "\uBAA8\uB378 \uD504\uB85C\uBE0C \uC9C4\uD589", { index: index + 1, total: models.length, model, result });
       }
     });
     const selected = await probeRuns.firstSuccess;
@@ -13890,33 +11454,74 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       await updateModelCache(modelCachePath, results);
       return results;
     });
+    const concurrencyPerKey = Math.max(1, options.concurrencyPerKey ?? 2);
+    const keyCount = keyPool.snapshot().length;
+    const workerCount = Math.max(1, keyCount * concurrencyPerKey);
+    const queueCapacity = workerCount * 2;
+    const queue = new BoundedQueue(queueCapacity);
     const ocrStart = performance.now();
     currentStage = "ocr";
-    markStageStart("ocr", `OCR \uC9C4\uD589 \uC911 (${selectedModel})`);
-    logStage("info", "ocr", "start", "\uD398\uC774\uC9C0 OCR \uC2DC\uC791", { selectedModel, pageCount: images.length });
-    const rawPagePaths = [];
-    for (let i = 0; i < images.length; i++) {
-      const imagePath = images[i];
-      const markdown = await ocrImageWithFallback({
-        imagePath,
-        prompt: OCR_PROMPT2,
-        models: fallbackModelOrder,
-        modelMaxTokens,
-        baseUrl,
-        keyPool,
-        timeoutMs,
-        maxRetriesPerPage,
+    markStageStart("ocr", `OCR \uC9C4\uD589 \uC911 (\uC6CC\uCEE4 ${workerCount}\uAC1C)`);
+    logStage("info", "ocr", "start", "\uD398\uC774\uC9C0 OCR \uC2DC\uC791", { workerCount, keyCount, pageCount: totalPages });
+    let renderDone = 1;
+    const renderProducer = (async () => {
+      try {
+        await queue.enqueue({ pageNumber: 1, imagePath: probeImage });
+        if (totalPages > 1) {
+          for await (const item of renderPdfToPngStream(workingPdfPath, join4(imagesDir, "page"), dpi, totalPages, 2)) {
+            await queue.enqueue(item);
+            renderDone++;
+            markStageProgress("render", Math.round(renderDone / totalPages * 100), renderDone, totalPages, `\uD398\uC774\uC9C0 ${renderDone}/${totalPages} \uB80C\uB354\uB9C1`);
+            logStage("debug", "render", "progress", "\uD398\uC774\uC9C0 \uB80C\uB354 \uC644\uB8CC", { page: item.pageNumber });
+          }
+        }
+      } finally {
+        queue.close();
+        timingsMs.render = elapsedMs(renderStart);
+        markStageDone("render", "\uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC");
+        logStage("info", "render", "done", "\uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC", { pages: renderDone, elapsedMs: timingsMs.render });
+      }
+    })();
+    const [, pageResultsMap] = await Promise.all([
+      renderProducer,
+      ocrWorkerPool({
+        queue,
+        workerCount,
+        totalPages,
+        ocrInput: {
+          prompt: OCR_PROMPT2,
+          models: fallbackModelOrder,
+          modelMaxTokens,
+          baseUrl,
+          keyPool,
+          timeoutMs,
+          maxRetriesPerPage,
+          logger
+        },
+        onPageDone: (pageNumber, completedCount, model) => {
+          markStageProgress(
+            "ocr",
+            Math.round(completedCount / totalPages * 100),
+            completedCount,
+            totalPages,
+            `OCR ${completedCount}/${totalPages}`,
+            model || void 0
+          );
+          logStage("debug", "ocr", "progress", "\uD398\uC774\uC9C0 OCR \uC644\uB8CC", { page: pageNumber, total: totalPages, model });
+        },
         logger
-      });
-      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);
-      logStage("debug", "ocr", "progress", "\uD398\uC774\uC9C0 OCR \uC644\uB8CC", { page: i + 1, total: images.length });
-    }
+      })
+    ]);
     timingsMs.ocr = elapsedMs(ocrStart);
     markStageDone("ocr", "OCR \uC644\uB8CC");
     logStage("info", "ocr", "done", "\uD398\uC774\uC9C0 OCR \uC644\uB8CC", { elapsedMs: timingsMs.ocr });
+    const sortedEntries = Array.from(pageResultsMap.entries()).sort((a, b) => a[0] - b[0]);
+    const rawPagePaths = [];
+    for (const [pageNum, markdown] of sortedEntries) {
+      const pagePath = join4(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
+      await writeFile(pagePath, markdown, "utf-8");
+      rawPagePaths.push(pagePath);
+    }
     const mergeStart = performance.now();
     currentStage = "merge";
     markStageStart("merge", "\uCD5C\uC885 Markdown \uBCD1\uD569 \uC911");
@@ -13933,7 +11538,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       selectedModel,
       probeImage,
       probeResults: await probeResultsPromise,
-      pageCount: images.length,
+      pageCount: totalPages,
       keyHealth: keyPool.snapshot(),
       timingsMs,
       modelCachePath
@@ -14000,37 +11605,17 @@ 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) {
-  const libreConvert = await loadLibreConvert();
-  return await new Promise((resolvePromise, reject2) => {
+  return await new Promise((resolvePromise, reject) => {
     libreConvert(buffer, ext, void 0, (err, done) => {
       if (err || !done) {
-        reject2(new UnifiedOcrError("CONVERT_FAILED", "convert", err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"));
+        reject(new UnifiedOcrError("CONVERT_FAILED", "convert", err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"));
         return;
       }
       resolvePromise(done);
     });
   });
 }
-async function renderPdfToPng(pdfPath, prefixPath, dpi) {
-  try {
-    await runCommand("pdftoppm", ["-png", "-r", String(dpi), pdfPath, prefixPath]);
-  } catch (err) {
-    throw new UnifiedOcrError("RENDER_FAILED", "render", err instanceof Error ? err.message : String(err));
-  }
-}
 async function getPdfPageCount(pdfPath) {
   const stdout = await runCommandWithStdout("pdfinfo", [pdfPath]);
   const m = stdout.match(/^\s*Pages:\s*(\d+)\s*$/mi);
@@ -14043,53 +11628,50 @@ async function getPdfPageCount(pdfPath) {
   }
   return n;
 }
-async function renderPdfToPngWithProgress(pdfPath, prefixPath, dpi, onPageDone) {
-  let totalPages = 0;
-  try {
-    totalPages = await getPdfPageCount(pdfPath);
-  } catch {
-    totalPages = 0;
-  }
-  if (totalPages > 0) {
+async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, startPage = 1) {
+  const imagesDir = dirname3(prefixPath);
+  for (let page = startPage; page <= totalPages; page++) {
     try {
-      for (let page = 1; page <= totalPages; page++) {
-        await runCommand("pdftoppm", [
-          "-png",
-          "-r",
-          String(dpi),
-          "-f",
-          String(page),
-          "-l",
-          String(page),
-          pdfPath,
-          prefixPath
-        ]);
-        onPageDone(page, totalPages);
-      }
-      return { emittedPerPageProgress: true, pageCountSource: "pdfinfo" };
+      await runCommand("pdftoppm", [
+        "-png",
+        "-r",
+        String(dpi),
+        "-f",
+        String(page),
+        "-l",
+        String(page),
+        pdfPath,
+        prefixPath
+      ]);
+      const files = await readdir(imagesDir);
+      const pageFiles = files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
+      const imagePath = join4(imagesDir, pageFiles[pageFiles.length - 1]);
+      yield { pageNumber: page, imagePath };
     } catch (err) {
-      throw new UnifiedOcrError("RENDER_FAILED", "render", err instanceof Error ? err.message : String(err));
+      yield {
+        pageNumber: page,
+        imagePath: null,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
     }
   }
-  await renderPdfToPng(pdfPath, prefixPath, dpi);
-  return { emittedPerPageProgress: false, pageCountSource: "fallback" };
 }
 async function runCommand(cmd, args) {
-  await new Promise((resolvePromise, reject2) => {
+  await new Promise((resolvePromise, reject) => {
     const child = spawn2(cmd, args, { stdio: "pipe" });
     let stderr = "";
     child.stderr.on("data", (d) => {
       stderr += String(d);
     });
-    child.on("error", reject2);
+    child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) resolvePromise();
-      else reject2(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
+      else reject(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
     });
   });
 }
 async function runCommandWithStdout(cmd, args) {
-  return await new Promise((resolvePromise, reject2) => {
+  return await new Promise((resolvePromise, reject) => {
     const child = spawn2(cmd, args, { stdio: "pipe" });
     let stdout = "";
     let stderr = "";
@@ -14099,52 +11681,25 @@ async function runCommandWithStdout(cmd, args) {
     child.stderr.on("data", (d) => {
       stderr += String(d);
     });
-    child.on("error", reject2);
+    child.on("error", reject);
     child.on("close", (code) => {
       if (code === 0) resolvePromise(stdout);
-      else reject2(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
+      else reject(new Error(`${cmd} \uC2E4\uD328 (code=${code}): ${stderr.trim()}`));
     });
   });
 }
-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) => join5(imagesDir, f));
+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.");
+  }
 }
 function naturalPageSort(a, b) {
   const na = Number((a.match(/\d+/g) || ["0"]).at(-1) || 0);
   const nb = Number((b.match(/\d+/g) || ["0"]).at(-1) || 0);
   return na - nb;
 }
-async function pickRepresentativeImage(images) {
-  const sample = images.slice(0, Math.min(images.length, 8));
-  const weighted = [];
-  for (const p of sample) {
-    const st = await stat(p);
-    if (st.size > 8 * 1024) weighted.push({ path: p, size: st.size });
-  }
-  const use = weighted.length > 0 ? weighted : await Promise.all(sample.map(async (p) => ({ path: p, size: (await stat(p)).size })));
-  use.sort((a, b) => a.size - b.size);
-  return use[Math.floor(use.length / 2)].path;
-}
 async function mapWithConcurrency(items, concurrency, mapper) {
   const results = new Array(items.length);
   let nextIndex = 0;
@@ -14165,12 +11720,12 @@ function startParallelProbeRuns(input) {
   let doneCount = 0;
   let resolveFirst;
   let rejectFirst;
-  const firstSuccess = new Promise((resolve4, reject2) => {
+  const firstSuccess = new Promise((resolve4, reject) => {
     resolveFirst = resolve4;
-    rejectFirst = reject2;
+    rejectFirst = reject;
   });
   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, index2) => {
+  const allResults = mapWithConcurrency(input.models, input.probeConcurrency, async (model, index) => {
     const t0 = performance.now();
     try {
       await ocrImageViaNim({
@@ -14186,7 +11741,7 @@ function startParallelProbeRuns(input) {
         stage: "probe"
       });
       const result = { model, durationMs: elapsedMs(t0), success: true };
-      input.onProbeResult?.({ index: index2, model, result });
+      input.onProbeResult?.({ index, model, result });
       if (!firstResolved) {
         firstResolved = true;
         resolveFirst?.({ selectedModel: model, firstDurationMs: result.durationMs });
@@ -14200,7 +11755,7 @@ function startParallelProbeRuns(input) {
         error: err instanceof Error ? err.message : String(err)
       };
       lastErr = result.error ?? lastErr;
-      input.onProbeResult?.({ index: index2, model, result });
+      input.onProbeResult?.({ index, model, result });
       return result;
     } finally {
       doneCount += 1;
@@ -14246,11 +11801,43 @@ async function updateModelCache(path, probes) {
   current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeFile(path, JSON.stringify(current, null, 2), "utf-8");
 }
+async function ocrWorkerPool(input) {
+  const { queue, workerCount, ocrInput, onPageDone } = input;
+  const results = /* @__PURE__ */ new Map();
+  let completedCount = 0;
+  async function worker() {
+    while (true) {
+      const item = await queue.dequeue();
+      if (item === QUEUE_DONE) break;
+      const { pageNumber, imagePath, error } = item;
+      if (imagePath === null) {
+        input.logger?.log({
+          level: "warn",
+          stage: "ocr",
+          event: "message",
+          message: `\uD398\uC774\uC9C0 ${pageNumber} \uB80C\uB354 \uC2E4\uD328 \u2014 \uBE48 \uD398\uC774\uC9C0\uB85C \uCC98\uB9AC`,
+          meta: { error: String(error) }
+        });
+        results.set(pageNumber, "");
+        completedCount++;
+        onPageDone(pageNumber, completedCount, "");
+        continue;
+      }
+      const { markdown, model } = await ocrImageWithFallback({ ...ocrInput, imagePath });
+      results.set(pageNumber, markdown);
+      completedCount++;
+      onPageDone(pageNumber, completedCount, model);
+    }
+  }
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
 async function ocrImageWithFallback(input) {
   let lastErr = "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958";
   for (const model of input.models) {
     try {
-      return await ocrImageViaNim({
+      const markdown = await ocrImageViaNim({
         imagePath: input.imagePath,
         prompt: input.prompt,
         model,
@@ -14262,6 +11849,7 @@ async function ocrImageWithFallback(input) {
         logger: input.logger,
         stage: "ocr"
       });
+      return { markdown, model };
     } catch (err) {
       lastErr = err instanceof Error ? err.message : String(err);
     }
@@ -14607,14 +12195,5 @@ 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