somark-js 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1304 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  APIError: () => APIError,
+  AuthenticationError: () => AuthenticationError,
+  ConnectionError: () => ConnectionError,
+  DocumentParser: () => DocumentParser,
+  FileTooLargeError: () => FileTooLargeError,
+  InsufficientBalanceError: () => InsufficientBalanceError,
+  InvalidParamError: () => InvalidParamError,
+  PDFProcessor: () => PDFProcessor,
+  ParseFailedError: () => ParseFailedError,
+  ParseResponse: () => ParseResponse,
+  ParseTimeoutError: () => ParseTimeoutError,
+  RateLimitError: () => RateLimitError,
+  RequestTimeoutError: () => RequestTimeoutError,
+  SoMark: () => SoMark,
+  SoMarkDown: () => SoMarkDown,
+  SoMarkDownPreview: () => SoMarkDownPreview,
+  SoMarkError: () => SoMarkError,
+  Task: () => Task,
+  UnsupportedFileError: () => UnsupportedFileError,
+  Usage: () => Usage,
+  UsageClient: () => UsageClient
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+var DEFAULT_BASE_URL = "https://somark.tech/api/v1";
+var DEFAULT_TIMEOUT = 60;
+var DEFAULT_MAX_RETRIES = 2;
+var CONFIG_FILE = path.join(os.homedir(), ".somark", "config.toml");
+var VALID_CONFIG_KEYS = ["api_key", "base_url", "timeout", "max_retries"];
+function parseOptionalString(value) {
+  return value === void 0 || value === null ? void 0 : String(value);
+}
+function parseString(value) {
+  return String(value);
+}
+function parseNumber(value) {
+  return Number(value);
+}
+function parseInteger(value) {
+  return Number.parseInt(String(value), 10);
+}
+function validateAny(_key, _value) {
+}
+function validateBaseUrl(key, value) {
+  if (!/^https?:\/\//i.test(String(value))) {
+    throw new Error(`Invalid ${key} "${value}". Must start with http:// or https://`);
+  }
+}
+function maskIdentity(value) {
+  return value;
+}
+function maskApiKey(value) {
+  return value.length > 8 ? `${value.slice(0, 4)}...${value.slice(-4)}` : "***";
+}
+function formatValue(value) {
+  return String(value);
+}
+var CONFIG_SCHEMA = [
+  {
+    key: "api_key",
+    envVar: "SOMARK_API_KEY",
+    optionKey: "apiKey",
+    defaultValue: void 0,
+    parse: parseOptionalString,
+    validate: validateAny,
+    mask: maskApiKey,
+    format: formatValue,
+    showWhenUnset: false
+  },
+  {
+    key: "base_url",
+    envVar: "SOMARK_BASE_URL",
+    optionKey: "baseUrl",
+    defaultValue: DEFAULT_BASE_URL,
+    parse: parseString,
+    validate: validateBaseUrl,
+    mask: maskIdentity,
+    format: formatValue,
+    showWhenUnset: true
+  },
+  {
+    key: "timeout",
+    envVar: "SOMARK_TIMEOUT",
+    optionKey: "timeout",
+    defaultValue: DEFAULT_TIMEOUT,
+    parse: parseNumber,
+    validate: validateAny,
+    mask: maskIdentity,
+    format: formatValue,
+    showWhenUnset: true
+  },
+  {
+    key: "max_retries",
+    envVar: "SOMARK_MAX_RETRIES",
+    optionKey: "maxRetries",
+    defaultValue: DEFAULT_MAX_RETRIES,
+    parse: parseInteger,
+    validate: validateAny,
+    mask: maskIdentity,
+    format: formatValue,
+    showWhenUnset: true
+  }
+];
+var CONFIG_SCHEMA_BY_KEY = new Map(
+  CONFIG_SCHEMA.map((entry) => [entry.key, entry])
+);
+function stripTomlComment(line) {
+  let quote;
+  let escaping = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (quote === '"') {
+      if (escaping) {
+        escaping = false;
+      } else if (char === "\\") {
+        escaping = true;
+      } else if (char === quote) {
+        quote = void 0;
+      }
+    } else if (quote === "'") {
+      if (char === quote) quote = void 0;
+    } else if (char === '"' || char === "'") {
+      quote = char;
+    } else if (char === "#") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function parseTomlValue(rawValue) {
+  const value = stripTomlComment(rawValue).trim();
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return JSON.parse(value);
+  }
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (/^[+-]?(?:\d+\.?\d*|\.\d+)$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+function loadTomlConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const result = {};
+    for (const line of content.split("\n")) {
+      const trimmed = stripTomlComment(line).trim();
+      if (!trimmed || trimmed.startsWith("[")) continue;
+      const separatorIndex = trimmed.indexOf("=");
+      if (separatorIndex === -1) continue;
+      const key = trimmed.slice(0, separatorIndex).trim();
+      if (!VALID_CONFIG_KEYS.includes(key)) continue;
+      result[key] = parseTomlValue(trimmed.slice(separatorIndex + 1));
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function hasFileValue(file, key) {
+  const value = file[key];
+  return value !== void 0 && value !== null && value !== "";
+}
+function resolveSchemaEntry(entry, opts, file) {
+  let rawValue;
+  let source;
+  if (opts[entry.optionKey] !== void 0) {
+    rawValue = opts[entry.optionKey];
+    source = "explicit";
+  } else if (process.env[entry.envVar]) {
+    rawValue = process.env[entry.envVar];
+    source = "env";
+  } else if (hasFileValue(file, entry.key)) {
+    rawValue = file[entry.key];
+    source = "file";
+  } else {
+    rawValue = entry.defaultValue;
+    source = "default";
+  }
+  const value = entry.parse(rawValue);
+  entry.validate(entry.key, value);
+  return { value, source };
+}
+function resolveSchema(opts = {}) {
+  const file = loadTomlConfig();
+  return Object.fromEntries(
+    CONFIG_SCHEMA.map((entry) => [entry.key, resolveSchemaEntry(entry, opts, file)])
+  );
+}
+function resolveConfig(opts = {}) {
+  const resolved = resolveSchema(opts);
+  return {
+    apiKey: resolved.api_key.value,
+    baseUrl: resolved.base_url.value,
+    timeout: resolved.timeout.value,
+    maxRetries: resolved.max_retries.value
+  };
+}
+
+// src/errors.ts
+var SoMarkError = class extends Error {
+  code;
+  constructor(message = "", code = -1) {
+    super(message);
+    this.name = "SoMarkError";
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends SoMarkError {
+  constructor(message = "Authentication failed", code = -1) {
+    super(message, code);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientBalanceError = class extends SoMarkError {
+  constructor(message = "Insufficient balance", code = -1) {
+    super(message, code);
+    this.name = "InsufficientBalanceError";
+  }
+};
+var RateLimitError = class extends SoMarkError {
+  constructor(message = "Rate limit exceeded", code = -1) {
+    super(message, code);
+    this.name = "RateLimitError";
+  }
+};
+var UnsupportedFileError = class extends SoMarkError {
+  constructor(message = "Unsupported file type", code = -1) {
+    super(message, code);
+    this.name = "UnsupportedFileError";
+  }
+};
+var FileTooLargeError = class extends SoMarkError {
+  constructor(message = "File too large", code = -1) {
+    super(message, code);
+    this.name = "FileTooLargeError";
+  }
+};
+var ParseTimeoutError = class extends SoMarkError {
+  constructor(message = "Parse timed out", code = -1) {
+    super(message, code);
+    this.name = "ParseTimeoutError";
+  }
+};
+var ParseFailedError = class extends SoMarkError {
+  constructor(message = "Parse failed", code = -1) {
+    super(message, code);
+    this.name = "ParseFailedError";
+  }
+};
+var InvalidParamError = class extends SoMarkError {
+  constructor(message = "Invalid parameter", code = -1) {
+    super(message, code);
+    this.name = "InvalidParamError";
+  }
+};
+var APIError = class extends SoMarkError {
+  constructor(message = "API error", code = -1) {
+    super(message, code);
+    this.name = "APIError";
+  }
+};
+var ConnectionError = class extends SoMarkError {
+  constructor(message = "Connection failed", code = -1) {
+    super(message, code);
+    this.name = "ConnectionError";
+  }
+};
+var RequestTimeoutError = class extends SoMarkError {
+  constructor(message = "Request timed out", code = -1) {
+    super(message, code);
+    this.name = "RequestTimeoutError";
+  }
+};
+var CODE_TO_ERROR = {
+  1101: RateLimitError,
+  1102: ParseTimeoutError,
+  1104: UnsupportedFileError,
+  1105: InvalidParamError,
+  1106: InvalidParamError,
+  1107: AuthenticationError,
+  1108: InsufficientBalanceError,
+  1111: APIError,
+  1118: FileTooLargeError,
+  1120: APIError,
+  1123: InsufficientBalanceError,
+  1124: RateLimitError,
+  1132: FileTooLargeError,
+  1133: InvalidParamError,
+  1137: ParseFailedError,
+  1138: APIError
+};
+function raiseForCode(code, message = "") {
+  const ErrorClass = CODE_TO_ERROR[code] ?? APIError;
+  throw new ErrorClass(message || `API error (code=${code})`, code);
+}
+
+// src/http.ts
+var RETRY_CODES = /* @__PURE__ */ new Set([1101, 1124]);
+var RETRY_HTTP_STATUSES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.timeoutMs = opts.timeout * 1e3;
+    this.maxRetries = opts.maxRetries;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  buildFormData(data) {
+    const form = new FormData();
+    if (this.apiKey) form.append("api_key", this.apiKey);
+    for (const [k, v] of Object.entries(data)) {
+      if (v === void 0) continue;
+      if (Array.isArray(v)) {
+        for (const item of v) form.append(k, item);
+      } else {
+        form.append(k, v);
+      }
+    }
+    return form;
+  }
+  async post(path8, data = {}, file) {
+    const url = this.baseUrl + path8;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const form = this.buildFormData(data);
+        if (file) {
+          const blob = new Blob([file.buffer], { type: file.mimeType });
+          form.append("file", blob, file.name);
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+          response = await fetch(url, { method: "POST", body: form, signal: controller.signal });
+        } finally {
+          clearTimeout(timer);
+        }
+        if (RETRY_HTTP_STATUSES.has(response.status) && attempt < this.maxRetries) {
+          await sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        if (!response.ok) {
+          throw new APIError(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const result = await response.json();
+        const code = result.code ?? -1;
+        if (code !== 0) {
+          if (RETRY_CODES.has(code) && attempt < this.maxRetries) {
+            await sleep(Math.pow(2, attempt) * 1e3);
+            continue;
+          }
+          raiseForCode(code, (result.message ?? result.msg) || "");
+        }
+        return result;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          lastError = new RequestTimeoutError("Request timed out");
+        } else if (err instanceof TypeError && err.message.includes("fetch")) {
+          lastError = new ConnectionError(err.message);
+        } else if (err instanceof Error && err.code === "ECONNREFUSED") {
+          lastError = new ConnectionError(err.message);
+        } else {
+          throw err;
+        }
+        if (attempt < this.maxRetries) await sleep(Math.pow(2, attempt) * 1e3);
+      }
+    }
+    throw lastError ?? new APIError("Request failed after retries");
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/resources/parser.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/models.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+
+// src/warnings.ts
+var warningsSuppressed = false;
+function dedupe(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const message of messages) {
+    if (seen.has(message)) continue;
+    seen.add(message);
+    result.push(message);
+  }
+  return result;
+}
+function collectApiWarnings(data) {
+  const raw = data.warnings;
+  if (!Array.isArray(raw)) return [];
+  return dedupe(raw.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean));
+}
+function emitWarnings(warnings) {
+  if (warningsSuppressed) return;
+  for (const warning of dedupe(warnings)) {
+    process.emitWarning(warning, { type: "SoMarkWarning" });
+  }
+}
+function parseMaxConcurrency(raw) {
+  const value = raw?.trim() ?? "";
+  if (!value) return { value: 1, warnings: [] };
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    return {
+      value: 1,
+      warnings: [`Invalid SOMARK_PARSE_MAX_CONCURRENCY="${value}"; using 1.`]
+    };
+  }
+  if (parsed >= 2) {
+    return {
+      value: parsed,
+      warnings: [
+        `SOMARK_PARSE_MAX_CONCURRENCY is set to ${parsed}. The official default quota is 1 for everyone; only users explicitly approved for higher concurrency should use 2 or above.`
+      ]
+    };
+  }
+  return { value: parsed, warnings: [] };
+}
+
+// src/models.ts
+var ParseResponse = class _ParseResponse {
+  ok;
+  code;
+  message;
+  warnings;
+  taskId;
+  pages;
+  fileType;
+  imgs;
+  md;
+  jsonOutput;
+  zipUrl;
+  sourceFileName;
+  constructor(data) {
+    this.ok = data.ok;
+    this.code = data.code;
+    this.message = data.message;
+    this.warnings = data.warnings ?? [];
+    this.taskId = data.taskId;
+    this.pages = data.pages;
+    this.fileType = data.fileType;
+    this.imgs = data.imgs;
+    this.md = data.md;
+    this.jsonOutput = data.jsonOutput;
+    this.zipUrl = data.zipUrl;
+    this.sourceFileName = data.sourceFileName;
+  }
+  async save(targetPath, format) {
+    const plan = planOutput(this.sourceFileName, targetPath, format, { allowStdout: false });
+    for (const target of plan.targets) {
+      if (target.stdout || !target.path) throw new Error("save path is required");
+      await this.saveFormat(target.path, target.format);
+    }
+  }
+  contentForFormat(format) {
+    const fmt = normalizeOutputFormat(format);
+    if (fmt === "json") return JSON.stringify(this.jsonOutput ?? {}, null, 2);
+    if (fmt === "md") return this.md ?? "";
+    if (fmt === "zip") {
+      if (!this.zipUrl) throw new Error("ZIP output URL was not returned by the API.");
+      return this.zipUrl;
+    }
+    throw new Error(`Unsupported output format: ${fmt}. Valid formats: md, markdown, json, zip.`);
+  }
+  async saveFormat(targetPath, format) {
+    const fmt = normalizeOutputFormat(format);
+    if (fmt === "zip") {
+      if (!this.zipUrl) throw new Error("ZIP output URL was not returned by the API.");
+      await downloadOutputFile(targetPath, this.zipUrl);
+      return;
+    }
+    fs2.writeFileSync(targetPath, this.contentForFormat(fmt), "utf-8");
+  }
+  toJSON() {
+    return {
+      ok: this.ok,
+      code: this.code,
+      message: this.message,
+      warnings: this.warnings,
+      taskId: this.taskId,
+      pages: this.pages,
+      fileType: this.fileType,
+      imgs: this.imgs,
+      md: this.md,
+      jsonOutput: this.jsonOutput,
+      zipUrl: this.zipUrl,
+      sourceFileName: this.sourceFileName
+    };
+  }
+  static fromApi(data) {
+    const apiData = data.data ?? {};
+    const metadata = apiData.metadata ?? {};
+    const result = apiData.result ?? {};
+    const outputs = result.outputs ?? {};
+    const warnings = collectApiWarnings(data);
+    return new _ParseResponse({
+      ok: data.code === 0,
+      code: data.code ?? -1,
+      message: data.message ?? data.msg ?? "",
+      warnings,
+      taskId: apiData.task_id ?? "",
+      pages: metadata.page_num ?? 0,
+      fileType: metadata.file_type ?? "",
+      imgs: result.imgs ?? [],
+      md: outputs.markdown,
+      jsonOutput: outputs.json,
+      zipUrl: outputs.zip,
+      sourceFileName: result.file_name ?? apiData.file_name
+    });
+  }
+};
+function normalizeOutputFormat(format) {
+  const fmt = format.trim().toLowerCase();
+  return { markdown: "md" }[fmt] ?? fmt;
+}
+function normalizeSaveFormats(format, targetPath) {
+  const rawFormats = Array.isArray(format) ? format : typeof format === "string" ? format.split(",").map((item) => item.trim()) : [path2.extname(targetPath ?? "").replace(/^\./, "") || "md"];
+  const formats = rawFormats.map(normalizeOutputFormat).filter(Boolean);
+  const normalized = formats.length ? formats : ["md"];
+  const invalid = normalized.filter((fmt) => !["md", "json", "zip"].includes(fmt));
+  if (invalid.length) {
+    throw new Error(`Unsupported output format: ${invalid.join(", ")}. Valid formats: md, markdown, json, zip.`);
+  }
+  return normalized;
+}
+function planOutput(sourceFileName, out, format, opts = {}) {
+  const formats = normalizeSaveFormats(format, out);
+  if (opts.batch) {
+    if (!out || !isExistingDirectory(out)) {
+      throw new Error("batch parse requires --out to be an existing directory");
+    }
+    return directoryOutputPlan(sourceFileName, out, formats);
+  }
+  if (!out) {
+    if (formats.length > 1) throw new Error("multiple formats require --out to be an existing directory");
+    if (!opts.allowStdout) throw new Error("output path is required");
+    return { formats, targets: [{ format: formats[0], stdout: true }], stdout: true };
+  }
+  if (isExistingDirectory(out)) return directoryOutputPlan(sourceFileName, out, formats);
+  if (formats.length > 1) throw new Error("multiple formats require --out to be an existing directory");
+  if (looksLikeDirectoryPath(out)) throw new Error(`output directory does not exist: ${out}`);
+  const parent = path2.dirname(path2.resolve(out));
+  if (!isExistingDirectory(parent)) throw new Error(`output parent directory does not exist: ${parent}`);
+  return { formats, targets: [{ format: formats[0], path: out, stdout: false }], stdout: false };
+}
+function directoryOutputPlan(sourceFileName, directory, formats) {
+  const stem = sourceStem(sourceFileName);
+  if (!stem) throw new Error("saving to a directory requires a source file name");
+  return {
+    formats,
+    targets: formats.map((fmt) => ({
+      format: fmt,
+      path: path2.join(directory, `${stem}.${formatExt(fmt)}`),
+      stdout: false
+    })),
+    stdout: false
+  };
+}
+function formatExt(format) {
+  return normalizeOutputFormat(format) === "md" ? "md" : normalizeOutputFormat(format);
+}
+function sourceStem(fileName) {
+  if (!fileName) return void 0;
+  return path2.basename(fileName, path2.extname(fileName));
+}
+function isExistingDirectory(target) {
+  return fs2.existsSync(target) && fs2.statSync(target).isDirectory();
+}
+function looksLikeDirectoryPath(target) {
+  return target.endsWith(path2.sep) || target.endsWith("/");
+}
+async function downloadOutputFile(targetPath, url) {
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(6e4) });
+  } catch (err) {
+    throw new Error(`failed to download ZIP output: ${err.message}`);
+  }
+  if (!response.ok) {
+    throw new Error(`failed to download ZIP output: HTTP ${response.status}: ${response.statusText}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  fs2.writeFileSync(targetPath, bytes);
+}
+var Usage = class _Usage {
+  ok;
+  code;
+  message;
+  warnings;
+  remainingPaidPages;
+  remainingFreePagesToday;
+  remainingFreePagesThisMonth;
+  dashboardUrl;
+  constructor(data) {
+    this.ok = data.ok;
+    this.code = data.code;
+    this.message = data.message;
+    this.warnings = data.warnings ?? [];
+    this.remainingPaidPages = data.remainingPaidPages;
+    this.remainingFreePagesToday = data.remainingFreePagesToday;
+    this.remainingFreePagesThisMonth = data.remainingFreePagesThisMonth;
+    this.dashboardUrl = data.dashboardUrl;
+  }
+  toJSON() {
+    return {
+      ok: this.ok,
+      code: this.code,
+      message: this.message,
+      warnings: this.warnings,
+      remainingPaidPages: this.remainingPaidPages,
+      remainingFreePagesToday: this.remainingFreePagesToday,
+      remainingFreePagesThisMonth: this.remainingFreePagesThisMonth,
+      dashboardUrl: this.dashboardUrl
+    };
+  }
+  static fromApi(data) {
+    const apiData = data.data ?? {};
+    const warnings = collectApiWarnings(data);
+    return new _Usage({
+      ok: data.code === 0,
+      code: data.code ?? -1,
+      message: data.message ?? data.msg ?? "",
+      warnings,
+      remainingPaidPages: apiData.remaining_paid_pages ?? 0,
+      remainingFreePagesToday: apiData.remaining_free_pages_today ?? 0,
+      remainingFreePagesThisMonth: apiData.remaining_free_pages_this_month ?? 0,
+      dashboardUrl: apiData.dashboard_url ?? "https://somark.tech/workbench"
+    });
+  }
+};
+var Task = class {
+  id;
+  completed = false;
+  status = "queuing";
+  recordId;
+  fileName;
+  pages;
+  warnings;
+  refreshHandler;
+  _result;
+  constructor(taskId, refreshHandler, warnings = []) {
+    this.id = taskId;
+    this.refreshHandler = refreshHandler;
+    this.warnings = warnings;
+  }
+  async refresh() {
+    if (!this.refreshHandler) {
+      throw new Error("Task cannot refresh without a parser resource. Use client.parser.task(taskId).");
+    }
+    const data = await this.refreshHandler(this.id);
+    this.applyApi(data);
+  }
+  applyApi(data) {
+    this.warnings = collectApiWarnings(data);
+    const apiData = data.data ?? {};
+    const rawStatus = apiData.status ?? this.status;
+    this.status = rawStatus.toLowerCase();
+    this.recordId = apiData.record_id;
+    this.fileName = apiData.file_name;
+    const metadata = apiData.metadata ?? {};
+    this.pages = metadata.page_num;
+    if (this.status === "success" || this.status === "failed") {
+      this.completed = true;
+      if (this.status === "success") {
+        this._result = ParseResponse.fromApi(data);
+      }
+    }
+  }
+  async wait(opts = {}) {
+    const pollInterval = (opts.pollInterval ?? 3) * 1e3;
+    const timeout = (opts.timeout ?? 120) * 1e3;
+    const start = Date.now();
+    while (!this.completed) {
+      if (Date.now() - start >= timeout) {
+        throw new ParseTimeoutError(`Task ${this.id} timed out`);
+      }
+      await sleep2(pollInterval);
+      await this.refresh();
+    }
+    if (this.status === "failed") throw new ParseFailedError(`Task ${this.id} failed`);
+    return this._result;
+  }
+  result() {
+    if (!this._result) throw new Error("Task not completed. Call wait() first.");
+    return this._result;
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/resources/parse-core.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var FMT_MAP = { md: "markdown", zip: "zip", json: "json" };
+var VALID_API_FORMATS = /* @__PURE__ */ new Set(["markdown", "json", "zip"]);
+var VALID_FORMAT_HINT = "md, markdown, json, zip";
+function buildParseData(opts) {
+  const data = {};
+  if (opts.formats?.length) {
+    const mapped = opts.formats.map((f) => {
+      const normalized = normalizeOutputFormat(f);
+      return FMT_MAP[normalized] ?? normalized;
+    });
+    const invalid = mapped.filter((f) => !VALID_API_FORMATS.has(f));
+    if (invalid.length) {
+      throw new InvalidParamError(`Unsupported output format: ${invalid.join(", ")}. Valid formats: ${VALID_FORMAT_HINT}.`);
+    }
+    data.output_formats = mapped;
+  }
+  if (opts.elementFormats) {
+    const ef = opts.elementFormats;
+    const efObj = {};
+    if (ef.image) efObj.image = ef.image;
+    if (ef.formula) efObj.formula = ef.formula;
+    if (ef.table) efObj.table = ef.table;
+    if (ef.cs) efObj.cs = ef.cs;
+    if (Object.keys(efObj).length) data.element_formats = JSON.stringify(efObj);
+  }
+  if (opts.extractConfig) {
+    const ec = opts.extractConfig;
+    const fcObj = {};
+    if (ec.enableTextCrossPage !== void 0) fcObj.enable_text_cross_page = ec.enableTextCrossPage;
+    if (ec.enableTableCrossPage !== void 0) fcObj.enable_table_cross_page = ec.enableTableCrossPage;
+    if (ec.enableTitleLevelRecognition !== void 0) fcObj.enable_title_level_recognition = ec.enableTitleLevelRecognition;
+    if (ec.enableInlineImage !== void 0) fcObj.enable_inline_image = ec.enableInlineImage;
+    if (ec.enableTableImage !== void 0) fcObj.enable_table_image = ec.enableTableImage;
+    if (ec.enableImageUnderstanding !== void 0) fcObj.enable_image_understanding = ec.enableImageUnderstanding;
+    if (ec.keepHeaderFooter !== void 0) fcObj.keep_header_footer = ec.keepHeaderFooter;
+    if (Object.keys(fcObj).length) data.feature_config = JSON.stringify(fcObj);
+  }
+  return data;
+}
+function readFileList(file) {
+  if (!fs3.existsSync(file)) throw new InvalidParamError(`File list not found: ${file}`);
+  return fs3.readFileSync(file, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((item) => path3.isAbsolute(item) ? item : path3.resolve(item));
+}
+function resolveFileInputs(file, fileList = false) {
+  if (fileList) {
+    const manifests = Array.isArray(file) ? file : [file];
+    return { files: manifests.flatMap(readFileList), isBatch: true };
+  }
+  if (Array.isArray(file)) return { files: file, isBatch: true };
+  return { files: [file], isBatch: false };
+}
+function ensureFilesExist(files) {
+  const missing = files.filter((file) => !fs3.existsSync(file) || !fs3.statSync(file).isFile());
+  if (missing.length) throw new InvalidParamError(`File not found: ${missing.join(", ")}`);
+}
+function parseBatchSettings(itemCount) {
+  const { value, warnings } = parseMaxConcurrency(process.env.SOMARK_PARSE_MAX_CONCURRENCY);
+  return { concurrency: Math.min(value, itemCount) || 1, warnings };
+}
+async function runLimited(files, worker, onResult) {
+  const { concurrency, warnings } = parseBatchSettings(files.length);
+  const results = new Array(files.length);
+  let next = 0;
+  async function runWorker() {
+    while (next < files.length) {
+      const index = next++;
+      const result = await worker(files[index]);
+      results[index] = result;
+      onResult?.(index, result);
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, () => runWorker()));
+  return { results, warnings, concurrency };
+}
+function attachWarnings(items, warnings) {
+  if (!warnings.length) return;
+  for (const item of items) {
+    item.warnings = [...item.warnings ?? [], ...warnings];
+  }
+}
+
+// src/resources/parser.ts
+var DocumentParser = class {
+  _http;
+  constructor(http2) {
+    this._http = http2;
+  }
+  checkApiKey() {
+    if (!this._http.getApiKey()) {
+      throw new AuthenticationError("apiKey is required for parser operations.");
+    }
+  }
+  async pollTask(taskId) {
+    this.checkApiKey();
+    const data = await this._http.post("/parse/async_check", { task_id: taskId });
+    emitWarnings(collectApiWarnings(data));
+    return data;
+  }
+  task(taskId) {
+    return new Task(taskId, (id) => this.pollTask(id));
+  }
+  async parseOne(opts) {
+    this.checkApiKey();
+    const data = buildParseData({ formats: opts.formats ?? ["md"], elementFormats: opts.elementFormats, extractConfig: opts.extractConfig });
+    const buffer = fs4.readFileSync(opts.file);
+    const fileName = path4.basename(opts.file);
+    const result = await this._http.post("/parse/sync", data, { name: fileName, buffer, mimeType: "application/octet-stream" });
+    const response = ParseResponse.fromApi(result);
+    emitWarnings(response.warnings);
+    response.sourceFileName = fileName;
+    return response;
+  }
+  async parse(opts) {
+    this.checkApiKey();
+    const { files, isBatch } = resolveFileInputs(opts.file, opts.fileList);
+    ensureFilesExist(files);
+    const { results: responses, warnings } = await runLimited(files, (file) => this.parseOne({ ...opts, file }));
+    if (isBatch) {
+      emitWarnings(warnings);
+      attachWarnings(responses, warnings);
+    }
+    return isBatch ? responses : responses[0];
+  }
+  async createOne(opts) {
+    this.checkApiKey();
+    const data = buildParseData({ formats: opts.formats ?? ["md"], elementFormats: opts.elementFormats, extractConfig: opts.extractConfig });
+    const buffer = fs4.readFileSync(opts.file);
+    const fileName = path4.basename(opts.file);
+    const result = await this._http.post("/parse/async", data, { name: fileName, buffer, mimeType: "application/octet-stream" });
+    const taskId = result.data?.task_id ?? "";
+    const warnings = collectApiWarnings(result);
+    emitWarnings(warnings);
+    return new Task(taskId, (id) => this.pollTask(id), warnings);
+  }
+  async create(opts) {
+    this.checkApiKey();
+    const { files, isBatch } = resolveFileInputs(opts.file, opts.fileList);
+    ensureFilesExist(files);
+    const { results: tasks, warnings } = await runLimited(files, (file) => this.createOne({ ...opts, file }));
+    if (isBatch) {
+      emitWarnings(warnings);
+      attachWarnings(tasks, warnings);
+    }
+    return isBatch ? tasks : tasks[0];
+  }
+};
+
+// src/resources/usage.ts
+var UsageClient = class {
+  _http;
+  constructor(http2) {
+    this._http = http2;
+  }
+  async get() {
+    if (!this._http.getApiKey()) {
+      throw new AuthenticationError("apiKey is required for usage queries.");
+    }
+    const result = await this._http.post("/usage", {});
+    const usage = Usage.fromApi(result);
+    emitWarnings(usage.warnings);
+    return usage;
+  }
+};
+
+// src/resources/pdf.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var PDFProcessor = class {
+  async toImages(opts) {
+    let pdfiumMod = null;
+    try {
+      pdfiumMod = await import("@hyzyla/pdfium");
+    } catch {
+      return { ok: false, files: [], error: "@hyzyla/pdfium is not installed. Run: npm install somark-js" };
+    }
+    let PNG = null;
+    try {
+      const pngjsMod = await import("pngjs");
+      PNG = pngjsMod.PNG;
+    } catch {
+      return { ok: false, files: [], error: "pngjs is not installed. Run: npm install pngjs" };
+    }
+    try {
+      const outDir = opts.out ?? "./";
+      if (!fs5.existsSync(outDir)) fs5.mkdirSync(outDir, { recursive: true });
+      const baseName = path5.basename(opts.file, path5.extname(opts.file));
+      const fmt = opts.filenameFormat ?? "{name}.page-{n}.png";
+      const dpi = opts.dpi ?? 150;
+      const scale = dpi / 72;
+      const pdfBuffer = fs5.readFileSync(opts.file);
+      const library = await pdfiumMod.PDFiumLibrary.init();
+      const document = await library.loadDocument(pdfBuffer);
+      const files = [];
+      const pageCount = document.getPageCount();
+      for (let i = 0; i < pageCount; i++) {
+        const page = document.getPage(i);
+        const image = await page.render({
+          scale,
+          render: async (renderOpts) => {
+            const png = new PNG({ width: renderOpts.width, height: renderOpts.height });
+            const src = renderOpts.data;
+            for (let j = 0; j < src.length; j += 4) {
+              png.data[j] = src[j + 2];
+              png.data[j + 1] = src[j + 1];
+              png.data[j + 2] = src[j];
+              png.data[j + 3] = src[j + 3];
+            }
+            return Buffer.from(PNG.sync.write(png));
+          }
+        });
+        const outName = fmt.replace("{name}", baseName).replace("{n}", String(i + 1));
+        const outPath = path5.join(outDir, outName);
+        fs5.writeFileSync(outPath, Buffer.from(image.data));
+        files.push(outPath);
+      }
+      document.destroy();
+      library.destroy();
+      return { ok: true, files };
+    } catch (err) {
+      return { ok: false, files: [], error: String(err) };
+    }
+  }
+};
+
+// src/resources/preview.ts
+var fs6 = __toESM(require("fs"), 1);
+var http = __toESM(require("http"), 1);
+var path6 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
+var SUPPORTED_PREVIEW_EXTS = /* @__PURE__ */ new Set([".md", ".smd"]);
+var VENDOR_FIX_HINT = "Run: git submodule update --init --recursive or somark doctor fix";
+var previewHttp = {
+  createServer: http.createServer
+};
+var previewFs = {
+  createReadStream: fs6.createReadStream,
+  existsSync: fs6.existsSync,
+  statSync: fs6.statSync
+};
+var MIME_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".png": "image/png",
+  ".smd": "text/plain; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp"
+};
+function currentModuleDir() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  return path6.dirname((0, import_url.fileURLToPath)(import_meta.url));
+}
+var previewVendorPaths = {
+  packageVendorDir() {
+    return path6.resolve(currentModuleDir(), "../vendor/somarkdown-viewer");
+  },
+  developmentVendorDir() {
+    return path6.resolve(process.cwd(), "vendor/somarkdown-viewer");
+  }
+};
+function vendorCandidates() {
+  const candidates = [
+    { dir: previewVendorPaths.packageVendorDir(), source: "package" },
+    { dir: previewVendorPaths.developmentVendorDir(), source: "development" }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.map((candidate) => ({ ...candidate, dir: path6.resolve(candidate.dir) })).filter((candidate) => {
+    if (seen.has(candidate.dir)) return false;
+    seen.add(candidate.dir);
+    return true;
+  });
+}
+function findVendorLocation() {
+  for (const candidate of vendorCandidates()) {
+    if (previewFs.existsSync(candidate.dir) && previewFs.statSync(candidate.dir).isDirectory()) return candidate;
+  }
+  return null;
+}
+function missingVendorEntries(vendorDir) {
+  const required = [
+    path6.join(vendorDir, "index.html"),
+    path6.join(vendorDir, "lib")
+  ];
+  return required.filter((candidate) => !previewFs.existsSync(candidate)).map((item) => path6.basename(item));
+}
+function validateVendorLocation(vendorLocation) {
+  if (!vendorLocation) {
+    throw new Error(`vendor/somarkdown-viewer not found. ${VENDOR_FIX_HINT}`);
+  }
+  const missing = missingVendorEntries(vendorLocation.dir);
+  if (missing.length > 0) {
+    if (vendorLocation.source === "package") {
+      throw new Error(`Installed preview assets are incomplete. Missing ${missing.join(", ")}. Reinstall the package or rebuild it with bundled viewer assets.`);
+    }
+    throw new Error(`vendor/somarkdown-viewer is incomplete. Missing ${missing.join(", ")}. ${VENDOR_FIX_HINT}`);
+  }
+  return vendorLocation;
+}
+function validatePreviewFile(file) {
+  const absolutePath = path6.resolve(file);
+  if (!previewFs.existsSync(absolutePath) || !previewFs.statSync(absolutePath).isFile()) {
+    throw new Error(`Preview file not found: ${absolutePath}`);
+  }
+  const ext = path6.extname(absolutePath).toLowerCase();
+  if (!SUPPORTED_PREVIEW_EXTS.has(ext)) {
+    throw new Error(`Unsupported preview file type: ${ext || "(no extension)"}. Use .md or .smd.`);
+  }
+  return {
+    absolutePath,
+    rootDir: path6.dirname(absolutePath),
+    routePath: `/_preview/file/${encodeURIComponent(path6.basename(absolutePath))}`
+  };
+}
+function normalizeRelativeRoute(routePathname) {
+  const prefix = "/_preview/file/";
+  if (!routePathname.startsWith(prefix)) return null;
+  const raw = routePathname.slice(prefix.length);
+  if (!raw) return null;
+  const decodedSegments = raw.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return null;
+    }
+  });
+  if (decodedSegments.some((segment) => !segment || segment === "." || segment === "..")) {
+    return null;
+  }
+  return decodedSegments.join(path6.sep);
+}
+function isPathInside(rootDir, candidatePath) {
+  const relativePath = path6.relative(rootDir, candidatePath);
+  return relativePath !== "" && !relativePath.startsWith("..") && !path6.isAbsolute(relativePath);
+}
+function sendFile(res, filePath) {
+  const ext = path6.extname(filePath).toLowerCase();
+  res.writeHead(200, { "Content-Type": MIME_TYPES[ext] ?? "application/octet-stream" });
+  previewFs.createReadStream(filePath).pipe(res);
+}
+function sendText(res, status, body) {
+  res.writeHead(status, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end(body);
+}
+var SoMarkDownPreview = class {
+  async start(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? 7878;
+    const openBrowser = opts.openBrowser ?? true;
+    const vendorLocation = validateVendorLocation(findVendorLocation());
+    const vendorDir = vendorLocation.dir;
+    const previewFile = opts.file ? validatePreviewFile(opts.file) : null;
+    const server = previewHttp.createServer((req, res) => {
+      const pathname = (req.url ?? "/").split("?")[0] || "/";
+      if (pathname === "/") {
+        sendFile(res, path6.join(vendorDir, "index.html"));
+        return;
+      }
+      const relativePreviewPath = normalizeRelativeRoute(pathname);
+      if (pathname.startsWith("/_preview/file/")) {
+        if (!previewFile) {
+          sendText(res, 404, "No preview file loaded.");
+          return;
+        }
+        if (!relativePreviewPath) {
+          sendText(res, 403, "Preview access denied.");
+          return;
+        }
+        const candidatePath = path6.resolve(previewFile.rootDir, relativePreviewPath);
+        if (candidatePath !== previewFile.absolutePath && !isPathInside(previewFile.rootDir, candidatePath)) {
+          sendText(res, 403, "Preview access denied.");
+          return;
+        }
+        if (!previewFs.existsSync(candidatePath) || !previewFs.statSync(candidatePath).isFile()) {
+          sendText(res, 404, "Preview file not found.");
+          return;
+        }
+        sendFile(res, candidatePath);
+        return;
+      }
+      const vendorPath = path6.resolve(vendorDir, `.${pathname}`);
+      const relativeVendorPath = path6.relative(vendorDir, vendorPath);
+      if (relativeVendorPath.startsWith("..") || path6.isAbsolute(relativeVendorPath) || !previewFs.existsSync(vendorPath) || !previewFs.statSync(vendorPath).isFile()) {
+        sendText(res, 404, "Not found");
+        return;
+      }
+      sendFile(res, vendorPath);
+    });
+    server.on("clientError", (_err, socket) => {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    });
+    await new Promise((resolve5, reject) => {
+      server.listen(port, host, () => resolve5());
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(`Port ${port} is already in use on ${host}.`));
+          return;
+        }
+        reject(err);
+      });
+    });
+    const boundAddress = server.address();
+    const boundPort = typeof boundAddress === "object" && boundAddress ? boundAddress.port : port;
+    const serverUrl = `http://${host}:${boundPort}`;
+    const fileUrl = previewFile ? `${serverUrl}?file=${encodeURIComponent(`${serverUrl}${previewFile.routePath}`)}` : serverUrl;
+    if (openBrowser) {
+      const open = await import("open").catch(() => null);
+      if (open) await open.default(fileUrl);
+    }
+    let stopped = false;
+    return {
+      url: serverUrl,
+      fileUrl,
+      host,
+      port: boundPort,
+      stop: () => new Promise((resolve5, reject) => {
+        if (stopped) {
+          resolve5();
+          return;
+        }
+        stopped = true;
+        server.close((err) => err ? reject(err) : resolve5());
+      })
+    };
+  }
+};
+
+// src/client.ts
+var SoMark = class {
+  parser;
+  usage;
+  pdf;
+  preview;
+  _http;
+  constructor(opts = {}) {
+    const cfg = resolveConfig(opts);
+    this._http = new HttpClient({
+      apiKey: cfg.apiKey,
+      baseUrl: cfg.baseUrl,
+      timeout: cfg.timeout,
+      maxRetries: cfg.maxRetries
+    });
+    this.parser = new DocumentParser(this._http);
+    this.usage = new UsageClient(this._http);
+    this.pdf = new PDFProcessor();
+    this.preview = new SoMarkDownPreview();
+  }
+  toString() {
+    const key = this._http.getApiKey();
+    const masked = key && key.length > 8 ? `${key.slice(0, 4)}...${key.slice(-4)}` : key ? "set" : "not set";
+    return `SoMark(apiKey=${masked})`;
+  }
+};
+
+// src/somarkdown.ts
+var path7 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs"), 1);
+var import_module = require("module");
+var import_url2 = require("url");
+var import_meta2 = {};
+var somarkdownFs = {
+  existsSync: fs7.existsSync
+};
+var _SoMarkDown = null;
+function unique(values) {
+  return [...new Set(values)];
+}
+function currentModuleDir2() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  return path7.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+}
+function resolveSoMarkDownExport(mod) {
+  const candidates = [
+    mod,
+    mod?.default,
+    mod?.SoMarkDown,
+    mod?.default?.SoMarkDown
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "function") {
+      const proto = candidate.prototype;
+      if (typeof proto?.render === "function") return candidate;
+    }
+  }
+  throw new Error("SoMarkDown UMD export is not a constructable renderer.");
+}
+function loadCommonJsFile(filePath) {
+  const code = fs7.readFileSync(filePath, "utf-8");
+  const module2 = { exports: {} };
+  const localRequire = (0, import_module.createRequire)(filePath);
+  const fn = new Function("module", "exports", "require", "__filename", "__dirname", code);
+  fn.call(globalThis, module2, module2.exports, localRequire, filePath, path7.dirname(filePath));
+  return module2.exports;
+}
+function loadSoMarkDown() {
+  if (_SoMarkDown) return _SoMarkDown;
+  const moduleDir = currentModuleDir2();
+  const candidates = unique([
+    path7.resolve(process.cwd(), "vendor/somarkdown-viewer/lib/somarkdown/somarkdown.umd.min.js"),
+    path7.resolve(moduleDir, "vendor/somarkdown-viewer/lib/somarkdown/somarkdown.umd.min.js"),
+    path7.resolve(moduleDir, "../vendor/somarkdown-viewer/lib/somarkdown/somarkdown.umd.min.js"),
+    path7.resolve(moduleDir, "../../vendor/somarkdown-viewer/lib/somarkdown/somarkdown.umd.min.js"),
+    path7.resolve(moduleDir, "../../../vendor/somarkdown-viewer/lib/somarkdown/somarkdown.umd.min.js")
+  ]);
+  for (const p of candidates) {
+    if (somarkdownFs.existsSync(p)) {
+      const mod = loadCommonJsFile(p);
+      _SoMarkDown = resolveSoMarkDownExport(mod);
+      return _SoMarkDown;
+    }
+  }
+  throw new Error(
+    "SoMarkDown UMD not found. Run: git submodule update --init --recursive && vendor/somarkdown-viewer/get_latest_smd.sh"
+  );
+}
+var SoMarkDown = class {
+  renderer;
+  constructor(...args) {
+    const Renderer = loadSoMarkDown();
+    this.renderer = new Renderer(...args);
+  }
+  render(markdown, ...args) {
+    return this.renderer.render(markdown, ...args);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AuthenticationError,
+  ConnectionError,
+  DocumentParser,
+  FileTooLargeError,
+  InsufficientBalanceError,
+  InvalidParamError,
+  PDFProcessor,
+  ParseFailedError,
+  ParseResponse,
+  ParseTimeoutError,
+  RateLimitError,
+  RequestTimeoutError,
+  SoMark,
+  SoMarkDown,
+  SoMarkDownPreview,
+  SoMarkError,
+  Task,
+  UnsupportedFileError,
+  Usage,
+  UsageClient
+});