mineru-open-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,774 @@
+// src/constants.ts
+var DEFAULT_BASE_URL = "https://mineru.net/api/v4";
+var DEFAULT_FLASH_BASE_URL = "https://mineru.net/api/v1/agent";
+
+// src/client.ts
+import { readFile } from "fs/promises";
+import { basename as basename2, extname as extname2 } from "path";
+
+// src/errors.ts
+var MinerUError = class extends Error {
+  code;
+  traceId;
+  constructor(code, message, traceId = "") {
+    const tag = traceId ? ` (trace: ${traceId})` : "";
+    super(`[${code}] ${message}${tag}`);
+    this.name = "MinerUError";
+    this.code = String(code);
+    this.traceId = traceId;
+  }
+};
+var AuthError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "AuthError";
+  }
+};
+var ParamError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "ParamError";
+  }
+};
+var FileTooLargeError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "FileTooLargeError";
+  }
+};
+var PageLimitError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "PageLimitError";
+  }
+};
+var TaskNotFoundError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "TaskNotFoundError";
+  }
+};
+var ExtractFailedError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "ExtractFailedError";
+  }
+};
+var TimeoutError = class extends MinerUError {
+  timeout;
+  taskId;
+  constructor(timeout, taskId) {
+    super("TIMEOUT", `Task ${taskId} did not complete within ${timeout}s`);
+    this.name = "TimeoutError";
+    this.timeout = timeout;
+    this.taskId = taskId;
+  }
+};
+var QuotaExceededError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "QuotaExceededError";
+  }
+};
+var FlashFileTooLargeError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "FlashFileTooLargeError";
+  }
+};
+var FlashUnsupportedTypeError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "FlashUnsupportedTypeError";
+  }
+};
+var FlashPageLimitError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "FlashPageLimitError";
+  }
+};
+var FlashParamError = class extends MinerUError {
+  constructor(code, message, traceId = "") {
+    super(code, message, traceId);
+    this.name = "FlashParamError";
+  }
+};
+var NoAuthClientError = class extends MinerUError {
+  constructor() {
+    super(
+      "-1",
+      "This operation requires an authenticated client; pass token to MinerU() or set MINERU_TOKEN env var."
+    );
+    this.name = "NoAuthClientError";
+  }
+};
+var CODE_TO_ERROR = {
+  A0202: AuthError,
+  A0211: AuthError,
+  "-500": ParamError,
+  "-10002": ParamError,
+  "-60005": FileTooLargeError,
+  "-60006": PageLimitError,
+  "-60010": ExtractFailedError,
+  "-60012": TaskNotFoundError,
+  "-60013": MinerUError,
+  "-60018": QuotaExceededError,
+  "-60019": QuotaExceededError,
+  "-30001": FlashFileTooLargeError,
+  "-30002": FlashUnsupportedTypeError,
+  "-30003": FlashPageLimitError,
+  "-30004": FlashParamError
+};
+function raiseForCode(code, msg, traceId = "") {
+  const ErrorClass = CODE_TO_ERROR[String(code)] ?? MinerUError;
+  throw new ErrorClass(code, msg, traceId);
+}
+
+// src/api.ts
+var ApiClient = class {
+  baseUrl;
+  headers;
+  source;
+  constructor(token, baseUrl, source = "") {
+    this.baseUrl = baseUrl;
+    this.headers = {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+    this.source = source;
+  }
+  setSource(source) {
+    this.source = source;
+  }
+  async post(path, json) {
+    const headers = { ...this.headers };
+    if (this.source) {
+      headers["source"] = this.source;
+    }
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(json)
+    });
+    return this.handle(resp);
+  }
+  async get(path) {
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    return this.handle(resp);
+  }
+  async putFile(url, data) {
+    const resp = await fetch(url, {
+      method: "PUT",
+      body: data
+    });
+    if (!resp.ok) {
+      throw new Error(`Upload failed: ${resp.status} ${resp.statusText}`);
+    }
+  }
+  async download(url) {
+    const resp = await fetch(url, { redirect: "follow" });
+    if (!resp.ok) {
+      throw new Error(`Download failed: ${resp.status} ${resp.statusText}`);
+    }
+    return new Uint8Array(await resp.arrayBuffer());
+  }
+  async handle(resp) {
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(
+        `HTTP ${resp.status}: ${resp.statusText}${text ? ` \u2014 ${text}` : ""}`
+      );
+    }
+    const body = await resp.json();
+    if (body.code !== 0) {
+      raiseForCode(body.code, body.msg ?? "unknown error", body.trace_id ?? "");
+    }
+    return body;
+  }
+};
+
+// src/flash-api.ts
+var FlashApiClient = class {
+  baseUrl;
+  headers;
+  source;
+  constructor(baseUrl = DEFAULT_FLASH_BASE_URL, source = "") {
+    this.baseUrl = baseUrl;
+    this.headers = { "Content-Type": "application/json" };
+    this.source = source;
+  }
+  setSource(source) {
+    this.source = source;
+  }
+  async post(path, json) {
+    const headers = { ...this.headers };
+    if (this.source) {
+      headers["source"] = this.source;
+    }
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(json)
+    });
+    return this.handle(resp);
+  }
+  async get(path) {
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "GET"
+    });
+    return this.handle(resp);
+  }
+  async putFile(url, data) {
+    const resp = await fetch(url, { method: "PUT", body: data });
+    if (!resp.ok) {
+      throw new Error(`Upload failed: ${resp.status} ${resp.statusText}`);
+    }
+  }
+  async downloadText(url) {
+    const resp = await fetch(url, { redirect: "follow" });
+    if (!resp.ok) {
+      throw new Error(`Download failed: ${resp.status} ${resp.statusText}`);
+    }
+    return resp.text();
+  }
+  async handle(resp) {
+    if (resp.status === 429) {
+      raiseForCode(
+        "RATE_LIMITED",
+        "flash API rate limit exceeded; try again later"
+      );
+    }
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(
+        `HTTP ${resp.status}: ${resp.statusText}${text ? ` \u2014 ${text}` : ""}`
+      );
+    }
+    const body = await resp.json();
+    if (body.code !== 0) {
+      raiseForCode(body.code, body.msg ?? "unknown error", body.trace_id ?? "");
+    }
+    return body;
+  }
+};
+
+// src/models.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+function progressPercent(p) {
+  if (p.totalPages === 0) return 0;
+  return p.extractedPages / p.totalPages * 100;
+}
+function progressToString(p) {
+  return `${p.extractedPages}/${p.totalPages} (${progressPercent(p).toFixed(0)}%)`;
+}
+function createEmptyResult(taskId, state) {
+  return {
+    taskId,
+    state,
+    filename: null,
+    errCode: "",
+    error: null,
+    zipUrl: null,
+    progress: null,
+    markdown: null,
+    contentList: null,
+    images: [],
+    docx: null,
+    html: null,
+    latex: null,
+    _zipBytes: null
+  };
+}
+async function ensureDir(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+async function saveMarkdown(result, path, withImages = true) {
+  if (result.markdown == null) {
+    throw new Error("No markdown content available (state != done)");
+  }
+  await ensureDir(path);
+  await writeFile(path, result.markdown, "utf-8");
+  if (withImages && result.images.length > 0) {
+    const imgDir = join(dirname(path), "images");
+    await mkdir(imgDir, { recursive: true });
+    for (const img of result.images) {
+      await writeFile(join(imgDir, img.name), img.data);
+    }
+  }
+}
+async function saveDocx(result, path) {
+  if (result.docx == null) {
+    throw new Error(
+      "No docx content available"
+    );
+  }
+  await ensureDir(path);
+  await writeFile(path, result.docx);
+}
+async function saveHtml(result, path) {
+  if (result.html == null) {
+    throw new Error(
+      "No html content available"
+    );
+  }
+  await ensureDir(path);
+  await writeFile(path, result.html, "utf-8");
+}
+async function saveLatex(result, path) {
+  if (result.latex == null) {
+    throw new Error(
+      "No latex content available"
+    );
+  }
+  await ensureDir(path);
+  await writeFile(path, result.latex, "utf-8");
+}
+async function saveAll(result, dir) {
+  if (result._zipBytes == null) {
+    throw new Error("No zip data available (state != done)");
+  }
+  const { unzipSync: unzipSync2 } = await import("fflate");
+  const entries = unzipSync2(new Uint8Array(result._zipBytes));
+  await mkdir(dir, { recursive: true });
+  for (const [relativePath, content] of Object.entries(entries)) {
+    if (relativePath.endsWith("/")) continue;
+    const fullPath = join(dir, relativePath);
+    await ensureDir(fullPath);
+    await writeFile(fullPath, content);
+  }
+}
+
+// src/zip.ts
+import { unzipSync } from "fflate";
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".svg",
+  ".webp"
+]);
+function extname(filename) {
+  const dot = filename.lastIndexOf(".");
+  return dot === -1 ? "" : filename.slice(dot).toLowerCase();
+}
+function basename(filepath) {
+  const parts = filepath.replace(/\\/g, "/").split("/");
+  return parts[parts.length - 1] ?? "";
+}
+function parseZip(zipBytes, taskId, filename = null) {
+  const result = createEmptyResult(taskId, "done");
+  result.filename = filename;
+  result._zipBytes = zipBytes;
+  const entries = unzipSync(zipBytes);
+  const images = [];
+  let contentList = null;
+  for (const [relPath, data] of Object.entries(entries)) {
+    if (relPath.endsWith("/")) continue;
+    const name = basename(relPath);
+    const ext = extname(name);
+    const text = () => new TextDecoder().decode(data);
+    if (ext === ".md") {
+      result.markdown = text();
+    } else if (name.endsWith("_content_list.json") || name === "content_list.json") {
+      contentList = JSON.parse(text());
+    } else if (ext === ".json" && contentList == null) {
+      try {
+        const parsed = JSON.parse(text());
+        if (Array.isArray(parsed)) {
+          contentList = parsed;
+        }
+      } catch {
+      }
+    } else if (IMAGE_EXTENSIONS.has(ext)) {
+      images.push({ name, data: new Uint8Array(data), path: relPath });
+    } else if (ext === ".docx") {
+      result.docx = new Uint8Array(data);
+    } else if (ext === ".html" || ext === ".htm") {
+      result.html = text();
+    } else if (ext === ".tex") {
+      result.latex = text();
+    }
+  }
+  result.contentList = contentList;
+  result.images = images;
+  return result;
+}
+
+// src/client.ts
+var MODEL_MAP = {
+  pipeline: "pipeline",
+  vlm: "vlm",
+  html: "MinerU-HTML"
+};
+var HTML_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".htm"]);
+var DEFAULT_SOURCE = "open-api-sdk-js";
+var DEFAULT_TIMEOUT_POLL_SINGLE = 300;
+var DEFAULT_TIMEOUT_POLL_BATCH = 1800;
+function isUrl(source) {
+  return source.startsWith("http://") || source.startsWith("https://");
+}
+function getExtension(source) {
+  if (isUrl(source)) {
+    const path = source.split("?")[0].split("#")[0];
+    const dot = path.lastIndexOf(".");
+    return dot === -1 ? "" : path.slice(dot).toLowerCase();
+  }
+  return extname2(source).toLowerCase();
+}
+function inferModel(source) {
+  return HTML_EXTENSIONS.has(getExtension(source)) ? "MinerU-HTML" : "vlm";
+}
+function resolveModel(model, source) {
+  if (model != null) {
+    return MODEL_MAP[model] ?? model;
+  }
+  return inferModel(source);
+}
+function buildApiOptions(modelVersion, opts) {
+  const o = { model_version: modelVersion };
+  if (opts.formula !== void 0) o["enable_formula"] = opts.formula;
+  if (opts.table !== void 0) o["enable_table"] = opts.table;
+  if (opts.language !== void 0) o["language"] = opts.language;
+  if (opts.extraFormats?.length) {
+    o["extra_formats"] = opts.extraFormats;
+  }
+  return o;
+}
+function applyFileFields(entry, key, ocr, pages, fileParams) {
+  const fp = fileParams?.[key];
+  const effectiveOcr = fp?.ocr !== void 0 ? fp.ocr : ocr;
+  if (effectiveOcr !== void 0) entry["is_ocr"] = effectiveOcr;
+  const effectivePages = fp?.pages || pages;
+  if (effectivePages) entry["page_ranges"] = effectivePages;
+  if (fp?.dataId) entry["data_id"] = fp.dataId;
+}
+function parseTaskResult(data) {
+  const result = createEmptyResult(
+    data["task_id"] ?? "",
+    data["state"] ?? "unknown"
+  );
+  result.filename = data["file_name"] ?? null;
+  const errCodeRaw = data["err_code"];
+  result.errCode = errCodeRaw == null ? "" : String(errCodeRaw);
+  result.error = data["err_msg"] || null;
+  result.zipUrl = data["full_zip_url"] ?? null;
+  const ep = data["extract_progress"];
+  if (ep) {
+    result.progress = {
+      extractedPages: ep["extracted_pages"] ?? 0,
+      totalPages: ep["total_pages"] ?? 0,
+      startTime: ep["start_time"] ?? ""
+    };
+  }
+  return result;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var MinerU = class {
+  api;
+  flashApi;
+  /**
+   * @param token - API token.
+   * @param baseUrl - API base URL.
+   * @param flashBaseUrl - Flash API base URL.
+   */
+  constructor(token, baseUrl = DEFAULT_BASE_URL, flashBaseUrl) {
+    const resolved = token ?? process.env["MINERU_TOKEN"];
+    if (resolved) {
+      this.api = new ApiClient(resolved, baseUrl, DEFAULT_SOURCE);
+    } else {
+      this.api = null;
+    }
+    this.flashApi = new FlashApiClient(flashBaseUrl, DEFAULT_SOURCE);
+  }
+  setSource(source) {
+    if (this.api !== null) {
+      this.api.setSource(source);
+    }
+    this.flashApi.setSource(source);
+  }
+  requireAuth() {
+    if (this.api === null) {
+      throw new NoAuthClientError();
+    }
+    return this.api;
+  }
+  // ══════════════════════════════════════════════════════════════════
+  //  Synchronous (blocking) methods
+  // ══════════════════════════════════════════════════════════════════
+  async extract(source, options = {}) {
+    this.requireAuth();
+    const { timeout = DEFAULT_TIMEOUT_POLL_SINGLE, ...opts } = options;
+    const modelVersion = resolveModel(opts.model, source);
+    const apiOpts = buildApiOptions(modelVersion, opts);
+    let batchId;
+    if (isUrl(source)) {
+      batchId = await this.submitUrlsBatch([source], apiOpts, opts.ocr, opts.pages, opts.fileParams);
+    } else {
+      batchId = await this.uploadAndSubmit([source], apiOpts, opts.ocr, opts.pages, opts.fileParams);
+    }
+    const results = await this.waitBatch(batchId, timeout);
+    return results[0];
+  }
+  async *extractBatch(sources, options = {}) {
+    this.requireAuth();
+    const { timeout = DEFAULT_TIMEOUT_POLL_BATCH, ...opts } = options;
+    const firstSource = sources[0] ?? "";
+    const modelVersion = resolveModel(opts.model, firstSource);
+    const apiOpts = buildApiOptions(modelVersion, opts);
+    const urls = sources.filter(isUrl);
+    const files = sources.filter((s) => !isUrl(s));
+    const batchIds = [];
+    if (urls.length > 0) {
+      batchIds.push(await this.submitUrlsBatch(urls, apiOpts, opts.ocr, void 0, opts.fileParams));
+    }
+    if (files.length > 0) {
+      batchIds.push(await this.uploadAndSubmit(files, apiOpts, opts.ocr, void 0, opts.fileParams));
+    }
+    yield* this.yieldBatch(batchIds, sources.length, timeout);
+  }
+  async crawl(url, options = {}) {
+    return this.extract(url, { model: "html", timeout: DEFAULT_TIMEOUT_POLL_SINGLE, ...options });
+  }
+  async *crawlBatch(urls, options = {}) {
+    yield* this.extractBatch(urls, { model: "html", timeout: DEFAULT_TIMEOUT_POLL_BATCH, ...options });
+  }
+  // ══════════════════════════════════════════════════════════════════
+  //  Async primitives (no polling, no waiting)
+  // ══════════════════════════════════════════════════════════════════
+  async submit(source, options = {}) {
+    this.requireAuth();
+    const modelVersion = resolveModel(options.model, source);
+    const apiOpts = buildApiOptions(modelVersion, options);
+    if (isUrl(source)) {
+      return this.submitUrlsBatch([source], apiOpts, options.ocr, options.pages, options.fileParams);
+    }
+    return this.uploadAndSubmit([source], apiOpts, options.ocr, options.pages, options.fileParams);
+  }
+  async submitBatch(sources, options = {}) {
+    this.requireAuth();
+    const firstSource = sources[0] ?? "";
+    const modelVersion = resolveModel(options.model, firstSource);
+    const apiOpts = buildApiOptions(modelVersion, options);
+    const urls = sources.filter(isUrl);
+    const files = sources.filter((s) => !isUrl(s));
+    if (urls.length === 0 && files.length === 0) {
+      throw new Error("No sources provided.");
+    }
+    if (urls.length > 0 && files.length > 0) {
+      throw new Error(
+        "submitBatch() does not support mixing URLs and local files in one call. Please submit them separately or use extractBatch() instead."
+      );
+    }
+    if (urls.length > 0) {
+      return this.submitUrlsBatch(urls, apiOpts, options.ocr, void 0, options.fileParams);
+    }
+    return this.uploadAndSubmit(files, apiOpts, options.ocr, void 0, options.fileParams);
+  }
+  async getTask(taskId) {
+    const api = this.requireAuth();
+    const body = await api.get(`/extract/task/${taskId}`);
+    const result = parseTaskResult(body.data);
+    if (result.state === "done" && result.zipUrl) {
+      return this.downloadAndParse(result);
+    }
+    return result;
+  }
+  async getBatch(batchId) {
+    const api = this.requireAuth();
+    const body = await api.get(`/extract-results/batch/${batchId}`);
+    const items = body.data["extract_result"] ?? [];
+    const results = [];
+    for (const item of items) {
+      let r = parseTaskResult(item);
+      if (r.state === "done" && r.zipUrl) {
+        r = await this.downloadAndParse(r);
+      }
+      results.push(r);
+    }
+    return results;
+  }
+  // ══════════════════════════════════════════════════════════════════
+  //  Internal helpers
+  // ══════════════════════════════════════════════════════════════════
+  async submitUrlsBatch(urls, opts, ocr, pages, fileParams) {
+    const files = urls.map((u) => {
+      const entry = { url: u };
+      applyFileFields(entry, u, ocr, pages, fileParams);
+      return entry;
+    });
+    const body = await this.requireAuth().post("/extract/task/batch", {
+      files,
+      ...opts
+    });
+    return body.data["batch_id"];
+  }
+  async uploadAndSubmit(filePaths, opts, ocr, pages, fileParams) {
+    const api = this.requireAuth();
+    const filesMeta = filePaths.map((p) => {
+      const entry = { name: basename2(p) };
+      applyFileFields(entry, p, ocr, pages, fileParams);
+      return entry;
+    });
+    const body = await api.post("/file-urls/batch", {
+      files: filesMeta,
+      ...opts
+    });
+    const batchId = body.data["batch_id"];
+    const uploadUrls = body.data["file_urls"];
+    for (let i = 0; i < filePaths.length; i++) {
+      const data = await readFile(filePaths[i]);
+      await api.putFile(uploadUrls[i], new Uint8Array(data));
+    }
+    return batchId;
+  }
+  async downloadAndParse(result) {
+    const zipBytes = await this.requireAuth().download(result.zipUrl);
+    const parsed = parseZip(zipBytes, result.taskId, result.filename);
+    parsed.zipUrl = result.zipUrl;
+    return parsed;
+  }
+  async waitBatch(batchId, timeout) {
+    const deadline = Date.now() + timeout * 1e3;
+    let interval = 2e3;
+    for (; ; ) {
+      const results = await this.getBatch(batchId);
+      if (results.every((r) => r.state === "done" || r.state === "failed")) {
+        return results;
+      }
+      if (Date.now() > deadline) {
+        throw new TimeoutError(timeout, batchId);
+      }
+      await sleep(Math.min(interval, Math.max(0, deadline - Date.now())));
+      interval = Math.min(interval * 2, 3e4);
+    }
+  }
+  async *yieldBatch(batchIds, total, timeout) {
+    const deadline = Date.now() + timeout * 1e3;
+    const yielded = /* @__PURE__ */ new Set();
+    let interval = 2e3;
+    while (yielded.size < total) {
+      for (const bid of batchIds) {
+        const results = await this.getBatch(bid);
+        for (let idx = 0; idx < results.length; idx++) {
+          const key = `${bid}:${idx}`;
+          const r = results[idx];
+          if (!yielded.has(key) && (r.state === "done" || r.state === "failed")) {
+            yielded.add(key);
+            yield r;
+          }
+        }
+      }
+      if (yielded.size >= total) break;
+      if (Date.now() > deadline) {
+        throw new TimeoutError(timeout, batchIds.join(","));
+      }
+      await sleep(Math.min(interval, Math.max(0, deadline - Date.now())));
+      interval = Math.min(interval * 2, 3e4);
+    }
+  }
+  // ══════════════════════════════════════════════════════════════════
+  //  Flash (agent) mode
+  // ══════════════════════════════════════════════════════════════════
+  async flashExtract(source, options = {}) {
+    const { language = "ch", pageRange, timeout = DEFAULT_TIMEOUT_POLL_SINGLE } = options;
+    let taskId;
+    if (isUrl(source)) {
+      taskId = await this.flashSubmitUrl(source, language, pageRange);
+    } else {
+      taskId = await this.flashSubmitFile(source, language, pageRange);
+    }
+    return this.flashWait(taskId, timeout);
+  }
+  // ── Flash internal helpers ──
+  async flashSubmitUrl(url, language, pageRange) {
+    const payload = { url, language };
+    if (pageRange != null) payload["page_range"] = pageRange;
+    const body = await this.flashApi.post("/parse/url", payload);
+    return body.data["task_id"];
+  }
+  async flashSubmitFile(filePath, language, pageRange) {
+    const fileName = basename2(filePath);
+    const payload = { file_name: fileName, language };
+    if (pageRange != null) payload["page_range"] = pageRange;
+    const body = await this.flashApi.post("/parse/file", payload);
+    const taskId = body.data["task_id"];
+    const fileUrl = body.data["file_url"];
+    const data = await readFile(filePath);
+    await this.flashApi.putFile(fileUrl, new Uint8Array(data));
+    return taskId;
+  }
+  async flashWait(taskId, timeout) {
+    const deadline = Date.now() + timeout * 1e3;
+    let interval = 2e3;
+    for (; ; ) {
+      const result = await this.flashGetTask(taskId);
+      if (result.state === "done" || result.state === "failed") return result;
+      if (Date.now() > deadline) throw new TimeoutError(timeout, taskId);
+      await sleep(Math.min(interval, Math.max(0, deadline - Date.now())));
+      interval = Math.min(interval * 2, 3e4);
+    }
+  }
+  async flashGetTask(taskId) {
+    const body = await this.flashApi.get(`/parse/${taskId}`);
+    return this.parseFlashTask(body.data);
+  }
+  async parseFlashTask(data) {
+    const result = createEmptyResult(
+      data["task_id"] ?? "",
+      data["state"] ?? "unknown"
+    );
+    const errCodeRaw = data["err_code"];
+    result.errCode = errCodeRaw == null ? "" : String(errCodeRaw);
+    result.error = data["err_msg"] || null;
+    const ep = data["extract_progress"];
+    if (ep) {
+      result.progress = {
+        extractedPages: ep["extracted_pages"] ?? 0,
+        totalPages: ep["total_pages"] ?? 0,
+        startTime: ep["start_time"] ?? ""
+      };
+    }
+    if (result.state === "done" && data["markdown_url"]) {
+      result.markdown = await this.flashApi.downloadText(
+        data["markdown_url"]
+      );
+    }
+    return result;
+  }
+};
+export {
+  AuthError,
+  DEFAULT_BASE_URL,
+  DEFAULT_FLASH_BASE_URL,
+  ExtractFailedError,
+  FileTooLargeError,
+  FlashFileTooLargeError,
+  FlashPageLimitError,
+  FlashParamError,
+  FlashUnsupportedTypeError,
+  MinerU,
+  MinerUError,
+  NoAuthClientError,
+  PageLimitError,
+  ParamError,
+  QuotaExceededError,
+  TaskNotFoundError,
+  TimeoutError,
+  progressPercent,
+  progressToString,
+  saveAll,
+  saveDocx,
+  saveHtml,
+  saveLatex,
+  saveMarkdown
+};
+//# sourceMappingURL=index.js.map