extractia-sdk 1.3.0 → 1.4.0

package/dist/extractia-sdk.browser.js

@@ -392,15 +392,15 @@ var ExtractiaSDK = (() => {
     if (setImmediateSupported) {
       return setImmediate;
     }
-    return postMessageSupported ? ((token2, callbacks) => {
+    return postMessageSupported ? ((token, callbacks) => {
       _global.addEventListener("message", ({ source, data }) => {
-        if (source === _global && data === token2) {
+        if (source === _global && data === token) {
           callbacks.length && callbacks.shift()();
         }
       }, false);
       return (cb) => {
         callbacks.push(cb);
-        _global.postMessage(token2, "*");
+        _global.postMessage(token, "*");
       };
     })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
   })(
@@ -556,9 +556,9 @@ var ExtractiaSDK = (() => {
   }
   function renderKey(path, key, dots) {
     if (!path) return key;
-    return path.concat(key).map(function each(token2, i) {
-      token2 = removeBrackets(token2);
-      return !dots && i ? "[" + token2 + "]" : token2;
+    return path.concat(key).map(function each(token, i) {
+      token = removeBrackets(token);
+      return !dots && i ? "[" + token + "]" : token;
     }).join(dots ? "." : "");
   }
   function isFlatArray(arr) {
@@ -1601,7 +1601,7 @@ var ExtractiaSDK = (() => {
       if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) {
         headers.setContentType(void 0);
       } else if ((contentType = headers.getContentType()) !== false) {
-        const [type, ...tokens] = contentType ? contentType.split(";").map((token2) => token2.trim()).filter(Boolean) : [];
+        const [type, ...tokens] = contentType ? contentType.split(";").map((token) => token.trim()).filter(Boolean) : [];
         headers.setContentType([type || "multipart/form-data", ...tokens].join("; "));
       }
     }
@@ -1621,22 +1621,22 @@ var ExtractiaSDK = (() => {
   var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
   var xhr_default = isXHRAdapterSupported && function(config) {
     return new Promise(function dispatchXhrRequest(resolve, reject) {
-      const _config = resolveConfig_default(config);
-      let requestData = _config.data;
-      const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
-      let { responseType, onUploadProgress, onDownloadProgress } = _config;
+      const _config2 = resolveConfig_default(config);
+      let requestData = _config2.data;
+      const requestHeaders = AxiosHeaders_default.from(_config2.headers).normalize();
+      let { responseType, onUploadProgress, onDownloadProgress } = _config2;
       let onCanceled;
       let uploadThrottled, downloadThrottled;
       let flushUpload, flushDownload;
       function done() {
         flushUpload && flushUpload();
         flushDownload && flushDownload();
-        _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
-        _config.signal && _config.signal.removeEventListener("abort", onCanceled);
+        _config2.cancelToken && _config2.cancelToken.unsubscribe(onCanceled);
+        _config2.signal && _config2.signal.removeEventListener("abort", onCanceled);
       }
       let request = new XMLHttpRequest();
-      request.open(_config.method.toUpperCase(), _config.url, true);
-      request.timeout = _config.timeout;
+      request.open(_config2.method.toUpperCase(), _config2.url, true);
+      request.timeout = _config2.timeout;
       function onloadend() {
         if (!request) {
           return;
@@ -1687,10 +1687,10 @@ var ExtractiaSDK = (() => {
         request = null;
       };
       request.ontimeout = function handleTimeout() {
-        let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
-        const transitional2 = _config.transitional || transitional_default;
-        if (_config.timeoutErrorMessage) {
-          timeoutErrorMessage = _config.timeoutErrorMessage;
+        let timeoutErrorMessage = _config2.timeout ? "timeout of " + _config2.timeout + "ms exceeded" : "timeout exceeded";
+        const transitional2 = _config2.transitional || transitional_default;
+        if (_config2.timeoutErrorMessage) {
+          timeoutErrorMessage = _config2.timeoutErrorMessage;
         }
         reject(new AxiosError_default(
           timeoutErrorMessage,
@@ -1706,11 +1706,11 @@ var ExtractiaSDK = (() => {
           request.setRequestHeader(key, val);
         });
       }
-      if (!utils_default.isUndefined(_config.withCredentials)) {
-        request.withCredentials = !!_config.withCredentials;
+      if (!utils_default.isUndefined(_config2.withCredentials)) {
+        request.withCredentials = !!_config2.withCredentials;
       }
       if (responseType && responseType !== "json") {
-        request.responseType = _config.responseType;
+        request.responseType = _config2.responseType;
       }
       if (onDownloadProgress) {
         [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
@@ -1721,7 +1721,7 @@ var ExtractiaSDK = (() => {
         request.upload.addEventListener("progress", uploadThrottled);
         request.upload.addEventListener("loadend", flushUpload);
       }
-      if (_config.cancelToken || _config.signal) {
+      if (_config2.cancelToken || _config2.signal) {
         onCanceled = (cancel) => {
           if (!request) {
             return;
@@ -1730,12 +1730,12 @@ var ExtractiaSDK = (() => {
           request.abort();
           request = null;
         };
-        _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
-        if (_config.signal) {
-          _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
+        _config2.cancelToken && _config2.cancelToken.subscribe(onCanceled);
+        if (_config2.signal) {
+          _config2.signal.aborted ? onCanceled() : _config2.signal.addEventListener("abort", onCanceled);
         }
       }
-      const protocol = parseProtocol(_config.url);
+      const protocol = parseProtocol(_config2.url);
       if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
         reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
         return;
@@ -2385,32 +2385,32 @@ var ExtractiaSDK = (() => {
       this.promise = new Promise(function promiseExecutor(resolve) {
         resolvePromise = resolve;
       });
-      const token2 = this;
+      const token = this;
       this.promise.then((cancel) => {
-        if (!token2._listeners) return;
-        let i = token2._listeners.length;
+        if (!token._listeners) return;
+        let i = token._listeners.length;
         while (i-- > 0) {
-          token2._listeners[i](cancel);
+          token._listeners[i](cancel);
         }
-        token2._listeners = null;
+        token._listeners = null;
       });
       this.promise.then = (onfulfilled) => {
         let _resolve;
         const promise = new Promise((resolve) => {
-          token2.subscribe(resolve);
+          token.subscribe(resolve);
           _resolve = resolve;
         }).then(onfulfilled);
         promise.cancel = function reject() {
-          token2.unsubscribe(_resolve);
+          token.unsubscribe(_resolve);
         };
         return promise;
       };
       executor(function cancel(message, config, request) {
-        if (token2.reason) {
+        if (token.reason) {
           return;
         }
-        token2.reason = new CanceledError_default(message, config, request);
-        resolvePromise(token2.reason);
+        token.reason = new CanceledError_default(message, config, request);
+        resolvePromise(token.reason);
       });
     }
     /**
@@ -2462,11 +2462,11 @@ var ExtractiaSDK = (() => {
      */
     static source() {
       let cancel;
-      const token2 = new _CancelToken(function executor(c) {
+      const token = new _CancelToken(function executor(c) {
         cancel = c;
       });
       return {
-        token: token2,
+        token,
         cancel
       };
     }
@@ -2610,93 +2610,347 @@ var ExtractiaSDK = (() => {
   } = axios_default;
 
   // src/errors.js
+  var STATUS_MESSAGES = {
+    400: "The request contains invalid data. Please check your input.",
+    401: "Your API token is invalid or has expired. Please check your credentials.",
+    402: "Your current plan does not support this feature or your document quota is exhausted.",
+    403: "You do not have permission to perform this action.",
+    404: "The requested resource could not be found.",
+    409: "A resource with this identifier already exists.",
+    429: "Too many requests. Please wait a moment and try again.",
+    500: "The server encountered an unexpected error. Please try again in a moment.",
+    502: "The server received an unexpected response. Please try again.",
+    503: "The service is temporarily unavailable. Please try again in a few minutes.",
+    504: "The server timed out while processing the request. Please try again."
+  };
   var ExtractiaError = class extends Error {
-    /** @param {string} message @param {number} status */
-    constructor(message, status) {
+    /**
+     * @param {string} message    — Technical detail string.
+     * @param {number} [status]   — HTTP status code (0 = no response).
+     * @param {string} [userMessage] — Human-friendly sentence shown to end users.
+     * @param {string} [code]     — Machine-readable error code.
+     */
+    constructor(message, status = 0, userMessage = null, code = "SDK_ERROR") {
       super(message);
       this.name = "ExtractiaError";
       this.status = status;
+      this.userMessage = userMessage != null ? userMessage : message;
+      this.code = code;
+      this.requestId = null;
+    }
+    /** Returns true if automatically retrying the same request may succeed. */
+    isRetryable() {
+      return this.status === 429 || this.status >= 500;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        code: this.code,
+        status: this.status,
+        message: this.message,
+        userMessage: this.userMessage,
+        requestId: this.requestId
+      };
     }
   };
   var AuthError = class extends ExtractiaError {
-    constructor(message = "Unauthorized. Check your API token.") {
-      super(message, 401);
+    constructor(message = STATUS_MESSAGES[401]) {
+      super(message, 401, STATUS_MESSAGES[401], "AUTH_ERROR");
       this.name = "AuthError";
     }
   };
   var ForbiddenError = class extends ExtractiaError {
-    constructor(message = "Forbidden. Insufficient permissions.") {
-      super(message, 403);
+    constructor(message = STATUS_MESSAGES[403]) {
+      super(message, 403, STATUS_MESSAGES[403], "FORBIDDEN");
       this.name = "ForbiddenError";
     }
   };
   var TierError = class extends ExtractiaError {
-    constructor(message = "Tier limit reached. Upgrade your plan.", status = 402) {
-      super(message, status);
+    constructor(message = STATUS_MESSAGES[402], status = 402) {
+      super(message, status, STATUS_MESSAGES[402], "TIER_LIMIT");
       this.name = "TierError";
     }
   };
+  var QuotaError = class extends ExtractiaError {
+    constructor(message = "You have reached your document processing quota for this billing period. Please upgrade or wait for the next cycle.") {
+      super(message, 402, message, "QUOTA_EXCEEDED");
+      this.name = "QuotaError";
+    }
+  };
   var RateLimitError = class extends ExtractiaError {
-    constructor(message = "Too many requests. Please slow down.") {
-      super(message, 429);
+    /**
+     * @param {string} [message]
+     * @param {number|null} [retryAfter] — Seconds to wait before retrying (from Retry-After header).
+     */
+    constructor(message = STATUS_MESSAGES[429], retryAfter = null) {
+      super(message, 429, STATUS_MESSAGES[429], "RATE_LIMITED");
       this.name = "RateLimitError";
+      this.retryAfter = retryAfter;
+    }
+    isRetryable() {
+      return true;
     }
   };
   var NotFoundError = class extends ExtractiaError {
-    constructor(message = "Resource not found.") {
-      super(message, 404);
+    constructor(message = STATUS_MESSAGES[404]) {
+      super(message, 404, STATUS_MESSAGES[404], "NOT_FOUND");
       this.name = "NotFoundError";
     }
   };
+  var ValidationError = class extends ExtractiaError {
+    /**
+     * @param {string}                    [message]
+     * @param {Record<string,string>|null} [fields] — Field-level errors, if the server provides them.
+     */
+    constructor(message = STATUS_MESSAGES[400], fields = null) {
+      super(message, 400, STATUS_MESSAGES[400], "VALIDATION_ERROR");
+      this.name = "ValidationError";
+      this.fields = fields;
+    }
+  };
+  var ConflictError = class extends ExtractiaError {
+    constructor(message = STATUS_MESSAGES[409]) {
+      super(message, 409, STATUS_MESSAGES[409], "CONFLICT");
+      this.name = "ConflictError";
+    }
+  };
+  var ServerError = class extends ExtractiaError {
+    constructor(message = STATUS_MESSAGES[500], status = 500) {
+      var _a;
+      super(
+        message,
+        status,
+        (_a = STATUS_MESSAGES[status]) != null ? _a : STATUS_MESSAGES[500],
+        "SERVER_ERROR"
+      );
+      this.name = "ServerError";
+    }
+    isRetryable() {
+      return true;
+    }
+  };
+  var NetworkError = class extends ExtractiaError {
+    constructor(message = "Unable to reach the Extractia API. Please check your network connection and try again.") {
+      super(message, 0, message, "NETWORK_ERROR");
+      this.name = "NetworkError";
+    }
+    isRetryable() {
+      return true;
+    }
+  };
+  var TimeoutError = class extends ExtractiaError {
+    constructor(message = "The request timed out. The server may be under heavy load \u2014 please try again in a moment.") {
+      super(message, 0, message, "TIMEOUT");
+      this.name = "TimeoutError";
+    }
+    isRetryable() {
+      return true;
+    }
+  };
+  function extractServerDetail(data) {
+    var _a, _b, _c, _d, _e;
+    if (!data) return null;
+    if (typeof data === "string" && data.trim()) return data.trim();
+    if (typeof data === "object") {
+      const msg = (_c = (_b = (_a = data.message) != null ? _a : data.error) != null ? _b : data.detail) != null ? _c : data.title;
+      if (msg && typeof msg === "string") return msg.trim();
+      if (Array.isArray(data.errors) && data.errors.length > 0) {
+        const first = data.errors[0];
+        return typeof first === "string" ? first : (_e = (_d = first.message) != null ? _d : first.msg) != null ? _e : JSON.stringify(first);
+      }
+      if (Array.isArray(data.fieldErrors) && data.fieldErrors.length > 0) {
+        return data.fieldErrors.map((e) => {
+          var _a2, _b2;
+          return `${(_a2 = e.field) != null ? _a2 : "field"}: ${(_b2 = e.message) != null ? _b2 : e.defaultMessage}`;
+        }).join("; ");
+      }
+    }
+    return null;
+  }
   function mapAxiosError(err) {
-    var _a, _b;
-    const status = (_a = err.response) == null ? void 0 : _a.status;
-    const serverMessage = (_b = err.response) == null ? void 0 : _b.data;
-    const detail = typeof serverMessage === "string" ? serverMessage : void 0;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!err.response) {
+      if (err.code === "ECONNABORTED" || err.code === "ETIMEDOUT" || err.message && err.message.toLowerCase().includes("timeout")) {
+        return new TimeoutError();
+      }
+      return new NetworkError(err.message || void 0);
+    }
+    const status = err.response.status;
+    const detail = extractServerDetail(err.response.data);
+    const userMessage = (_a = STATUS_MESSAGES[status]) != null ? _a : status >= 500 ? STATUS_MESSAGES[500] : "Something went wrong. Please try again.";
+    let error;
     switch (status) {
+      case 400: {
+        const body = err.response.data;
+        const fields = (_b = body == null ? void 0 : body.fields) != null ? _b : Array.isArray(body == null ? void 0 : body.fieldErrors) ? Object.fromEntries(
+          body.fieldErrors.map((f) => {
+            var _a2;
+            return [f.field, (_a2 = f.message) != null ? _a2 : f.defaultMessage];
+          })
+        ) : null;
+        error = new ValidationError(detail != null ? detail : STATUS_MESSAGES[400], fields);
+        break;
+      }
       case 401:
-        return new AuthError(detail);
+        error = new AuthError(detail != null ? detail : void 0);
+        break;
       case 402:
-        return new TierError(detail);
+        if (detail && (detail.toLowerCase().includes("quota") || detail.toLowerCase().includes("document") || detail.toLowerCase().includes("limit reached"))) {
+          error = new QuotaError(detail);
+        } else {
+          error = new TierError(detail != null ? detail : void 0);
+        }
+        break;
       case 403:
-        return new ForbiddenError(detail);
+        error = new ForbiddenError(detail != null ? detail : void 0);
+        break;
       case 404:
-        return new NotFoundError(detail);
-      case 429:
-        return new RateLimitError(detail);
+        error = new NotFoundError(detail != null ? detail : void 0);
+        break;
+      case 409:
+        error = new ConflictError(detail != null ? detail : void 0);
+        break;
+      case 429: {
+        const retryAfterHeader = (_c = err.response.headers) == null ? void 0 : _c["retry-after"];
+        const retryAfter = retryAfterHeader != null ? parseInt(retryAfterHeader, 10) : null;
+        error = new RateLimitError(detail != null ? detail : void 0, isNaN(retryAfter) ? null : retryAfter);
+        break;
+      }
       default:
-        return new ExtractiaError(detail != null ? detail : err.message, status != null ? status : 0);
+        if (status >= 500) {
+          error = new ServerError((_d = detail != null ? detail : STATUS_MESSAGES[status]) != null ? _d : STATUS_MESSAGES[500], status);
+        } else {
+          error = new ExtractiaError(
+            detail != null ? detail : err.message,
+            status,
+            userMessage,
+            `HTTP_${status}`
+          );
+        }
     }
+    error.userMessage = userMessage;
+    const reqId = (_h = (_g = (_e = err.response.headers) == null ? void 0 : _e["x-request-id"]) != null ? _g : (_f = err.response.headers) == null ? void 0 : _f["x-correlation-id"]) != null ? _h : null;
+    if (reqId) error.requestId = reqId;
+    return error;
   }
 
   // src/apiClient.js
-  var token = null;
-  var DEFAULT_BASE_URL = "https://api.extractia.info/api/public";
-  var api = axios_default.create({
-    baseURL: DEFAULT_BASE_URL,
-    timeout: 6e4
-    // 60s — AI processing can take 10–30s
+  var _token = null;
+  var _config = {
+    baseURL: "https://api.extractia.info/api/public",
+    timeout: 6e4,
+    retries: 1,
+    retryDelay: 1e3,
+    debug: false,
+    defaultHeaders: {},
+    onBeforeRequest: null,
+    onAfterResponse: null,
+    onError: null
+  };
+  var _api = axios_default.create({
+    baseURL: _config.baseURL,
+    timeout: _config.timeout
   });
-  api.interceptors.request.use((config) => {
-    if (!token) {
-      throw new Error(
-        "API token is required. Call setToken(yourApiToken) before making requests."
+  _api.interceptors.request.use((config) => {
+    var _a, _b, _c, _d, _e;
+    if (!_token) {
+      const err = new ExtractiaError(
+        "API token not set. Call setToken(token) before making requests.",
+        0,
+        "API token not set. Call setToken(token) before making requests.",
+        "TOKEN_MISSING"
       );
+      return Promise.reject(err);
+    }
+    config.headers = (_a = config.headers) != null ? _a : {};
+    config.headers["Authorization"] = `Bearer ${_token}`;
+    Object.assign(config.headers, _config.defaultHeaders);
+    if (_config.debug) {
+      console.debug(
+        `[ExtractIA SDK] \u2192 ${((_b = config.method) != null ? _b : "GET").toUpperCase()} ${(_c = config.baseURL) != null ? _c : ""}${(_d = config.url) != null ? _d : ""}`,
+        (_e = config.params) != null ? _e : ""
+      );
+    }
+    if (typeof _config.onBeforeRequest === "function") {
+      const modified = _config.onBeforeRequest(config);
+      return modified != null ? modified : config;
     }
-    config.headers.Authorization = `Bearer ${token}`;
     return config;
   });
-  api.interceptors.response.use(
-    (response) => response,
-    (err) => Promise.reject(mapAxiosError(err))
+  _api.interceptors.response.use(
+    (response) => {
+      var _a, _b;
+      if (_config.debug) {
+        console.debug(
+          `[ExtractIA SDK] \u2190 ${response.status} ${(_b = (_a = response.config) == null ? void 0 : _a.url) != null ? _b : ""}`
+        );
+      }
+      if (typeof _config.onAfterResponse === "function") {
+        _config.onAfterResponse(response);
+      }
+      return response;
+    },
+    async (err) => {
+      var _a, _b;
+      if (err instanceof ExtractiaError) {
+        if (typeof _config.onError === "function") _config.onError(err);
+        return Promise.reject(err);
+      }
+      const mapped = mapAxiosError(err);
+      const cfg = err.config;
+      if (cfg && mapped.isRetryable() && ((_a = cfg._retryCount) != null ? _a : 0) < _config.retries) {
+        cfg._retryCount = ((_b = cfg._retryCount) != null ? _b : 0) + 1;
+        const delayMs = mapped.retryAfter != null ? mapped.retryAfter * 1e3 : _config.retryDelay * cfg._retryCount;
+        if (_config.debug) {
+          console.debug(
+            `[ExtractIA SDK] retrying (${cfg._retryCount}/${_config.retries}) in ${delayMs}ms\u2026`
+          );
+        }
+        await new Promise((r) => setTimeout(r, delayMs));
+        return _api(cfg);
+      }
+      if (typeof _config.onError === "function") _config.onError(mapped);
+      return Promise.reject(mapped);
+    }
   );
-  function setToken(newToken) {
-    token = newToken;
+  function setToken(token) {
+    if (!token || typeof token !== "string" || !token.trim()) {
+      throw new Error("setToken: token must be a non-empty string.");
+    }
+    _token = token.trim();
+  }
+  function getToken() {
+    return _token;
+  }
+  function hasToken() {
+    return Boolean(_token);
   }
-  function configure({ baseURL } = {}) {
-    if (baseURL) api.defaults.baseURL = baseURL;
+  function clearToken() {
+    _token = null;
+  }
+  function configure(opts = {}) {
+    if (opts.baseURL) {
+      _config.baseURL = opts.baseURL;
+      _api.defaults.baseURL = opts.baseURL;
+    }
+    if (opts.timeout != null) {
+      _config.timeout = opts.timeout;
+      _api.defaults.timeout = opts.timeout;
+    }
+    if (opts.retries != null) _config.retries = opts.retries;
+    if (opts.retryDelay != null) _config.retryDelay = opts.retryDelay;
+    if (opts.debug != null) _config.debug = Boolean(opts.debug);
+    if (opts.defaultHeaders) {
+      _config.defaultHeaders = __spreadValues(__spreadValues({}, _config.defaultHeaders), opts.defaultHeaders);
+    }
+    if (opts.onBeforeRequest) _config.onBeforeRequest = opts.onBeforeRequest;
+    if (opts.onAfterResponse) _config.onAfterResponse = opts.onAfterResponse;
+    if (opts.onError) _config.onError = opts.onError;
   }
-  var apiClient_default = api;
+  function getConfig() {
+    return __spreadValues({}, _config);
+  }
+  var apiClient_default = _api;
 
   // src/auth.js
   async function getMyProfile() {
@@ -2912,8 +3166,188 @@ var ExtractiaSDK = (() => {
     return res.data;
   }
 
+  // src/subusers.js
+  var subusers_exports = {};
+  __export(subusers_exports, {
+    createSubUser: () => createSubUser,
+    deleteSubUser: () => deleteSubUser,
+    getSubUsers: () => getSubUsers,
+    toggleSuspendSubUser: () => toggleSuspendSubUser,
+    updateSubUser: () => updateSubUser
+  });
+  async function getSubUsers() {
+    const res = await apiClient_default.get("/me/subusers");
+    return res.data;
+  }
+  async function createSubUser({
+    username,
+    password,
+    permissions,
+    allowedFormIds
+  }) {
+    const res = await apiClient_default.post("/me/subusers", __spreadValues({
+      username,
+      password,
+      permissions
+    }, allowedFormIds !== void 0 ? { allowedFormIds } : {}));
+    return res.data;
+  }
+  async function deleteSubUser(username) {
+    const res = await apiClient_default.delete(`/me/subusers/${encodeURIComponent(username)}`);
+    return res.data;
+  }
+  async function updateSubUser(username, updates = {}) {
+    const res = await apiClient_default.put(
+      `/me/subusers/${encodeURIComponent(username)}`,
+      updates
+    );
+    return res.data;
+  }
+  async function toggleSuspendSubUser(username) {
+    const res = await apiClient_default.put(
+      `/me/subusers/${encodeURIComponent(username)}/suspend`
+    );
+    return res.data;
+  }
+
+  // src/utils.js
+  var utils_exports2 = {};
+  __export(utils_exports2, {
+    delay: () => delay,
+    ensureBase64: () => ensureBase64,
+    fileToBase64: () => fileToBase64,
+    getMimeType: () => getMimeType,
+    isBase64: () => isBase64,
+    paginate: () => paginate,
+    paginateAll: () => paginateAll,
+    stripDataUrlPrefix: () => stripDataUrlPrefix,
+    withRetry: () => withRetry
+  });
+  function fileToBase64(file) {
+    if (typeof FileReader === "undefined") {
+      return Promise.reject(
+        new Error(
+          "fileToBase64: FileReader is not available in this environment. In Node.js, read the file manually and encode it with Buffer.from(data).toString('base64')."
+        )
+      );
+    }
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(
+        /** @type {string} */
+        reader.result
+      );
+      reader.onerror = () => {
+        var _a;
+        return reject(new Error(`fileToBase64: failed to read file "${(_a = file.name) != null ? _a : "unknown"}".`));
+      };
+      reader.readAsDataURL(file);
+    });
+  }
+  function stripDataUrlPrefix(base64OrDataUrl) {
+    if (typeof base64OrDataUrl !== "string") {
+      throw new TypeError(
+        "stripDataUrlPrefix: argument must be a string."
+      );
+    }
+    const idx = base64OrDataUrl.indexOf(";base64,");
+    return idx !== -1 ? base64OrDataUrl.slice(idx + 8) : base64OrDataUrl;
+  }
+  function getMimeType(dataUrl) {
+    if (typeof dataUrl !== "string") return null;
+    const match = dataUrl.match(/^data:([^;]+);base64,/);
+    return match ? match[1] : null;
+  }
+  function isBase64(str) {
+    if (typeof str !== "string" || !str.trim()) return false;
+    const raw = stripDataUrlPrefix(str);
+    return raw.length > 0 && raw.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(raw);
+  }
+  async function ensureBase64(fileOrBase64) {
+    if (typeof fileOrBase64 === "string") return fileOrBase64;
+    if (typeof File !== "undefined" && fileOrBase64 instanceof File || typeof Blob !== "undefined" && fileOrBase64 instanceof Blob) {
+      return fileToBase64(fileOrBase64);
+    }
+    throw new TypeError(
+      "ensureBase64: argument must be a File, Blob, or a base64 string."
+    );
+  }
+  function paginate(_0) {
+    return __asyncGenerator(this, arguments, function* (fn, { size = 50, startPage = 0, maxPages = 1e3 } = {}) {
+      var _a;
+      let page = startPage;
+      let pagesRead = 0;
+      while (pagesRead < maxPages) {
+        const result = yield new __await(fn({ page, size }));
+        const items = Array.isArray(result == null ? void 0 : result.content) ? result.content : [];
+        for (const item of items) yield item;
+        const totalPages = (_a = result == null ? void 0 : result.totalPages) != null ? _a : 1;
+        if (items.length === 0 || page + 1 >= totalPages) break;
+        page++;
+        pagesRead++;
+      }
+    });
+  }
+  async function paginateAll(fn, opts) {
+    const items = [];
+    try {
+      for (var iter = __forAwait(paginate(fn, opts)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const item = temp.value;
+        items.push(item);
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    return items;
+  }
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function withRetry(fn, { retries = 3, initialDelay = 500, shouldRetry } = {}) {
+    const isRetryable = shouldRetry != null ? shouldRetry : (err) => typeof err.isRetryable === "function" && err.isRetryable();
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastErr = err;
+        if (attempt < retries && isRetryable(err)) {
+          const wait = err.retryAfter != null ? err.retryAfter * 1e3 : initialDelay * 2 ** attempt;
+          await delay(wait);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastErr;
+  }
+
   // src/browser-entry.js
-  var extractia = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, auth_exports), templates_exports), documents_exports), analytics_exports), ocrTools_exports);
+  var extractia = __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, auth_exports), templates_exports), documents_exports), analytics_exports), ocrTools_exports), subusers_exports), utils_exports2), {
+    getToken,
+    hasToken,
+    clearToken,
+    getConfig,
+    ExtractiaError,
+    AuthError,
+    ForbiddenError,
+    TierError,
+    QuotaError,
+    RateLimitError,
+    NotFoundError,
+    ValidationError,
+    ConflictError,
+    ServerError,
+    NetworkError,
+    TimeoutError
+  });
   var browser_entry_default = extractia;
   return __toCommonJS(browser_entry_exports);
 })();