scrapfly-sdk 0.5.1 → 0.6.4

package/README.md

@@ -1,8 +1,10 @@
 # Scrapfly SDK
 
-`npm install scrapfly-sdk`
+`npm install scrapfly-sdk`  
+`deno add jsr:@scrapfly/scrapfly-sdk`  
+`bun jsr add @scrapfly/scrapfly-sdk`  
 
-Typescript/NodeJS SDK for [Scrapfly.io](https://scrapfly.io/) web scraping API which allows to:
+Typescript/Javascript SDK for [Scrapfly.io](https://scrapfly.io/) web scraping API which allows to:
 
 -   Scrape the web without being blocked.
 -   Use headless browsers to access Javascript-powered page data.
@@ -11,6 +13,10 @@ Typescript/NodeJS SDK for [Scrapfly.io](https://scrapfly.io/) web scraping API w
 
 For web scraping guides see [our blog](https://scrapfly.io/blog/) and [#scrapeguide](https://scrapfly.io/blog/tag/scrapeguide/) tag for how to scrape specific targets.
 
+The SDK is distributed through:
+- [npmjs.com/package/scrapfly-sdk](https://www.npmjs.com/package/scrapfly-sdk)
+- [jsr.io/@scrapfly/scrapfly-sdk](https://jsr.io/@scrapfly/scrapfly-sdk)
+
 ## Quick Intro
 
 1. Register a [Scrapfly account for free](https://scrapfly.io/register)
@@ -18,7 +24,12 @@ For web scraping guides see [our blog](https://scrapfly.io/blog/) and [#scrapegu
 3. Start scraping: 🚀
 
 ```javascript
+// node 
 import { ScrapflyClient, ScrapeConfig } from 'scrapfly-sdk';
+// bun
+import { ScrapflyClient, ScrapeConfig} from '@scrapfly/scrapfly-sdk';
+// deno: 
+import { ScrapflyClient, ScrapeConfig } from 'jsr:@scrapfly/scrapfly-sdk';
 
 const key = 'YOUR SCRAPFLY KEY';
 const client = new ScrapflyClient({ key });
@@ -70,15 +81,25 @@ new ScrapeConfig({
 
 ## Development
 
-Install and setup environment:
-
-```shell
-$ npm install
-```
-
-Build and test:
-
-```shell
-$ npm run build
-$ npm run test
-```
+This is a Deno Typescript project that builds to NPM through [DNT](https://github.com/denoland/dnt).
+
+- `/src` directory contains all of the source code with `main.ts` being the entry point.
+- `__tests__` directory contains tests for the source code.
+- `deno.json` contains meta information
+- `build.ts` is the build script that builds the project to nodejs ESM package.
+- `/npm` directory will be produced when `built.ts` is executed for building node package.
+
+```bash
+# make modifications and run tests
+$ deno task test
+# format
+$ deno fmt
+# lint
+$ deno lint
+# publish JSR:
+$ deno publish
+# build NPM package:
+$ deno build-npm
+# publish NPM:
+$ cd npm && npm publish
+```

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,61 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/client.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="node" />
+import { fetchRetry } from './utils.js';
+import * as errors from './errors.js';
+import type { ScrapeConfig } from './scrapeconfig.js';
+import type { ScreenshotConfig } from './screenshotconfig.js';
+import type { ExtractionConfig } from './extractionconfig.js';
+import { type AccountData, ExtractionResult, ScrapeResult, ScreenshotResult } from './result.js';
+export declare class ScrapflyClient {
+    HOST: string;
+    private key;
+    private ua;
+    fetch: typeof fetchRetry;
+    constructor(options: {
+        key: string;
+    });
+    /**
+     * Raise appropriate error for given response and scrape result
+     */
+    errResult(response: Response, result: ScrapeResult): errors.ScrapflyError;
+    /**
+     * Turn scrapfly API response to ScrapeResult or raise one of ScrapflyError
+     */
+    handleResponse(response: Response, result: ScrapeResult): ScrapeResult;
+    /**
+     * Retrieve Scrapfly account details
+     */
+    account(): Promise<AccountData>;
+    /**
+     * Issue a single scrape command from a given scrape configuration
+     */
+    scrape(config: ScrapeConfig): Promise<ScrapeResult>;
+    /**
+    Concurrently scrape multiple configs
+    This is a async generator call it like this:
+  
+      const results = [];
+      const errors = [];
+      for await (const resultOrError of client.concurrentScrape(configs)) {
+          if (resultOrError instanceof Error) {
+              errors.push(resultOrError);
+          } else {
+              results.push(resultOrError);
+          }
+      }
+  
+    @param concurrencyLimit: if not set it will be taken from your account info
+    */
+    concurrentScrape(configs: ScrapeConfig[], concurrencyLimit?: number): AsyncGenerator<ScrapeResult | Error | undefined, void, undefined>;
+    /**
+     * Save screenshot response to a file
+     */
+    saveScreenshot(result: ScreenshotResult, name: string, savePath?: string): Promise<any>;
+    /**
+     * Turn scrapfly screenshot API response to ScreenshotResult or raise one of ScrapflyError
+     */
+    handleScreenshotResponse(response: Response): Promise<ScreenshotResult>;
+    /**
+     * Take a screenshot
+     */
+    screenshot(config: ScreenshotConfig): Promise<ScreenshotResult>;
+    /**
+     * Turn scrapfly Extraction API response to ExtractionResult or raise one of ScrapflyError
+     */
+    handleExtractionResponse(response: Response): Promise<ExtractionResult>;
+    /**
+     * Extract structured data from a web page
+     */
+    extract(config: ExtractionConfig): Promise<ExtractionResult>;
+}
+//# sourceMappingURL=client.d.ts.map

package/esm/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,KAAK,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIjG,qBAAa,cAAc;IAClB,IAAI,SAA6B;IACxC,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,EAAE,CAAS;IACnB,KAAK,oBAAc;gBAEP,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;IAQpC;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC,aAAa;IAkEzE;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,GAAG,YAAY;IAUtE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,WAAW,CAAC;IA8BrC;;OAEG;IACG,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IA4CzD;;;;;;;;;;;;;;;MAeE;IACK,gBAAgB,CACrB,OAAO,EAAE,YAAY,EAAE,EACvB,gBAAgB,CAAC,EAAE,MAAM,GACxB,cAAc,CAAC,YAAY,GAAG,KAAK,GAAG,SAAS,EAAE,IAAI,EAAE,SAAS,CAAC;IAqCpE;;OAEG;IACG,cAAc,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAoB7F;;OAEG;IACG,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkB7E;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAuBrE;;OAEG;IACG,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkB7E;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA6BnE"}

package/esm/client.js

@@ -0,0 +1,364 @@
+import { path } from './deps.js';
+import { mkdir, writeFile } from './polyfill.js';
+import { fetchRetry } from './utils.js';
+import * as errors from './errors.js';
+import { ExtractionResult, ScrapeResult, ScreenshotResult } from './result.js';
+import { log } from './logger.js';
+export class ScrapflyClient {
+    constructor(options) {
+        Object.defineProperty(this, "HOST", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'https://api.scrapfly.io'
+        });
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ua", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fetch", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetchRetry
+        });
+        if (typeof options.key !== 'string' || options.key.trim() === '') {
+            throw new errors.BadApiKeyError('Invalid key. Key must be a non-empty string');
+        }
+        this.key = options.key;
+        this.ua = 'Typescript Scrapfly SDK';
+    }
+    /**
+     * Raise appropriate error for given response and scrape result
+     */
+    errResult(response, result) {
+        const error = result.result.error;
+        const message = error?.message ?? '';
+        const args = {
+            code: result.result.status,
+            http_status_code: result.result.status_code,
+            is_retryable: error?.retryable ?? false,
+            api_response: result,
+            resource: result.result.status ? result.result.status.split('::')[1] : null,
+            retry_delay: error?.retryable ? 5 : response.headers.get('X-Retry') ?? 5,
+            retry_times: 3,
+            documentation_url: error?.doc_url ?? 'https://scrapfly.io/docs/scrape-api/errors#api',
+        };
+        if (result.result.success === true) {
+            switch (args.http_status_code) {
+                case 500:
+                    return new errors.ApiHttpServerError(message, args);
+                case 401:
+                    return new errors.BadApiKeyError(message, args);
+                case 429:
+                    return new errors.TooManyRequests(message, args);
+            }
+            switch (args.resource) {
+                case 'SCRAPE':
+                    return new errors.ScrapflyScrapeError(message, args);
+                case 'WEBHOOK':
+                    return new errors.ScrapflyWebhookError(message, args);
+                case 'PROXY':
+                    return new errors.ScrapflyProxyError(message, args);
+                case 'SCHEDULE':
+                    return new errors.ScrapflyScheduleError(message, args);
+                case 'ASP':
+                    return new errors.ScrapflyAspError(message, args);
+                case 'SESSION':
+                    return new errors.ScrapflySessionError(message, args);
+            }
+            if (args.resource) {
+                return new errors.ApiHttpClientError(message, args);
+            }
+        }
+        else {
+            if (args.code === 'ERR::SCRAPE::BAD_UPSTREAM_RESPONSE') {
+                if (args.http_status_code >= 400 && args.http_status_code < 500) {
+                    return new errors.UpstreamHttpClientError(message, args);
+                }
+                if (args.http_status_code >= 500 && args.http_status_code < 600) {
+                    return new errors.UpstreamHttpServerError(message, args);
+                }
+            }
+            switch (args.resource) {
+                case 'SCRAPE':
+                    return new errors.ScrapflyScrapeError(message, args);
+                case 'WEBHOOK':
+                    return new errors.ScrapflyWebhookError(message, args);
+                case 'PROXY':
+                    return new errors.ScrapflyProxyError(message, args);
+                case 'SCHEDULE':
+                    return new errors.ScrapflyScheduleError(message, args);
+                case 'ASP':
+                    return new errors.ScrapflyAspError(message, args);
+                case 'SESSION':
+                    return new errors.ScrapflySessionError(message, args);
+            }
+        }
+        return new errors.ScrapflyError(message, args);
+    }
+    /**
+     * Turn scrapfly API response to ScrapeResult or raise one of ScrapflyError
+     */
+    handleResponse(response, result) {
+        // success
+        log.debug('scrape log url: ', result.result.log_url);
+        if (result.result.status === 'DONE' && result.result.success === true) {
+            return result;
+        }
+        // something went wrong
+        throw this.errResult(response, result);
+    }
+    /**
+     * Retrieve Scrapfly account details
+     */
+    async account() {
+        log.debug('retrieving account info');
+        let response;
+        try {
+            const url = new URL(this.HOST + '/account');
+            const params = { key: this.key };
+            url.search = new URLSearchParams(params).toString();
+            response = await this.fetch({
+                url: url.toString(),
+                method: 'GET',
+                headers: {
+                    'user-agent': this.ua,
+                    'accept-encoding': 'gzip, deflate, br',
+                    accept: 'application/json',
+                },
+            });
+        }
+        catch (e) {
+            log.error('error', e);
+            throw e;
+        }
+        const data = await response.json();
+        if ('error_id' in data || Object.keys(data).length === 0) {
+            if (data.http_code == 401 || response.status == 401) {
+                throw new errors.BadApiKeyError(JSON.stringify(data));
+            }
+            throw new errors.ApiHttpClientError(JSON.stringify(data));
+        }
+        return data;
+    }
+    /**
+     * Issue a single scrape command from a given scrape configuration
+     */
+    async scrape(config) {
+        log.debug('scraping', { method: config.method, url: config.url });
+        let response;
+        try {
+            const url = new URL(this.HOST + '/scrape');
+            const params = config.toApiParams({ key: this.key });
+            url.search = new URLSearchParams(params).toString();
+            response = await this.fetch({
+                url: url.toString(),
+                method: config.method,
+                headers: {
+                    'user-agent': this.ua,
+                    'content-type': config.method === 'POST'
+                        ? config.headers?.['content-type'] ?? 'application/json'
+                        : 'application/json',
+                    'accept-encoding': 'gzip, deflate, br',
+                    accept: 'application/json',
+                },
+                body: config.body,
+            });
+        }
+        catch (e) {
+            log.error('error', e);
+            e.scrapeConfig = config;
+            throw e;
+        }
+        const data = await response.json();
+        if ('error_id' in data || Object.keys(data).length === 0) {
+            if (data.http_code == 401 || response.status == 401) {
+                throw new errors.BadApiKeyError(JSON.stringify(data));
+            }
+            throw new errors.ApiHttpClientError(JSON.stringify(data));
+        }
+        const result = this.handleResponse(response, new ScrapeResult({
+            config: data.config,
+            context: data.context,
+            result: data.result,
+            uuid: data.uuid,
+        }));
+        return result;
+    }
+    /**
+    Concurrently scrape multiple configs
+    This is a async generator call it like this:
+  
+      const results = [];
+      const errors = [];
+      for await (const resultOrError of client.concurrentScrape(configs)) {
+          if (resultOrError instanceof Error) {
+              errors.push(resultOrError);
+          } else {
+              results.push(resultOrError);
+          }
+      }
+  
+    @param concurrencyLimit: if not set it will be taken from your account info
+    */
+    async *concurrentScrape(configs, concurrencyLimit) {
+        if (concurrencyLimit === undefined) {
+            const account = await this.account();
+            concurrencyLimit = account.subscription.usage.scrape.concurrent_limit;
+            log.info(`concurrency not provided - setting it to ${concurrencyLimit} from account info`);
+        }
+        const activePromises = new Set();
+        const configsIterator = configs[Symbol.iterator]();
+        // Helper function to start a new scrape and add it to activePromises
+        const startNewScrape = () => {
+            const { value: config, done } = configsIterator.next();
+            if (done)
+                return; // No more configs
+            const promise = this.scrape(config).catch((error) => error); // Catch errors and return them
+            activePromises.add(promise);
+            promise.finally(() => {
+                activePromises.delete(promise);
+                // After each scrape, start a new one if there are remaining configs
+                startNewScrape();
+            });
+        };
+        // Initially start as many scrapes as the concurrency limit
+        for (let i = 0; i < concurrencyLimit; i++) {
+            startNewScrape();
+        }
+        // As each scrape finishes, yield the result or error and start a new one if there are remaining configs
+        while (activePromises.size > 0) {
+            log.debug(`concurrently scraping ${activePromises.size}/${configs.length}}`);
+            const resultOrError = await Promise.race(activePromises);
+            yield resultOrError;
+        }
+    }
+    /**
+     * Save screenshot response to a file
+     */
+    async saveScreenshot(result, name, savePath) {
+        if (!result.image) {
+            throw new Error('Screenshot binary does not exist');
+        }
+        const extension_name = result.metadata.extension_name;
+        let file_path;
+        if (savePath) {
+            await mkdir(savePath, { recursive: true });
+            file_path = path.join(savePath, `${name}.${extension_name}`);
+        }
+        else {
+            file_path = `${name}.${extension_name}`;
+        }
+        const content = new Uint8Array(result.image);
+        // Use Deno's write file method
+        await writeFile(file_path, content);
+    }
+    /**
+     * Turn scrapfly screenshot API response to ScreenshotResult or raise one of ScrapflyError
+     */
+    async handleScreenshotResponse(response) {
+        if (response.headers.get('content-type') === 'application/json') {
+            const data = (await response.json());
+            if (data.http_code == 401 || response.status == 401) {
+                throw new errors.BadApiKeyError(JSON.stringify(data));
+            }
+            if ('error_id' in data) {
+                throw new errors.ScreenshotApiError(JSON.stringify(data));
+            }
+        }
+        if (!response.ok) {
+            throw new errors.ScreenshotApiError(JSON.stringify(await response.json()));
+        }
+        const data = await response.arrayBuffer();
+        const result = new ScreenshotResult(response, data);
+        return result;
+    }
+    /**
+     * Take a screenshot
+     */
+    async screenshot(config) {
+        let response;
+        try {
+            const url = new URL(this.HOST + '/screenshot');
+            const params = config.toApiParams({ key: this.key });
+            url.search = new URLSearchParams(params).toString();
+            response = await this.fetch({
+                url: url.toString(),
+                method: 'GET',
+                headers: {
+                    'user-agent': this.ua,
+                    'accept-encoding': 'gzip, deflate, br',
+                    accept: 'application/json',
+                },
+            });
+        }
+        catch (e) {
+            log.error('error', e);
+            throw e;
+        }
+        const result = await this.handleScreenshotResponse(response);
+        return result;
+    }
+    /**
+     * Turn scrapfly Extraction API response to ExtractionResult or raise one of ScrapflyError
+     */
+    async handleExtractionResponse(response) {
+        const data = (await response.json());
+        if ('error_id' in data) {
+            if (data.http_code == 401 || response.status == 401) {
+                throw new errors.BadApiKeyError(JSON.stringify(data));
+            }
+            throw new errors.ExtractionApiError(JSON.stringify(data));
+        }
+        if (!response.ok) {
+            throw new errors.ApiHttpClientError(JSON.stringify(await response.json()));
+        }
+        const result = new ExtractionResult({
+            data: data.data,
+            content_type: data.content_type,
+        });
+        return result;
+    }
+    /**
+     * Extract structured data from a web page
+     */
+    async extract(config) {
+        log.debug('extacting data from', { content_type: config.content_type });
+        let response;
+        try {
+            const url = new URL(this.HOST + '/extraction');
+            const params = await config.toApiParams({ key: this.key });
+            url.search = new URLSearchParams(params).toString();
+            const headers = {
+                'user-agent': this.ua,
+                'accept-encoding': 'gzip, deflate, br',
+                'content-type': config.content_type,
+                'accept': 'application/json',
+            };
+            if (config.document_compression_format && config.document_compression_format) {
+                headers['content-encoding'] = config.document_compression_format;
+            }
+            response = await this.fetch({
+                url: url.toString(),
+                method: 'POST',
+                headers: headers,
+                body: config.body,
+            });
+        }
+        catch (e) {
+            log.error('error', e);
+            throw e;
+        }
+        const result = await this.handleExtractionResponse(response);
+        return result;
+    }
+}

package/esm/deps/jsr.io/@std/path/1.0.1/_common/assert_path.d.ts

@@ -0,0 +1,2 @@
+export declare function assertPath(path?: string): void;
+//# sourceMappingURL=assert_path.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.1/_common/assert_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.1/_common/assert_path.ts"],"names":[],"mappings":"AAGA,wBAAgB,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,QAMvC"}

package/esm/deps/jsr.io/@std/path/1.0.1/_common/assert_path.js

@@ -0,0 +1,7 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+export function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.0.1/_common/basename.d.ts

@@ -0,0 +1,4 @@
+export declare function stripSuffix(name: string, suffix: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function assertArgs(path: string, suffix: string): string | undefined;
+//# sourceMappingURL=basename.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.1/_common/basename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basename.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.1/_common/basename.ts"],"names":[],"mappings":"AAKA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAchE;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAChC,KAAK,SAAI,GACR,MAAM,CAiBR;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,sBAQtD"}

package/esm/deps/jsr.io/@std/path/1.0.1/_common/basename.js

@@ -0,0 +1,40 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { assertPath } from "./assert_path.js";
+export function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+export function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+export function assertArgs(path, suffix) {
+    assertPath(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
+}

package/esm/deps/jsr.io/@std/path/1.0.1/_common/common.d.ts

@@ -0,0 +1,2 @@
+export declare function common(paths: string[], sep: string): string;
+//# sourceMappingURL=common.d.ts.map

package/esm/deps/jsr.io/@std/path/1.0.1/_common/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.0.1/_common/common.ts"],"names":[],"mappings":"AAGA,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAsB3D"}