{"version":3,"sources":["../src/index.ts","../src/version.ts","../src/core/errors.ts","../src/core/http.ts","../src/modules/checker/index.ts","../src/modules/datacenter/index.ts","../src/modules/dedicated/index.ts","../src/core/pagination.ts","../src/modules/free/client.ts","../src/modules/ip/client.ts","../src/modules/mobile/index.ts","../src/modules/residential/index.ts","../src/modules/serp/index.ts","../src/client.ts"],"sourcesContent":["// Public entrypoint. Anything not re-exported here is internal.\n\nexport { ProxyScrape } from './client';\n\n// Core types callers compose against.\nexport type { ClientOptions, Protocol, Anonymity } from './core/types';\n\n// Error classes — exported so callers can `instanceof` them.\nexport {\n ProxyScrapeError,\n AuthError,\n BadRequestError,\n RateLimitError,\n NetworkError,\n} from './core/errors';\n\n// Free module — types and the standalone client class for callers who want\n// to skip the umbrella ProxyScrape class. Module classes are useful for DI\n// in tests and for tree-shaking when only one module is needed.\nexport { FreeProxyListClient } from './modules/free';\nexport type {\n FreeProxy,\n FreeProxyFilters,\n FreeProxyListParams,\n FreeProxyListResult,\n FreeProxyRaw,\n FreeProxyApiResponse,\n} from './modules/free';\n\n// Public-IP lookup — top-level convenience exposed via `client.getPublicIp()`.\nexport { PublicIpClient } from './modules/ip';\nexport type { GetPublicIpOptions, PublicIpInfo, PublicIpService } from './modules/ip';\n\n// Other module clients are not yet implemented but are exported as types\n// so consumers can already reference them in their own type signatures.\nexport { CheckerClient } from './modules/checker';\nexport { ResidentialClient } from './modules/residential';\nexport { DatacenterClient } from './modules/datacenter';\nexport { DedicatedClient } from './modules/dedicated';\nexport { MobileClient } from './modules/mobile';\nexport { SerpClient } from './modules/serp';\n\nexport { SDK_VERSION } from './version';\n","/**\n * Single source of truth for the SDK version, embedded into the User-Agent\n * header and any public version surface.\n *\n * Kept in sync with package.json by the release workflow — the changeset\n * action edits both files in the same PR. If you update package.json by\n * hand, update this constant too.\n */\nexport const SDK_VERSION = '1.0.3';\n","/**\n * Base class for every error the SDK throws.\n *\n * Catch this if you want a single instanceof check that covers any failure\n * from the client; subclasses below let you discriminate the cause when you\n * need to.\n */\nexport class ProxyScrapeError extends Error {\n override name = 'ProxyScrapeError';\n // Use the native Error.cause field rather than our own parallel property,\n // which would (correctly) trip TS's noImplicitOverride. We just pipe the\n // caller's cause into the standard ErrorOptions and stay structural.\n constructor(message: string, cause?: unknown) {\n super(message, cause === undefined ? undefined : { cause });\n }\n}\n\n/**\n * Thrown when the API returns 401/403. The message echoes the upstream body\n * when available so callers don't have to inspect `response` to debug.\n */\nexport class AuthError extends ProxyScrapeError {\n override name = 'AuthError';\n constructor(\n message: string,\n public readonly status: number,\n cause?: unknown,\n ) {\n super(message, cause);\n }\n}\n\n/**\n * Thrown after retries are exhausted on a 429 or after the API's documented\n * rate-limit codes (433 hourly / 434 daily / 432 per-second) come back. The\n * `retryAfterSeconds` is read from the Retry-After header when present.\n */\nexport class RateLimitError extends ProxyScrapeError {\n override name = 'RateLimitError';\n constructor(\n message: string,\n public readonly status: number,\n public readonly retryAfterSeconds: number | null,\n cause?: unknown,\n ) {\n super(message, cause);\n }\n}\n\n/**\n * Thrown for non-recoverable 4xx responses (validation errors, malformed\n * params, etc.). 5xx is treated separately as transient and retried by the\n * HTTP wrapper.\n */\nexport class BadRequestError extends ProxyScrapeError {\n override name = 'BadRequestError';\n constructor(\n message: string,\n public readonly status: number,\n cause?: unknown,\n ) {\n super(message, cause);\n }\n}\n\n/**\n * Wraps fetch-level failures (DNS, TCP, TLS, AbortError, etc.) so callers\n * can distinguish \"the API said no\" from \"we couldn't reach the API\".\n */\nexport class NetworkError extends ProxyScrapeError {\n override name = 'NetworkError';\n}\n","import { SDK_VERSION } from '../version';\nimport { AuthError, BadRequestError, NetworkError, RateLimitError } from './errors';\nimport type { ClientOptions } from './types';\n\n/**\n * Internal HTTP client used by every module. Wraps fetch with:\n *\n * - timeout via AbortController (per-call or from ClientOptions)\n * - retry with exponential backoff on 5xx / 429 / network errors\n * - typed error mapping (AuthError / RateLimitError / BadRequestError /\n * NetworkError / ProxyScrapeError)\n * - User-Agent + optional Authorization injection\n *\n * Module code never touches fetch directly — that keeps timeout / retry /\n * error behavior consistent everywhere and gives us one place to add\n * telemetry, logging, or alternate transports later.\n */\n\nconst DEFAULT_BASE_URL = 'https://api.proxyscrape.com/v4';\nconst DEFAULT_TIMEOUT_MS = 30_000;\nconst DEFAULT_MAX_RETRIES = 3;\n\nexport interface RequestOptions {\n /** Override the request-level timeout. Falls back to ClientOptions.timeoutMs. */\n timeoutMs?: number;\n /** AbortSignal that lets the caller cancel mid-flight. */\n signal?: AbortSignal;\n /** Extra headers merged into the default set. */\n headers?: Record;\n /**\n * Skip injection of the `api-token` header.\n *\n * Used when the request targets a third-party endpoint (e.g. ipinfo.io\n * for `getPublicIp`) where we must NOT leak the caller's API key.\n * Defaults to false; module code should leave it false for any call\n * hitting api.proxyscrape.com.\n */\n skipAuth?: boolean;\n}\n\nexport interface RetryableRequest {\n url: string | URL;\n init?: RequestInit;\n /** If false, never retry — used for endpoints where idempotency is unclear. */\n retry?: boolean;\n}\n\nexport class HttpClient {\n private readonly baseUrl: string;\n private readonly apiKey: string | undefined;\n private readonly fetchImpl: typeof fetch;\n private readonly timeoutMs: number;\n private readonly maxRetries: number;\n private readonly userAgent: string;\n\n constructor(opts: ClientOptions = {}) {\n this.baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\\/+$/, '');\n this.apiKey = opts.apiKey;\n this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n this.maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;\n this.userAgent = opts.userAgent\n ? `proxyscrape-sdk/${SDK_VERSION} ${opts.userAgent}`\n : `proxyscrape-sdk/${SDK_VERSION}`;\n }\n\n /** Resolve a path against the base URL. Pass through absolute URLs as-is. */\n url(path: string, query?: Record): URL {\n const base = /^https?:/.test(path)\n ? path\n : `${this.baseUrl}${path.startsWith('/') ? '' : '/'}${path}`;\n const u = new URL(base);\n if (query) {\n for (const [k, v] of Object.entries(query)) {\n if (v === undefined || v === null) continue;\n u.searchParams.set(k, String(v));\n }\n }\n return u;\n }\n\n /** Issue a request, parse JSON, and return the decoded body. */\n async getJson(\n path: string,\n query?: Record,\n opts: RequestOptions = {},\n ): Promise {\n const res = await this.request(\n {\n url: this.url(path, query),\n init: { method: 'GET' },\n },\n opts,\n );\n return (await res.json()) as T;\n }\n\n /** Issue a request and return the raw text body — used for the text/csv export endpoints. */\n async getText(\n path: string,\n query?: Record,\n opts: RequestOptions = {},\n ): Promise {\n const res = await this.request(\n {\n url: this.url(path, query),\n init: { method: 'GET' },\n },\n opts,\n );\n return await res.text();\n }\n\n /**\n * Low-level request: handles timeout, retries, headers, error mapping.\n * Most module code should call getJson / getText instead.\n */\n async request(req: RetryableRequest, opts: RequestOptions = {}): Promise {\n const attempts = (req.retry ?? true) ? this.maxRetries + 1 : 1;\n let lastErr: unknown;\n\n for (let attempt = 0; attempt < attempts; attempt++) {\n const ctrl = new AbortController();\n const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs ?? this.timeoutMs);\n\n // Chain the caller's AbortSignal so external cancellation works too.\n if (opts.signal) {\n if (opts.signal.aborted) ctrl.abort(opts.signal.reason);\n else\n opts.signal.addEventListener('abort', () => ctrl.abort(opts.signal?.reason), {\n once: true,\n });\n }\n\n const headers: Record = {\n Accept: 'application/json',\n 'User-Agent': this.userAgent,\n // Skip auth header for explicit opt-outs (third-party endpoints).\n // Without this guard, a `getPublicIp` call against ipinfo.io would\n // forward the user's ProxyScrape API key to a vendor we don't own.\n ...(this.apiKey && !opts.skipAuth ? { 'api-token': this.apiKey } : {}),\n ...(req.init?.headers as Record | undefined),\n ...opts.headers,\n };\n\n try {\n const res = await this.fetchImpl(req.url, {\n ...req.init,\n headers,\n signal: ctrl.signal,\n });\n clearTimeout(timer);\n\n if (res.ok) return res;\n\n // Map status codes to typed errors.\n const status = res.status;\n const bodyText = await safeText(res);\n\n if (status === 401 || status === 403) {\n throw new AuthError(`Authentication failed (${status}): ${bodyText}`, status);\n }\n\n // ProxyScrape uses non-standard 432/433/434 for rate-limit windows;\n // 429 is the standard one. Treat all four the same.\n if (status === 429 || status === 432 || status === 433 || status === 434) {\n const retryAfter = parseRetryAfter(res.headers.get('Retry-After'));\n if (attempt < attempts - 1) {\n lastErr = new RateLimitError(\n `Rate limited (${status}): ${bodyText}`,\n status,\n retryAfter,\n );\n await sleep(backoffMs(attempt, retryAfter));\n continue;\n }\n throw new RateLimitError(`Rate limited (${status}): ${bodyText}`, status, retryAfter);\n }\n\n if (status >= 500 && status < 600) {\n if (attempt < attempts - 1) {\n lastErr = new ProxyScrapeError(`Server error (${status}): ${bodyText}`);\n await sleep(backoffMs(attempt, null));\n continue;\n }\n throw new ProxyScrapeError(`Server error (${status}): ${bodyText}`);\n }\n\n // Any other 4xx — non-recoverable.\n throw new BadRequestError(`Bad request (${status}): ${bodyText}`, status);\n } catch (err) {\n clearTimeout(timer);\n\n // Re-throw SDK errors that we've already mapped.\n if (err instanceof AuthError || err instanceof BadRequestError) throw err;\n if (err instanceof RateLimitError && attempt >= attempts - 1) throw err;\n\n // AbortError / TypeError / fetch-network failures.\n const isAbort =\n err instanceof Error && (err.name === 'AbortError' || err.message.includes('aborted'));\n const isCallerAbort = opts.signal?.aborted === true;\n if (isAbort && isCallerAbort) throw err; // Honor caller cancellation immediately.\n\n if (attempt < attempts - 1) {\n lastErr = err;\n await sleep(backoffMs(attempt, null));\n continue;\n }\n throw new NetworkError(err instanceof Error ? err.message : 'fetch failed', err);\n }\n }\n\n // Should be unreachable, but TS can't see that without exhaustive flow analysis.\n throw lastErr instanceof Error ? lastErr : new ProxyScrapeError('exhausted retries');\n }\n}\n\n// ProxyScrapeError is re-imported here only for the throw above where we\n// downgrade a typed error to the base class. Importing it at the top avoids\n// circular module concerns.\nimport { ProxyScrapeError } from './errors';\n\nfunction backoffMs(attempt: number, retryAfterSeconds: number | null): number {\n if (retryAfterSeconds != null) return Math.max(0, retryAfterSeconds * 1000);\n // Exponential backoff with jitter: 250, 500, 1000, 2000, 4000 ms ± 30%.\n const base = 250 * 2 ** attempt;\n const jitter = (Math.random() * 0.6 - 0.3) * base;\n return Math.max(0, Math.round(base + jitter));\n}\n\nfunction parseRetryAfter(header: string | null): number | null {\n if (!header) return null;\n const n = Number(header);\n if (Number.isFinite(n)) return n;\n // HTTP-date form. Convert delta from now.\n const t = Date.parse(header);\n if (Number.isFinite(t)) return Math.max(0, Math.round((t - Date.now()) / 1000));\n return null;\n}\n\nfunction sleep(ms: number): Promise {\n return new Promise((r) => setTimeout(r, ms));\n}\n\nasync function safeText(res: Response): Promise {\n try {\n return await res.text();\n } catch {\n return '';\n }\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the proxy-checker module. Real implementation lands once the\n * v4 /proxy-check endpoints are stable. Public methods listed here are\n * intentional commitments: they will be the surface in v1.x, only their\n * bodies fill in.\n *\n * Until then every call throws so accidental usage is loud, not silent.\n */\nexport class CheckerClient {\n constructor(protected readonly http: HttpClient) {}\n\n /** Submit a batch of proxies to be checked against the public judge servers. */\n test(_params: { proxies: string[] }): Promise {\n return Promise.reject(notImplemented('checker.test'));\n }\n\n /** Quick single-proxy liveness ping. */\n ping(_params: { proxy: string }): Promise {\n return Promise.reject(notImplemented('checker.ping'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The checker module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the datacenter proxies module. Real implementation lands once\n * the v4 endpoints are stable. Public methods are an intentional commitment\n * to the v1.x surface — only the bodies fill in.\n *\n * The HttpClient reference is held even though the stub methods don't use\n * it yet — that way the constructor isn't \"useless\" (it really will be\n * needed) and the eventual implementation slots in without touching the\n * constructor signature or callers.\n */\nexport class DatacenterClient {\n constructor(protected readonly http: HttpClient) {}\n\n acquire(_params?: Record): Promise {\n return Promise.reject(notImplemented('datacenter.acquire'));\n }\n\n release(_params?: Record): Promise {\n return Promise.reject(notImplemented('datacenter.release'));\n }\n\n list(_params?: Record): Promise {\n return Promise.reject(notImplemented('datacenter.list'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The datacenter module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the dedicated proxies module. Real implementation lands once\n * the v4 endpoints are stable. Public methods are an intentional commitment\n * to the v1.x surface — only the bodies fill in.\n *\n * The HttpClient reference is held even though the stub methods don't use\n * it yet — that way the constructor isn't \"useless\" (it really will be\n * needed) and the eventual implementation slots in without touching the\n * constructor signature or callers.\n */\nexport class DedicatedClient {\n constructor(protected readonly http: HttpClient) {}\n\n acquire(_params?: Record): Promise {\n return Promise.reject(notImplemented('dedicated.acquire'));\n }\n\n release(_params?: Record): Promise {\n return Promise.reject(notImplemented('dedicated.release'));\n }\n\n list(_params?: Record): Promise {\n return Promise.reject(notImplemented('dedicated.list'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The dedicated module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","/**\n * Async iterator helper for endpoints that paginate via skip/limit. Lets\n * module code expose a `stream(params)` method without re-implementing the\n * loop each time.\n *\n * Usage from a module:\n *\n * async *stream(params: FreeProxyListParams) {\n * yield* paginate({\n * fetchPage: (skip) => this.fetchPage({ ...params, skip }),\n * extractItems: (page) => page.proxies,\n * hasMore: (page) => page.nextpage,\n * pageSize: 2000,\n * });\n * }\n */\nexport interface PaginateOptions {\n fetchPage: (skip: number) => Promise;\n extractItems: (page: Page) => Item[];\n hasMore: (page: Page) => boolean;\n pageSize: number;\n /** Safety stop in case the API misreports `hasMore` forever. */\n maxPages?: number;\n}\n\nexport async function* paginate(\n opts: PaginateOptions,\n): AsyncGenerator {\n const maxPages = opts.maxPages ?? 1000;\n let skip = 0;\n for (let i = 0; i < maxPages; i++) {\n const page = await opts.fetchPage(skip);\n const items = opts.extractItems(page);\n for (const item of items) yield item;\n if (!opts.hasMore(page) || items.length === 0) return;\n skip += opts.pageSize;\n }\n}\n","import type { HttpClient, RequestOptions } from '../../core/http';\nimport { paginate } from '../../core/pagination';\nimport type { Anonymity, Protocol } from '../../core/types';\nimport type {\n FreeProxy,\n FreeProxyApiResponse,\n FreeProxyFilters,\n FreeProxyListParams,\n FreeProxyListResult,\n FreeProxyRaw,\n} from './types';\n\n/**\n * Wraps the v4 free-proxy-list endpoints. No auth needed — works against\n * https://api.proxyscrape.com/v4/free-proxy-list/get .\n *\n * Three shapes:\n * - list(params) — one page, returns an array + pagination metadata\n * - stream(params) — async iterator that pages through everything\n * - random(params) — convenience for \"give me one good proxy\"\n *\n * The text and CSV export endpoints are exposed via `listText` / `listCsv`\n * for callers who don't want to round-trip through JSON.\n */\nexport class FreeProxyListClient {\n private static readonly PATH = '/free-proxy-list/get';\n private static readonly MAX_PAGE_SIZE = 2000;\n\n constructor(private readonly http: HttpClient) {}\n\n /** Fetch a single page of proxies. */\n async list(\n params: FreeProxyListParams = {},\n opts: RequestOptions = {},\n ): Promise {\n const page = await this.fetchPage(params, opts);\n return {\n proxies: page.proxies.map(flattenProxy),\n shownRecords: page.shown_records,\n totalRecords: page.total_records,\n hasMore: page.nextpage,\n };\n }\n\n /**\n * Iterate every matching proxy across all pages. Stops automatically when\n * the API reports `nextpage: false`. Yields one proxy at a time so callers\n * can break out early without fetching the whole pool.\n */\n async *stream(\n params: FreeProxyFilters = {},\n opts: RequestOptions = {},\n ): AsyncGenerator {\n yield* paginate({\n pageSize: FreeProxyListClient.MAX_PAGE_SIZE,\n fetchPage: (skip) =>\n this.fetchPage({ ...params, limit: FreeProxyListClient.MAX_PAGE_SIZE, skip }, opts),\n extractItems: (page) => page.proxies.map(flattenProxy),\n hasMore: (page) => page.nextpage,\n });\n }\n\n /**\n * Return a single proxy matching the filters, or null if no matches exist.\n * Picks the first one the API returns — combine with filters (uptime,\n * country, anonymity) to narrow the pool before calling.\n */\n async random(\n params: FreeProxyFilters = {},\n opts: RequestOptions = {},\n ): Promise {\n // limit=1 is the cheapest way to ask \"do any exist\" + \"give me one\".\n const page = await this.fetchPage({ ...params, limit: 1 }, opts);\n const first = page.proxies[0];\n return first ? flattenProxy(first) : null;\n }\n\n /**\n * Plain-text export — one line per proxy as `protocol://ip:port`. Hands\n * back the raw body string so callers can pipe it straight to a file or\n * feed it line-by-line into another tool.\n */\n async listText(params: FreeProxyFilters = {}, opts: RequestOptions = {}): Promise {\n return this.http.getText(\n FreeProxyListClient.PATH,\n buildQuery({\n ...params,\n request: 'display_proxies',\n proxy_format: 'protocolipport',\n format: 'text',\n }),\n opts,\n );\n }\n\n /** CSV export — full per-proxy fields, header row included. */\n async listCsv(params: FreeProxyFilters = {}, opts: RequestOptions = {}): Promise {\n return this.http.getText(\n FreeProxyListClient.PATH,\n buildQuery({\n ...params,\n request: 'display_proxies',\n proxy_format: 'protocolipport',\n format: 'csv',\n }),\n opts,\n );\n }\n\n private async fetchPage(\n params: FreeProxyListParams,\n opts: RequestOptions,\n ): Promise {\n return this.http.getJson(\n FreeProxyListClient.PATH,\n buildQuery({\n ...params,\n request: 'get_proxies',\n proxy_format: 'protocolipport',\n format: 'json',\n }),\n opts,\n );\n }\n}\n\n// --- helpers ---------------------------------------------------------------\n\n/** Build the query-string object the API expects from our public filter shape. */\nfunction buildQuery(\n params: FreeProxyListParams & { request: string; proxy_format: string; format: string },\n): Record {\n return {\n request: params.request,\n proxy_format: params.proxy_format,\n format: params.format,\n protocol: arr(params.protocol)?.join(',')?.toLowerCase(),\n country: arr(params.country)\n ?.map((c) => c.toLowerCase())\n .join(','),\n anonymity: arr(params.anonymity)?.join(','),\n timeout: params.maxTimeoutMs,\n uptime: params.minUptimePercent,\n ssl: params.httpsOnly === true ? 'yes' : params.httpsOnly === false ? 'no' : undefined,\n port: arr(params.port)?.join(','),\n limit: params.limit,\n skip: params.skip,\n };\n}\n\nfunction arr(v: T | T[] | undefined): T[] | undefined {\n if (v == null) return undefined;\n return Array.isArray(v) ? v : [v];\n}\n\nfunction flattenProxy(p: FreeProxyRaw): FreeProxy {\n const ip = p.ip;\n const port = p.port;\n const protocol = (p.protocol || '').toLowerCase() as Protocol;\n const asField = p.ip_data?.as ?? '';\n const asn = asField.startsWith('AS') ? asField.split(' ', 1)[0]! : '';\n\n return {\n protocol,\n ip,\n port,\n url: `${protocol}://${ip}:${port}`,\n countryCode: (p.ip_data?.countryCode ?? '').toUpperCase(),\n country: p.ip_data?.country ?? '',\n city: p.ip_data?.city ?? '',\n anonymity: (p.anonymity as Anonymity) || 'unknown',\n ssl: Boolean(p.ssl),\n uptimePercent: typeof p.uptime === 'number' ? Math.round(p.uptime * 100) / 100 : null,\n asn,\n isp: p.ip_data?.isp ?? '',\n latencyMs: typeof p.timeout === 'number' ? Math.round(p.timeout * 100) / 100 : null,\n lastCheckedAt:\n typeof p.last_seen === 'number' ? new Date(p.last_seen * 1000).toISOString() : null,\n raw: p,\n };\n}\n","import type { HttpClient } from '../../core/http';\nimport type { GetPublicIpOptions, PublicIpInfo, PublicIpService } from './types';\n\n/**\n * Public-IP lookup helper. Wraps third-party IP-echo services behind a\n * single normalised response shape. Lives on the top-level `ProxyScrape`\n * client (as `.getPublicIp()`) because it doesn't fit cleanly inside any\n * one product module — it's an environmental fact about the caller, not\n * a free-list or checker or residential concern.\n *\n * Two providers are baked in:\n * - ipinfo.io → IP + geo + ASN, no key needed up to 50k req/month\n * - api.ipify → IP only, unlimited, no rate limits worth thinking about\n *\n * Anyone hitting our SDK at production volume should either pass an\n * `ipinfoToken` (their own ipinfo account) or override `endpoint` with\n * their own infrastructure. We don't proxy these calls through ProxyScrape\n * — they go directly from the caller to the chosen provider.\n *\n * The HttpClient is used with `skipAuth: true` so the caller's ProxyScrape\n * API key never leaves proxyscrape.com.\n */\nexport class PublicIpClient {\n constructor(private readonly http: HttpClient) {}\n\n async get(opts: GetPublicIpOptions = {}): Promise {\n const service: PublicIpService = opts.service ?? 'ipinfo';\n const endpoint = opts.endpoint ?? defaultEndpoint(service, opts.ipinfoToken);\n\n const raw = await this.http.getJson>(endpoint, undefined, {\n skipAuth: true,\n });\n\n return normalize(service, raw);\n }\n}\n\n// --- helpers ---------------------------------------------------------------\n\nfunction defaultEndpoint(service: PublicIpService, ipinfoToken: string | undefined): string {\n switch (service) {\n case 'ipinfo':\n return ipinfoToken\n ? `https://ipinfo.io/json?token=${encodeURIComponent(ipinfoToken)}`\n : 'https://ipinfo.io/json';\n case 'ipify':\n return 'https://api.ipify.org?format=json';\n }\n}\n\n/**\n * Provider responses differ in field names but overlap heavily. We map to\n * a single normalised shape and keep `raw` around for callers who need\n * something we didn't lift.\n */\nfunction normalize(service: PublicIpService, raw: Record): PublicIpInfo {\n const out: PublicIpInfo = { ip: String(raw['ip'] ?? ''), raw };\n\n if (typeof raw['country'] === 'string') out.country = raw['country'];\n if (typeof raw['region'] === 'string') out.region = raw['region'];\n if (typeof raw['city'] === 'string') out.city = raw['city'];\n if (typeof raw['org'] === 'string') out.org = raw['org'];\n if (typeof raw['postal'] === 'string') out.postal = raw['postal'];\n if (typeof raw['timezone'] === 'string') out.timezone = raw['timezone'];\n\n // ipinfo returns \"lat,lon\" as a single field; split it into numbers for\n // typical consumers, but keep the original string under `loc` for parity.\n if (service === 'ipinfo' && typeof raw['loc'] === 'string') {\n out.loc = raw['loc'];\n const [latStr, lonStr] = raw['loc'].split(',');\n const lat = latStr ? Number(latStr) : Number.NaN;\n const lon = lonStr ? Number(lonStr) : Number.NaN;\n if (Number.isFinite(lat)) out.latitude = lat;\n if (Number.isFinite(lon)) out.longitude = lon;\n }\n\n return out;\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the mobile proxies module. Real implementation lands once\n * the v4 endpoints are stable. Public methods are an intentional commitment\n * to the v1.x surface — only the bodies fill in.\n *\n * The HttpClient reference is held even though the stub methods don't use\n * it yet — that way the constructor isn't \"useless\" (it really will be\n * needed) and the eventual implementation slots in without touching the\n * constructor signature or callers.\n */\nexport class MobileClient {\n constructor(protected readonly http: HttpClient) {}\n\n acquire(_params?: Record): Promise {\n return Promise.reject(notImplemented('mobile.acquire'));\n }\n\n release(_params?: Record): Promise {\n return Promise.reject(notImplemented('mobile.release'));\n }\n\n list(_params?: Record): Promise {\n return Promise.reject(notImplemented('mobile.list'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The mobile module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the residential proxies module. Real implementation lands once\n * the v4 endpoints are stable. Public methods are an intentional commitment\n * to the v1.x surface — only the bodies fill in.\n *\n * The HttpClient reference is held even though the stub methods don't use\n * it yet — that way the constructor isn't \"useless\" (it really will be\n * needed) and the eventual implementation slots in without touching the\n * constructor signature or callers.\n */\nexport class ResidentialClient {\n constructor(protected readonly http: HttpClient) {}\n\n acquire(_params?: Record): Promise {\n return Promise.reject(notImplemented('residential.acquire'));\n }\n\n release(_params?: Record): Promise {\n return Promise.reject(notImplemented('residential.release'));\n }\n\n listSessions(_params?: Record): Promise {\n return Promise.reject(notImplemented('residential.listSessions'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The residential module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","import { ProxyScrapeError } from '../../core/errors';\nimport type { HttpClient } from '../../core/http';\n\n/**\n * Stub for the serp proxies module. Real implementation lands once\n * the v4 endpoints are stable. Public methods are an intentional commitment\n * to the v1.x surface — only the bodies fill in.\n *\n * The HttpClient reference is held even though the stub methods don't use\n * it yet — that way the constructor isn't \"useless\" (it really will be\n * needed) and the eventual implementation slots in without touching the\n * constructor signature or callers.\n */\nexport class SerpClient {\n constructor(protected readonly http: HttpClient) {}\n\n search(_params?: Record): Promise {\n return Promise.reject(notImplemented('serp.search'));\n }\n\n raw(_params?: Record): Promise {\n return Promise.reject(notImplemented('serp.raw'));\n }\n}\n\nfunction notImplemented(name: string): ProxyScrapeError {\n return new ProxyScrapeError(\n `${name}() is not implemented in this SDK version. The serp module is scaffolded for a future release — track https://github.com/ProxyScrape/proxyscrape-sdk/issues for status.`,\n );\n}\n","import { HttpClient, type RequestOptions } from './core/http';\nimport type { ClientOptions } from './core/types';\nimport { CheckerClient } from './modules/checker';\nimport { DatacenterClient } from './modules/datacenter';\nimport { DedicatedClient } from './modules/dedicated';\nimport { FreeProxyListClient } from './modules/free';\nimport type { FreeProxy, FreeProxyFilters } from './modules/free';\nimport { PublicIpClient } from './modules/ip';\nimport type { GetPublicIpOptions, PublicIpInfo } from './modules/ip';\nimport { MobileClient } from './modules/mobile';\nimport { ResidentialClient } from './modules/residential';\nimport { SerpClient } from './modules/serp';\n\n/**\n * The single public class users import. Holds a configured HTTP client and\n * exposes each product as a namespace on the instance:\n *\n * const ps = new ProxyScrape(); // free tier — no auth\n * await ps.free.list({ protocol: 'socks5' });\n *\n * const ps = new ProxyScrape({ apiKey });\n * await ps.residential.acquire({ ... }); // throws until implemented\n *\n * Adding a new product later means:\n * 1. Create src/modules//{index.ts,client.ts,types.ts}\n * 2. Add the field below\n * 3. No change to the public API contract — existing callers are unaffected.\n */\nexport class ProxyScrape {\n /** Free, unauthenticated proxy list. v0.1 — implemented. */\n readonly free: FreeProxyListClient;\n\n /** Proxy checker. v0.1 — stub, throws on use. */\n readonly checker: CheckerClient;\n\n /** Residential proxy pool. v0.1 — stub. */\n readonly residential: ResidentialClient;\n\n /** Datacenter proxy pool. v0.1 — stub. */\n readonly datacenter: DatacenterClient;\n\n /** Dedicated datacenter proxies. v0.1 — stub. */\n readonly dedicated: DedicatedClient;\n\n /** Mobile proxies. v0.1 — stub. */\n readonly mobile: MobileClient;\n\n /** Google SERP API. v0.1 — stub. */\n readonly serp: SerpClient;\n\n // Held privately because the umbrella class wraps it via `getPublicIp()`\n // rather than exposing it as a namespace — IP lookup is single-method and\n // belongs at the top level, not as `ps.ip.get()`.\n private readonly publicIp: PublicIpClient;\n\n constructor(opts: ClientOptions = {}) {\n const http = new HttpClient(opts);\n this.free = new FreeProxyListClient(http);\n this.checker = new CheckerClient(http);\n this.residential = new ResidentialClient(http);\n this.datacenter = new DatacenterClient(http);\n this.dedicated = new DedicatedClient(http);\n this.mobile = new MobileClient(http);\n this.serp = new SerpClient(http);\n this.publicIp = new PublicIpClient(http);\n }\n\n /**\n * Shortcut for `client.free.random(filters)` — picks one matching free\n * proxy, or null if none match.\n *\n * Lives at the top level because \"give me a proxy\" is the canonical\n * first call into the SDK. Functionally identical to `.free.random()`;\n * use whichever reads better in your code.\n *\n * const p = await ps.proxy({ country: 'us', anonymity: 'elite' });\n * if (p) console.log(p.url);\n */\n proxy(filters: FreeProxyFilters = {}, opts: RequestOptions = {}): Promise {\n return this.free.random(filters, opts);\n }\n\n /**\n * Look up the caller's public IP address. Useful for proxy\n * before/after verification:\n *\n * const real = await ps.getPublicIp();\n * // ...route a request through a proxy...\n * if (proxiedIp.ip === real.ip) console.warn('Proxy leaked real IP');\n *\n * Defaults to ipinfo.io (no key, ~50k req/month free, returns IP + geo).\n * Pass `{ service: 'ipify' }` for IP-only / unlimited, or `{ endpoint }`\n * to point at your own service. The caller's ProxyScrape API key is\n * never forwarded to the third-party provider.\n */\n getPublicIp(opts: GetPublicIpOptions = {}): Promise {\n return this.publicIp.get(opts);\n }\n}\n"],"mappings":"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","names":["notImplemented","notImplemented","notImplemented","notImplemented","notImplemented"]}