@bycrawl/nodejs-sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,990 @@
+// src/exceptions.ts
+var ByCrawlError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ByCrawlError";
+  }
+};
+var APIError = class extends ByCrawlError {
+  statusCode;
+  body;
+  constructor(message, options) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = options.statusCode;
+    this.body = options.body ?? null;
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(message = "Invalid or missing API key", body) {
+    super(message, { statusCode: 401, body });
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionError = class extends APIError {
+  constructor(message = "Insufficient scope", body) {
+    super(message, { statusCode: 403, body });
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message = "Resource not found", body) {
+    super(message, { statusCode: 404, body });
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends APIError {
+  retryAfter;
+  constructor(message = "Rate limit exceeded", options) {
+    super(message, { statusCode: 429, body: options?.body });
+    this.name = "RateLimitError";
+    this.retryAfter = options?.retryAfter ?? null;
+  }
+};
+var ServerError = class extends APIError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ServerError";
+  }
+};
+var TimeoutError = class extends ByCrawlError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var ConnectionError = class extends ByCrawlError {
+  constructor(message = "Network connection error") {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.bycrawl.com";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var SDK_VERSION = "0.1.1";
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function userAgent() {
+  return `bycrawl-node/${SDK_VERSION}`;
+}
+function makeHeaders(apiKey) {
+  return {
+    "x-api-key": apiKey,
+    "User-Agent": userAgent(),
+    Accept: "application/json"
+  };
+}
+function backoffDelay(attempt, base = 0.5, maxDelay = 8) {
+  const delay = Math.min(base * 2 ** attempt, maxDelay);
+  return Math.random() * delay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function raiseForStatus(status, body, headers) {
+  if (status >= 200 && status < 300) return;
+  const message = body?.error ?? `HTTP ${status}`;
+  if (status === 401) {
+    throw new AuthenticationError(message, body);
+  }
+  if (status === 403) {
+    throw new PermissionError(message, body);
+  }
+  if (status === 404) {
+    throw new NotFoundError(message, body);
+  }
+  if (status === 429) {
+    const retryAfter = headers.get("retry-after");
+    throw new RateLimitError(message, {
+      retryAfter: retryAfter ? parseFloat(retryAfter) : null,
+      body
+    });
+  }
+  if (status >= 500) {
+    throw new ServerError(message, { statusCode: status, body });
+  }
+  throw new APIError(message, { statusCode: status, body });
+}
+function headersToRecord(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+var Transport = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  defaultHeaders;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.defaultHeaders = makeHeaders(this.apiKey);
+  }
+  async request(method, path, options) {
+    const url = new URL(path, this.baseUrl);
+    if (options?.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value != null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const requestHeaders = {
+      ...this.defaultHeaders,
+      ...options?.headers
+    };
+    if (options?.json) {
+      requestHeaders["Content-Type"] = "application/json";
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(
+          () => controller.abort(),
+          this.timeout
+        );
+        let response;
+        try {
+          response = await fetch(url.toString(), {
+            method,
+            headers: requestHeaders,
+            body: options?.json ? JSON.stringify(options.json) : void 0,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId);
+        }
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          let delay = backoffDelay(attempt);
+          if (response.status === 429) {
+            const retryAfter = response.headers.get("retry-after");
+            if (retryAfter) {
+              delay = Math.max(delay, parseFloat(retryAfter) * 1e3);
+            }
+          }
+          await sleep(delay);
+          continue;
+        }
+        let body = null;
+        try {
+          body = await response.json();
+        } catch {
+          if (!response.ok) {
+            throw new APIError("Invalid JSON response", { statusCode: 502 });
+          }
+        }
+        raiseForStatus(response.status, body, response.headers);
+        return {
+          statusCode: response.status,
+          data: body ?? {},
+          headers: headersToRecord(response.headers)
+        };
+      } catch (error) {
+        if (error instanceof AuthenticationError || error instanceof PermissionError || error instanceof NotFoundError || error instanceof RateLimitError || error instanceof ServerError || error instanceof APIError) {
+          throw error;
+        }
+        if (error instanceof DOMException && error.name === "AbortError") {
+          lastError = error;
+          if (attempt < this.maxRetries) {
+            const delay = backoffDelay(attempt);
+            await sleep(delay);
+            continue;
+          }
+          throw new TimeoutError(String(error));
+        }
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+          lastError = error;
+          if (attempt < this.maxRetries) {
+            const delay = backoffDelay(attempt);
+            await sleep(delay);
+            continue;
+          }
+          throw new ConnectionError(String(error));
+        }
+        if (error instanceof ByCrawlError) {
+          throw error;
+        }
+        throw new ByCrawlError(`Unexpected error: ${error}`);
+      }
+    }
+    if (lastError) {
+      throw new ConnectionError(String(lastError));
+    }
+    throw new ConnectionError("Request failed after retries");
+  }
+};
+
+// src/resource.ts
+function parseRateLimit(headers) {
+  const limit = headers["x-ratelimit-limit"];
+  const remaining = headers["x-ratelimit-remaining"];
+  const reset = headers["x-ratelimit-reset"];
+  if (limit == null && remaining == null && reset == null) return null;
+  return {
+    limit: limit ? parseInt(limit, 10) : null,
+    remaining: remaining ? parseInt(remaining, 10) : null,
+    reset: reset ? parseFloat(reset) : null
+  };
+}
+function parseCredit(headers) {
+  const remaining = headers["x-credit-remaining"];
+  const used = headers["x-credit-used"];
+  if (remaining == null && used == null) return null;
+  return {
+    remaining: remaining ? parseInt(remaining, 10) : null,
+    used: used ? parseInt(used, 10) : null
+  };
+}
+function wrapResponse(wrapper, castTo) {
+  const data = wrapper.data;
+  let bodyData;
+  let success;
+  let error;
+  let queued;
+  if (typeof data === "object" && data !== null && "data" in data) {
+    bodyData = data.data;
+    success = data.success ?? true;
+    error = data.error ?? null;
+    queued = data.queued ?? false;
+  } else if (typeof data === "object" && data !== null && "error" in data) {
+    bodyData = null;
+    success = false;
+    error = data.error ?? null;
+    queued = false;
+  } else {
+    bodyData = data;
+    success = true;
+    error = null;
+    queued = false;
+  }
+  let parsed = bodyData;
+  if (castTo && bodyData != null) {
+    if (Array.isArray(bodyData)) {
+      parsed = bodyData.map(
+        (item) => castTo(item)
+      );
+    } else if (typeof bodyData === "object") {
+      parsed = castTo(bodyData);
+    }
+  }
+  return {
+    success,
+    data: parsed,
+    error,
+    queued,
+    rateLimit: parseRateLimit(wrapper.headers),
+    credit: parseCredit(wrapper.headers)
+  };
+}
+var APIResource = class {
+  _transport;
+  constructor(transport) {
+    this._transport = transport;
+  }
+  async _get(path, options) {
+    return this._request("GET", path, { params: options?.params, castTo: options?.castTo });
+  }
+  async _post(path, options) {
+    return this._request("POST", path, { body: options?.body, castTo: options?.castTo });
+  }
+  async _getList(path, options) {
+    const resp = await this._get(path, {
+      params: options.params
+    });
+    const raw = resp.data;
+    let items;
+    if (raw && typeof raw === "object" && !Array.isArray(raw) && options.itemsKey in raw) {
+      const arr = raw[options.itemsKey];
+      if (Array.isArray(arr)) {
+        items = options.castTo ? arr.map((item) => options.castTo(item)) : arr;
+      } else {
+        items = [];
+      }
+    } else if (Array.isArray(raw)) {
+      items = options.castTo ? raw.map((item) => options.castTo(item)) : raw;
+    } else {
+      items = [];
+    }
+    return {
+      ...resp,
+      data: items
+    };
+  }
+  async _request(method, path, options) {
+    const wrapper = await this._transport.request(method, path, {
+      params: options?.params,
+      json: options?.body
+    });
+    return wrapResponse(wrapper, options?.castTo);
+  }
+  async *_paginate(path, options) {
+    const itemsKey = options.itemsKey ?? "items";
+    const cursorKey = options.cursorKey ?? "cursor";
+    const hasMoreKey = options.hasMoreKey ?? "hasMore";
+    let params = { ...options.params };
+    while (true) {
+      const wrapper = await this._transport.request("GET", path, { params });
+      const responseData = wrapper.data;
+      const data = typeof responseData === "object" && responseData !== null && "data" in responseData ? responseData.data : responseData;
+      const items = data[itemsKey] ?? [];
+      for (const item of items) {
+        if (options.castTo) {
+          yield options.castTo(item);
+        } else {
+          yield item;
+        }
+      }
+      if (!data[hasMoreKey]) break;
+      const nextCursor = data[cursorKey] ?? data["next_cursor"];
+      if (!nextCursor) break;
+      params = { ...params, [cursorKey]: nextCursor };
+    }
+  }
+  async *_paginateByPage(path, options) {
+    const itemsKey = options.itemsKey ?? "items";
+    const pageKey = options.pageKey ?? "page";
+    let page = options.params[pageKey] ?? 1;
+    while (true) {
+      const params = { ...options.params, [pageKey]: page };
+      const wrapper = await this._transport.request("GET", path, { params });
+      const responseData = wrapper.data;
+      const data = typeof responseData === "object" && responseData !== null && "data" in responseData ? responseData.data : responseData;
+      const items = data[itemsKey] ?? [];
+      if (items.length === 0) break;
+      for (const item of items) {
+        if (options.castTo) {
+          yield options.castTo(item);
+        } else {
+          yield item;
+        }
+      }
+      const hasMore = data["hasMore"];
+      if (hasMore === false) break;
+      const limit = params["limit"] ?? 20;
+      if (items.length < limit) break;
+      page += 1;
+    }
+  }
+  async *_paginateByOffset(path, options) {
+    const itemsKey = options.itemsKey ?? "items";
+    const countKey = options.countKey ?? "count";
+    let offset = options.params["offset"] ?? 0;
+    const limit = options.params["limit"] ?? 20;
+    while (true) {
+      const params = { ...options.params, offset, limit };
+      const wrapper = await this._transport.request("GET", path, { params });
+      const responseData = wrapper.data;
+      const data = typeof responseData === "object" && responseData !== null && "data" in responseData ? responseData.data : responseData;
+      const items = data[itemsKey] ?? [];
+      if (items.length === 0) break;
+      for (const item of items) {
+        if (options.castTo) {
+          yield options.castTo(item);
+        } else {
+          yield item;
+        }
+      }
+      const total = data[countKey];
+      offset += items.length;
+      if (total != null && offset >= total) break;
+      if (items.length < limit) break;
+    }
+  }
+};
+
+// src/platforms/dcard.ts
+var Dcard = class extends APIResource {
+  async getForum(alias) {
+    return this._get(`/dcard/forums/${alias}`, {
+      castTo: (r) => r
+    });
+  }
+  async getForumPosts(alias, options) {
+    return this._get(`/dcard/forums/${alias}/posts`, {
+      params: { count: options?.count, popular: options?.popular }
+    });
+  }
+  async searchPosts(q, options) {
+    return this._get(`/dcard/posts/search`, {
+      params: { q, count: options?.count, offset: options?.offset }
+    });
+  }
+  async getPersona(username) {
+    return this._get(`/dcard/personas/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterSearchPosts(q, options) {
+    return this._paginateByOffset(`/dcard/posts/search`, {
+      params: { q, count: options?.count ?? 30 },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/facebook.ts
+var Facebook = class extends APIResource {
+  async getUser(username) {
+    return this._get(`/facebook/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUserPosts(username) {
+    return this._request("GET", `/facebook/users/${username}/posts`);
+  }
+  async getPost(options) {
+    return this._get(`/facebook/posts`, {
+      params: { url: options.url },
+      castTo: (r) => r
+    });
+  }
+  async getPostComments(options) {
+    return this._get(`/facebook/posts/comments`, {
+      params: { url: options.url, cursor: options.cursor }
+    });
+  }
+  async searchPosts(q, options) {
+    return this._get(`/facebook/posts/search`, {
+      params: { q, count: options?.count, cursor: options?.cursor }
+    });
+  }
+  async marketplaceBrowse(location, options) {
+    return this._get(`/facebook/marketplace/listings`, {
+      params: { location, category: options?.category }
+    });
+  }
+  async marketplaceSearch(q, options) {
+    return this._get(`/facebook/marketplace/search`, {
+      params: { q, location: options?.location }
+    });
+  }
+  async marketplaceItem(listingId) {
+    return this._get(`/facebook/marketplace/items/${listingId}`);
+  }
+  // -- Auto-pagination iterators --
+  iterPostComments(options) {
+    return this._paginate(`/facebook/posts/comments`, {
+      params: { url: options.url },
+      itemsKey: "comments"
+    });
+  }
+  iterSearchPosts(q, options) {
+    return this._paginate(`/facebook/posts/search`, {
+      params: { q, count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/gmaps.ts
+var GMaps = class extends APIResource {
+  async search(q, options) {
+    return this._get(`/gmaps/places/search`, {
+      params: { q, language: options?.language }
+    });
+  }
+  async getPlace(query, options) {
+    return this._get(`/gmaps/places`, {
+      params: { query, language: options?.language },
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/instagram.ts
+var Instagram = class extends APIResource {
+  async getUser(username) {
+    return this._get(`/instagram/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async searchTags(q) {
+    return this._get(`/instagram/tags/search`, { params: { q } });
+  }
+  async getPost(shortcode) {
+    return this._get(`/instagram/posts/${shortcode}`);
+  }
+  async getPostComments(shortcode, options) {
+    return this._get(`/instagram/posts/${shortcode}/comments`, {
+      params: { cursor: options?.cursor }
+    });
+  }
+  async getUserPosts(username, options) {
+    return this._get(`/instagram/users/${username}/posts`, {
+      params: { cursor: options?.cursor }
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterUserPosts(username) {
+    return this._paginate(`/instagram/users/${username}/posts`, {
+      params: {},
+      itemsKey: "posts"
+    });
+  }
+  iterPostComments(shortcode) {
+    return this._paginate(`/instagram/posts/${shortcode}/comments`, {
+      params: {},
+      itemsKey: "comments"
+    });
+  }
+};
+
+// src/platforms/job104.ts
+var Job104 = class extends APIResource {
+  async searchJobs(options) {
+    return this._getList(`/job104/jobs/search`, {
+      params: {
+        q: options?.q,
+        welfare: options?.welfare,
+        area: options?.area,
+        page: options?.page,
+        count: options?.count
+      },
+      itemsKey: "jobs",
+      castTo: (r) => r
+    });
+  }
+  async getCompany(companyId) {
+    return this._get(`/job104/companies/${companyId}`, {
+      castTo: (r) => r
+    });
+  }
+  async getJob(jobId) {
+    return this._get(`/job104/jobs/${jobId}`, {
+      castTo: (r) => r
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterSearchJobs(options) {
+    return this._paginateByPage(`/job104/jobs/search`, {
+      params: {
+        q: options?.q,
+        welfare: options?.welfare,
+        area: options?.area,
+        count: options?.count ?? 20
+      },
+      itemsKey: "jobs",
+      pageKey: "page",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/linkedin.ts
+var LinkedIn = class extends APIResource {
+  async getCompany(companyId) {
+    return this._get(`/linkedin/companies/${companyId}`, {
+      castTo: (r) => r
+    });
+  }
+  async getCompanyJobs(companyId, options) {
+    return this._get(`/linkedin/companies/${companyId}/jobs`, {
+      params: { count: options?.count, offset: options?.offset }
+    });
+  }
+  async searchJobs(query, options) {
+    return this._getList(`/linkedin/jobs/search`, {
+      params: {
+        q: query,
+        location: options?.location,
+        count: options?.count,
+        offset: options?.offset
+      },
+      itemsKey: "jobs",
+      castTo: (r) => r
+    });
+  }
+  async getJob(jobId) {
+    return this._get(`/linkedin/jobs/${jobId}`, {
+      castTo: (r) => r
+    });
+  }
+  async getPost(postId) {
+    return this._get(`/linkedin/posts/${postId}`, {
+      castTo: (r) => r
+    });
+  }
+  async searchUsers(query, options) {
+    return this._getList(`/linkedin/users/search`, {
+      params: { q: query, count: options?.count, offset: options?.offset },
+      itemsKey: "users",
+      castTo: (r) => r
+    });
+  }
+  async getUser(username) {
+    return this._get(`/linkedin/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterCompanyJobs(companyId, options) {
+    const count = options?.count ?? 10;
+    return this._paginateByOffset(`/linkedin/companies/${companyId}/jobs`, {
+      params: { count, limit: count },
+      itemsKey: "jobs",
+      castTo: (r) => r
+    });
+  }
+  iterSearchJobs(query, options) {
+    const count = options?.count ?? 10;
+    return this._paginateByOffset(`/linkedin/jobs/search`, {
+      params: { q: query, location: options?.location, count, limit: count },
+      itemsKey: "jobs",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/reddit.ts
+var Reddit = class extends APIResource {
+  async getSubreddit(name) {
+    return this._get(`/reddit/subreddits/${name}`, {
+      castTo: (r) => r
+    });
+  }
+  async getSubredditPosts(name, options) {
+    return this._getList(`/reddit/subreddits/${name}/posts`, {
+      params: { sort: options?.sort, t: options?.t, count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+  async getPost(postId) {
+    return this._get(`/reddit/posts/${postId}`, {
+      castTo: (r) => r
+    });
+  }
+  async searchPosts(q, options) {
+    return this._getList(`/reddit/posts/search`, {
+      params: { q, sort: options?.sort, count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+  async getUser(username) {
+    return this._get(`/reddit/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUserPosts(username, options) {
+    return this._get(`/reddit/users/${username}/posts`, {
+      params: {
+        sort: options?.sort,
+        t: options?.t,
+        count: options?.count,
+        after: options?.after
+      }
+    });
+  }
+};
+
+// src/platforms/threads.ts
+var Threads = class extends APIResource {
+  async getPost(postId, options) {
+    return this._get(`/threads/posts/${postId}`, {
+      params: { mode: options?.mode },
+      castTo: (r) => r
+    });
+  }
+  async getPosts(ids, options) {
+    const resp = await this._request("GET", `/threads/posts`, {
+      params: { ids: ids.join(","), mode: options?.mode }
+    });
+    return resp;
+  }
+  async searchPosts(q, options) {
+    return this._getList(`/threads/posts/search`, {
+      params: { q, count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+  async getUser(username) {
+    return this._get(`/threads/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUserPosts(userId, options) {
+    return this._get(`/threads/users/${userId}/posts`, {
+      params: { cursor: options?.cursor, count: options?.count }
+    });
+  }
+  async getUserReplies(userId, options) {
+    return this._get(`/threads/users/${userId}/replies`, {
+      params: { cursor: options?.cursor, count: options?.count }
+    });
+  }
+  async searchUsers(q, options) {
+    return this._getList(`/threads/users/search`, {
+      params: { q, count: options?.count },
+      itemsKey: "users",
+      castTo: (r) => r
+    });
+  }
+  async getPublicFeed(options) {
+    return this._get(`/threads/feed/public`, {
+      params: { cursor: options?.cursor, count: options?.count }
+    });
+  }
+  // -- Bulk operations --
+  async bulkSubmit(ids, options) {
+    return this._post(`/threads/bulk`, {
+      body: { ids, type: options?.type ?? "content" },
+      castTo: (r) => r
+    });
+  }
+  async bulkStatus(jobId) {
+    return this._get(`/threads/bulk/${jobId}`, {
+      castTo: (r) => r
+    });
+  }
+  async bulkResults(jobId) {
+    return this._request("GET", `/threads/bulk/${jobId}/results`);
+  }
+  async bulkSubmitAndWait(ids, options) {
+    const pollInterval = options?.pollInterval ?? 2e3;
+    const timeout = options?.timeout ?? 3e5;
+    const submitResp = await this.bulkSubmit(ids);
+    const jobId = submitResp.data.jobId;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const statusResp = await this.bulkStatus(jobId);
+      const status = statusResp.data.status;
+      if (status === "completed") {
+        return this.bulkResults(jobId);
+      }
+      if (status === "failed") {
+        throw new ByCrawlError(`Bulk job ${jobId} failed`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new TimeoutError(`Bulk job ${jobId} timed out after ${timeout}ms`);
+  }
+  // -- Auto-pagination iterators --
+  iterUserPosts(userId, options) {
+    return this._paginate(`/threads/users/${userId}/posts`, {
+      params: { count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+  iterUserReplies(userId, options) {
+    return this._paginate(`/threads/users/${userId}/replies`, {
+      params: { count: options?.count },
+      itemsKey: "replies",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/tiktok.ts
+var TikTok = class extends APIResource {
+  async getVideo(videoId) {
+    return this._get(`/tiktok/videos/${videoId}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUser(username) {
+    return this._get(`/tiktok/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUserVideos(username, options) {
+    return this._request("GET", `/tiktok/users/${username}/videos`, {
+      params: { count: options?.count }
+    });
+  }
+  async getVideoComments(videoId, options) {
+    return this._get(`/tiktok/videos/${videoId}/comments`, {
+      params: { cursor: options?.cursor }
+    });
+  }
+  async getCategories(options) {
+    return this._get(`/tiktok/categories`, {
+      params: { category: options?.category, count: options?.count }
+    });
+  }
+  async search(keyword, options) {
+    return this._get(`/tiktok/videos/search`, {
+      params: { q: keyword, count: options?.count }
+    });
+  }
+  async getVideoSubtitles(videoId) {
+    return this._get(`/tiktok/videos/${videoId}/subtitles`);
+  }
+  // -- Auto-pagination iterators --
+  iterVideoComments(videoId) {
+    return this._paginate(`/tiktok/videos/${videoId}/comments`, {
+      params: {},
+      itemsKey: "comments",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/webfetch.ts
+var WebFetch = class extends APIResource {
+  async fetch(url, options) {
+    return this._get(`/web/fetch`, {
+      params: { url, format: options?.format }
+    });
+  }
+};
+
+// src/platforms/x.ts
+var X = class extends APIResource {
+  async getUser(username) {
+    return this._get(`/x/users/${username}`, {
+      castTo: (r) => r
+    });
+  }
+  async getUserPosts(username, options) {
+    return this._get(`/x/users/${username}/posts`, {
+      params: { count: options?.count, cursor: options?.cursor }
+    });
+  }
+  async getPost(postId) {
+    return this._get(`/x/posts/${postId}`, {
+      castTo: (r) => r
+    });
+  }
+  async searchPosts(q, options) {
+    return this._getList(`/x/posts/search`, {
+      params: {
+        q,
+        count: options?.count,
+        cursor: options?.cursor,
+        product: options?.product
+      },
+      itemsKey: "tweets",
+      castTo: (r) => r
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterUserPosts(username, options) {
+    return this._paginate(`/x/users/${username}/posts`, {
+      params: { count: options?.count },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+  iterSearchPosts(q, options) {
+    return this._paginate(`/x/posts/search`, {
+      params: { q, count: options?.count, product: options?.product },
+      itemsKey: "posts",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/platforms/youtube.ts
+var YouTube = class extends APIResource {
+  async getVideo(videoId) {
+    return this._get(`/youtube/videos/${videoId}`, {
+      castTo: (r) => r
+    });
+  }
+  async getChannel(channelId) {
+    return this._get(`/youtube/channels/${channelId}`, {
+      castTo: (r) => r
+    });
+  }
+  async search(q, options) {
+    return this._get(`/youtube/videos/search`, {
+      params: { q, count: options?.count }
+    });
+  }
+  async getVideoComments(videoId, options) {
+    return this._get(`/youtube/videos/${videoId}/comments`, {
+      params: { count: options?.count }
+    });
+  }
+  async getVideoTranscription(videoId, options) {
+    return this._get(`/youtube/videos/${videoId}/transcription`, {
+      params: { language: options?.language }
+    });
+  }
+  // -- Auto-pagination iterators --
+  iterSearch(q, options) {
+    return this._paginate(`/youtube/videos/search`, {
+      params: { q, count: options?.count },
+      itemsKey: "videos",
+      castTo: (r) => r
+    });
+  }
+  iterVideoComments(videoId, options) {
+    return this._paginate(`/youtube/videos/${videoId}/comments`, {
+      params: { count: options?.count },
+      itemsKey: "comments",
+      castTo: (r) => r
+    });
+  }
+};
+
+// src/client.ts
+var ByCrawl = class {
+  threads;
+  facebook;
+  x;
+  instagram;
+  reddit;
+  linkedin;
+  tiktok;
+  youtube;
+  dcard;
+  gmaps;
+  job104;
+  web;
+  _transport;
+  constructor(options) {
+    const apiKey = options?.apiKey ?? process.env["BYCRAWL_API_KEY"] ?? "";
+    if (!apiKey) {
+      throw new Error(
+        "apiKey must be provided or set via the BYCRAWL_API_KEY environment variable"
+      );
+    }
+    this._transport = new Transport({
+      apiKey,
+      baseUrl: options?.baseUrl ?? DEFAULT_BASE_URL,
+      timeout: options?.timeout ?? DEFAULT_TIMEOUT,
+      maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES
+    });
+    this.threads = new Threads(this._transport);
+    this.facebook = new Facebook(this._transport);
+    this.x = new X(this._transport);
+    this.instagram = new Instagram(this._transport);
+    this.reddit = new Reddit(this._transport);
+    this.linkedin = new LinkedIn(this._transport);
+    this.tiktok = new TikTok(this._transport);
+    this.youtube = new YouTube(this._transport);
+    this.dcard = new Dcard(this._transport);
+    this.gmaps = new GMaps(this._transport);
+    this.job104 = new Job104(this._transport);
+    this.web = new WebFetch(this._transport);
+  }
+};
+export {
+  APIError,
+  AuthenticationError,
+  ByCrawl,
+  ByCrawlError,
+  ConnectionError,
+  NotFoundError,
+  PermissionError,
+  RateLimitError,
+  SDK_VERSION,
+  ServerError,
+  TimeoutError
+};
+//# sourceMappingURL=index.js.map