@zetagoaurum-dev/straw 1.0.0

package/dist/index.mjs

@@ -0,0 +1,251 @@
+// src/core/client.ts
+import { fetch, Agent } from "undici";
+
+// src/utils/helpers.ts
+var USER_AGENTS = [
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 14.2; rv:109.0) Gecko/20100101 Firefox/121.0",
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_2_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
+];
+function getRandomUserAgent() {
+  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/client.ts
+var StrawClient = class {
+  options;
+  dispatcher;
+  constructor(options = {}) {
+    this.options = {
+      timeout: 1e4,
+      retries: 3,
+      rotateUserAgent: true,
+      ...options
+    };
+    this.dispatcher = new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
+    });
+  }
+  /**
+   * Fetch a URL with built-in retries, timeout, and User-Agent rotation.
+   */
+  async request(url, init) {
+    let attempts = 0;
+    const maxRetries = this.options.retries || 1;
+    while (attempts < maxRetries) {
+      try {
+        const headers = new Headers(init?.headers);
+        if (this.options.rotateUserAgent && !headers.has("User-Agent")) {
+          headers.set("User-Agent", getRandomUserAgent());
+        }
+        if (!headers.has("Accept")) {
+          headers.set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7");
+        }
+        if (!headers.has("Accept-Language")) {
+          headers.set("Accept-Language", "en-US,en;q=0.9");
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+        const response = await fetch(url, {
+          ...init,
+          headers,
+          signal: controller.signal,
+          dispatcher: this.options.proxy ? void 0 : this.dispatcher
+        });
+        clearTimeout(timeoutId);
+        if ([429, 500, 502, 503, 504].includes(response.status)) {
+          throw new Error(`HTTP Error ${response.status}`);
+        }
+        return response;
+      } catch (error) {
+        attempts++;
+        if (attempts >= maxRetries) {
+          const cause = error.cause ? String(error.cause) : "No cause provided";
+          throw new Error(`Failed to fetch ${url} after ${maxRetries} attempts. Last error: ${error.message} - Cause: ${cause}`);
+        }
+        await sleep(1e3 * Math.pow(2, attempts));
+      }
+    }
+    throw new Error("Unreachable");
+  }
+  async getText(url, init) {
+    const response = await this.request(url, init);
+    return await response.text();
+  }
+  async getJson(url, init) {
+    const response = await this.request(url, init);
+    return await response.json();
+  }
+};
+
+// src/scrapers/web.ts
+import * as cheerio from "cheerio";
+var WebScraper = class {
+  client;
+  constructor(options) {
+    this.client = new StrawClient(options);
+  }
+  /**
+   * Scrape a webpage and return structured data.
+   * Extracts title, generic text, metadata, and all links.
+   */
+  async scrape(url) {
+    const html = await this.client.getText(url);
+    const $ = cheerio.load(html);
+    const title = $("title").text().trim();
+    let description = $('meta[name="description"]').attr("content") || "";
+    if (!description) {
+      description = $('meta[property="og:description"]').attr("content") || "";
+    }
+    const meta = {};
+    $("meta").each((_, el) => {
+      const name = $(el).attr("name") || $(el).attr("property");
+      const content = $(el).attr("content");
+      if (name && content) {
+        meta[name] = content;
+      }
+    });
+    const links = [];
+    $("a").each((_, el) => {
+      const href = $(el).attr("href");
+      const text2 = $(el).text().trim();
+      if (href && href.startsWith("http")) {
+        links.push({ text: text2, href });
+      }
+    });
+    $("script, style, noscript, iframe, svg").remove();
+    const text = $("body").text().replace(/\s+/g, " ").trim();
+    return {
+      title,
+      description,
+      text,
+      links,
+      meta
+    };
+  }
+};
+
+// src/scrapers/youtube.ts
+var YouTubeScraper = class {
+  client;
+  constructor(options) {
+    this.client = new StrawClient(options);
+  }
+  /**
+   * Extracts YouTube video metadata and direct stream URLs without external bloatware.
+   * Parses the ytInitialPlayerResponse object embedded in the watch HTML.
+   */
+  async scrapeVideo(url) {
+    const html = await this.client.getText(url, {
+      headers: {
+        "Cookie": "CONSENT=YES+cb.20230501-14-p0.en+FX+430"
+      }
+    });
+    const regex = /ytInitialPlayerResponse\s*=\s*({.*?});(?:var|<\/script>)/;
+    const match = html.match(regex);
+    if (!match || !match[1]) {
+      throw new Error("ytInitialPlayerResponse not found. YouTube might have changed their layout or the IP is blocked.");
+    }
+    const data = JSON.parse(match[1]);
+    const details = data?.videoDetails;
+    const streamingData = data?.streamingData;
+    if (!details) {
+      throw new Error("Video details not found inside player response.");
+    }
+    const formats = [];
+    const rawFormats = [...streamingData?.formats || [], ...streamingData?.adaptiveFormats || []];
+    for (const format of rawFormats) {
+      if (format.url) {
+        const mimeType = format.mimeType || "";
+        formats.push({
+          url: format.url,
+          mimeType,
+          width: format.width,
+          height: format.height,
+          quality: format.qualityLabel || format.quality,
+          bitrate: format.bitrate,
+          hasAudio: mimeType.includes("audio/"),
+          hasVideo: mimeType.includes("video/")
+        });
+      } else if (format.signatureCipher) {
+        continue;
+      }
+    }
+    return {
+      title: details.title || "",
+      author: details.author || "",
+      description: details.shortDescription || "",
+      views: details.viewCount || "0",
+      durationSeconds: details.lengthSeconds || "0",
+      thumbnail: details.thumbnail?.thumbnails?.[details.thumbnail.thumbnails.length - 1]?.url || "",
+      formats
+    };
+  }
+};
+
+// src/scrapers/media.ts
+import * as cheerio2 from "cheerio";
+var MediaScraper = class {
+  client;
+  constructor(options) {
+    this.client = new StrawClient(options);
+  }
+  /**
+   * Attempts to find direct media files (Images/Audio/Video/Documents) referenced in any generic webpage HTML.
+   */
+  async extractMedia(url) {
+    const html = await this.client.getText(url);
+    const $ = cheerio2.load(html);
+    const pageTitle = $("title").text().trim();
+    const mediaLinks = /* @__PURE__ */ new Set();
+    $("video, audio, img, source").each((_, el) => {
+      const src = $(el).attr("src") || $(el).attr("srcset");
+      if (src) {
+        const urls = src.match(/https?:\/\/[^\s"',]+/g);
+        if (urls) urls.forEach((u) => mediaLinks.add(u));
+        else if (src.startsWith("http")) mediaLinks.add(src);
+      }
+    });
+    $("a").each((_, el) => {
+      const href = $(el).attr("href");
+      if (href && href.startsWith("http") && href.match(/\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt|csv|rtf|mp4|mp3|webm|wav|ogg|m4a|avi|mkv|mov|flv|png|jpg|jpeg|gif|svg|webp|avif|ico|bmp)(\?.*)?$/i)) {
+        mediaLinks.add(href);
+      }
+    });
+    const rawLinksMatch = html.match(/https?:\/\/[^\s"',]+\.(png|jpg|jpeg|gif|svg|webp|avif|ico|bmp|pdf|doc|docx|xls|xlsx|ppt|pptx|txt|csv|rtf|mp4|mp3|webm|wav|ogg|m4a|avi|mkv|mov|flv)/gi);
+    if (rawLinksMatch) {
+      for (const link of rawLinksMatch) {
+        mediaLinks.add(link);
+      }
+    }
+    return {
+      pageTitle,
+      mediaLinks: Array.from(mediaLinks)
+    };
+  }
+};
+
+// src/index.ts
+var straw = {
+  client: (options) => new StrawClient(options),
+  web: (options) => new WebScraper(options),
+  youtube: (options) => new YouTubeScraper(options),
+  media: (options) => new MediaScraper(options)
+};
+var index_default = straw;
+export {
+  MediaScraper,
+  StrawClient,
+  WebScraper,
+  YouTubeScraper,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zetagoaurum-dev/straw",
+  "version": "1.0.0",
+  "description": "Enterprise-grade unified JS/TS and Python scraping library for Web, YouTube, and Media (Images, Audio, Video, Documents)",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "tsx tests/test.ts"
+  },
+  "keywords": [
+    "scraping",
+    "scraper",
+    "youtube-scraper",
+    "media-extractor",
+    "anti-cors"
+  ],
+  "author": "ZetaGo-Aurum",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "undici": "^7.22.0"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "straw-scraper"
+version = "1.0.0"
+description = "A high-performance, enterprise-grade scraping library for Python."
+authors = [
+    { name = "ZetaGo-Aurum" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "httpx>=0.25.0",
+    "beautifulsoup4>=4.12.0",
+    "lxml>=4.9.0"
+]
+keywords = ["scraping", "scraper", "youtube-scraper", "media-extractor", "anti-cors"]
+license = { text = "ISC" }
+
+[project.urls]
+Homepage = "https://github.com/ZetaGo-Aurum/straw"

package/src/core/client.ts

@@ -0,0 +1,94 @@
+import { fetch, RequestInit, Response, Agent } from 'undici';
+import { getRandomUserAgent, sleep } from '../utils/helpers';
+
+export interface StrawClientOptions {
+    proxy?: string;
+    timeout?: number;
+    retries?: number;
+    rotateUserAgent?: boolean;
+}
+
+export class StrawClient {
+    private options: StrawClientOptions;
+    private dispatcher: Agent;
+
+    constructor(options: StrawClientOptions = {}) {
+        this.options = {
+            timeout: 10000,
+            retries: 3,
+            rotateUserAgent: true,
+            ...options
+        };
+        
+        this.dispatcher = new Agent({
+            connect: {
+                rejectUnauthorized: false
+            }
+        });
+    }
+
+    /**
+     * Fetch a URL with built-in retries, timeout, and User-Agent rotation.
+     */
+    public async request(url: string, init?: RequestInit): Promise<Response> {
+        let attempts = 0;
+        const maxRetries = this.options.retries || 1;
+
+        while (attempts < maxRetries) {
+            try {
+                const headers = new Headers(init?.headers as any);
+                
+                if (this.options.rotateUserAgent && !headers.has('User-Agent')) {
+                    headers.set('User-Agent', getRandomUserAgent());
+                }
+
+                // Default headers to masquerade as a normal browser
+                if (!headers.has('Accept')) {
+                    headers.set('Accept', 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7');
+                }
+                if (!headers.has('Accept-Language')) {
+                    headers.set('Accept-Language', 'en-US,en;q=0.9');
+                }
+
+                // Setup AbortController for timeout
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+
+                const response = await fetch(url, {
+                    ...init,
+                    headers,
+                    signal: controller.signal as RequestInit['signal'],
+                    dispatcher: this.options.proxy ? undefined : this.dispatcher
+                });
+
+                clearTimeout(timeoutId);
+
+                // If rate limited or standard server error, retry
+                if ([429, 500, 502, 503, 504].includes(response.status)) {
+                    throw new Error(`HTTP Error ${response.status}`);
+                }
+
+                return response;
+            } catch (error: any) {
+                attempts++;
+                if (attempts >= maxRetries) {
+                    const cause = error.cause ? String(error.cause) : 'No cause provided';
+                    throw new Error(`Failed to fetch ${url} after ${maxRetries} attempts. Last error: ${error.message} - Cause: ${cause}`);
+                }
+                // Exponential backoff
+                await sleep(1000 * Math.pow(2, attempts));
+            }
+        }
+        throw new Error('Unreachable');
+    }
+
+    public async getText(url: string, init?: RequestInit): Promise<string> {
+        const response = await this.request(url, init);
+        return await response.text();
+    }
+
+    public async getJson<T>(url: string, init?: RequestInit): Promise<T> {
+        const response = await this.request(url, init);
+        return await response.json() as T;
+    }
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+import { StrawClient, StrawClientOptions } from './core/client';
+import { WebScraper, WebScrapeResult } from './scrapers/web';
+import { YouTubeScraper, YouTubeResult, YouTubeFormats } from './scrapers/youtube';
+import { MediaScraper, MediaScrapeResult } from './scrapers/media';
+
+export type { StrawClientOptions };
+export type { WebScrapeResult };
+export type { YouTubeResult, YouTubeFormats };
+export type { MediaScrapeResult };
+
+export {
+    StrawClient,
+    WebScraper,
+    YouTubeScraper,
+    MediaScraper
+};
+
+// Default export wrapper
+const straw = {
+    client: (options?: StrawClientOptions) => new StrawClient(options),
+    web: (options?: StrawClientOptions) => new WebScraper(options),
+    youtube: (options?: StrawClientOptions) => new YouTubeScraper(options),
+    media: (options?: StrawClientOptions) => new MediaScraper(options),
+};
+
+export default straw;

package/src/scrapers/media.ts

@@ -0,0 +1,58 @@
+import * as cheerio from 'cheerio';
+import { StrawClient, StrawClientOptions } from '../core/client';
+
+export interface MediaScrapeResult {
+    pageTitle: string;
+    mediaLinks: string[];
+}
+
+export class MediaScraper {
+    private client: StrawClient;
+
+    constructor(options?: StrawClientOptions) {
+        this.client = new StrawClient(options);
+    }
+
+    /**
+     * Attempts to find direct media files (Images/Audio/Video/Documents) referenced in any generic webpage HTML.
+     */
+    public async extractMedia(url: string): Promise<MediaScrapeResult> {
+        const html = await this.client.getText(url);
+        const $ = cheerio.load(html);
+
+        const pageTitle = $('title').text().trim();
+        const mediaLinks = new Set<string>();
+
+        // 1. Check <video>, <audio>, <img>, and <source> tags
+        $('video, audio, img, source').each((_, el) => {
+            const src = $(el).attr('src') || $(el).attr('srcset');
+            if (src) {
+                // handle srcset parsing simply by grabbing the first URL if needed, or just finding http links
+                const urls = src.match(/https?:\/\/[^\s"',]+/g);
+                if (urls) urls.forEach(u => mediaLinks.add(u));
+                else if (src.startsWith('http')) mediaLinks.add(src);
+            }
+        });
+
+        // 2. Check <a> tags for document/media links
+        $('a').each((_, el) => {
+            const href = $(el).attr('href');
+            if (href && href.startsWith('http') && href.match(/\.(pdf|doc|docx|xls|xlsx|ppt|pptx|txt|csv|rtf|mp4|mp3|webm|wav|ogg|m4a|avi|mkv|mov|flv|png|jpg|jpeg|gif|svg|webp|avif|ico|bmp)(\?.*)?$/i)) {
+                mediaLinks.add(href);
+            }
+        });
+
+        // 3. Fallback: Check regex for embedded JSON or JS containing media/document links
+        const rawLinksMatch = html.match(/https?:\/\/[^\s"',]+\.(png|jpg|jpeg|gif|svg|webp|avif|ico|bmp|pdf|doc|docx|xls|xlsx|ppt|pptx|txt|csv|rtf|mp4|mp3|webm|wav|ogg|m4a|avi|mkv|mov|flv)/gi);
+        if (rawLinksMatch) {
+            for (const link of rawLinksMatch) {
+                mediaLinks.add(link);
+            }
+        }
+
+        return {
+            pageTitle,
+            mediaLinks: Array.from(mediaLinks)
+        };
+    }
+}

package/src/scrapers/web.ts

@@ -0,0 +1,64 @@
+import * as cheerio from 'cheerio';
+import { StrawClient, StrawClientOptions } from '../core/client';
+
+export interface WebScrapeResult {
+    title: string;
+    description: string;
+    text: string;
+    links: { text: string; href: string }[];
+    meta: Record<string, string>;
+}
+
+export class WebScraper {
+    private client: StrawClient;
+
+    constructor(options?: StrawClientOptions) {
+        this.client = new StrawClient(options);
+    }
+
+    /**
+     * Scrape a webpage and return structured data.
+     * Extracts title, generic text, metadata, and all links.
+     */
+    public async scrape(url: string): Promise<WebScrapeResult> {
+        const html = await this.client.getText(url);
+        const $ = cheerio.load(html);
+
+        const title = $('title').text().trim();
+        let description = $('meta[name="description"]').attr('content') || '';
+        
+        if (!description) {
+            description = $('meta[property="og:description"]').attr('content') || '';
+        }
+
+        const meta: Record<string, string> = {};
+        $('meta').each((_, el) => {
+            const name = $(el).attr('name') || $(el).attr('property');
+            const content = $(el).attr('content');
+            if (name && content) {
+                meta[name] = content;
+            }
+        });
+
+        const links: { text: string; href: string }[] = [];
+        $('a').each((_, el) => {
+            const href = $(el).attr('href');
+            const text = $(el).text().trim();
+            if (href && href.startsWith('http')) {
+                links.push({ text, href });
+            }
+        });
+
+        // Remove scripts and styles for cleaner text extraction
+        $('script, style, noscript, iframe, svg').remove();
+        const text = $('body').text().replace(/\s+/g, ' ').trim();
+
+        return {
+            title,
+            description,
+            text,
+            links,
+            meta
+        };
+    }
+}

package/src/scrapers/youtube.ts

@@ -0,0 +1,92 @@
+import { StrawClient, StrawClientOptions } from '../core/client';
+
+export interface YouTubeFormats {
+    url: string;
+    mimeType: string;
+    width?: number;
+    height?: number;
+    quality?: string;
+    bitrate?: number;
+    hasAudio: boolean;
+    hasVideo: boolean;
+}
+
+export interface YouTubeResult {
+    title: string;
+    author: string;
+    description: string;
+    views: string;
+    durationSeconds: string;
+    thumbnail: string;
+    formats: YouTubeFormats[];
+}
+
+export class YouTubeScraper {
+    private client: StrawClient;
+
+    constructor(options?: StrawClientOptions) {
+        this.client = new StrawClient(options);
+    }
+
+    /**
+     * Extracts YouTube video metadata and direct stream URLs without external bloatware.
+     * Parses the ytInitialPlayerResponse object embedded in the watch HTML.
+     */
+    public async scrapeVideo(url: string): Promise<YouTubeResult> {
+        const html = await this.client.getText(url, {
+            headers: {
+                'Cookie': 'CONSENT=YES+cb.20230501-14-p0.en+FX+430'
+            }
+        });
+        
+        // Find ytInitialPlayerResponse JSON fragment in the HTML
+        const regex = /ytInitialPlayerResponse\s*=\s*({.*?});(?:var|<\/script>)/;
+        const match = html.match(regex);
+        
+        if (!match || !match[1]) {
+            throw new Error('ytInitialPlayerResponse not found. YouTube might have changed their layout or the IP is blocked.');
+        }
+
+        const data = JSON.parse(match[1]);
+        const details = data?.videoDetails;
+        const streamingData = data?.streamingData;
+
+        if (!details) {
+            throw new Error('Video details not found inside player response.');
+        }
+
+        const formats: YouTubeFormats[] = [];
+        const rawFormats = [...(streamingData?.formats || []), ...(streamingData?.adaptiveFormats || [])];
+        
+        for (const format of rawFormats) {
+            if (format.url) {
+                const mimeType = format.mimeType || '';
+                formats.push({
+                    url: format.url,
+                    mimeType: mimeType,
+                    width: format.width,
+                    height: format.height,
+                    quality: format.qualityLabel || format.quality,
+                    bitrate: format.bitrate,
+                    hasAudio: mimeType.includes('audio/'),
+                    hasVideo: mimeType.includes('video/')
+                });
+            } else if (format.signatureCipher) {
+                // To avoid bloatware, we do not implement the complex decipher algorithm here.
+                // Modern APIs usually provide the URL directly for lower qualities or we can fallback to other APIs.
+                // Implementing decipher requires porting youtube-dl's sig logic or using ytdl-core.
+                continue;
+            }
+        }
+
+        return {
+            title: details.title || '',
+            author: details.author || '',
+            description: details.shortDescription || '',
+            views: details.viewCount || '0',
+            durationSeconds: details.lengthSeconds || '0',
+            thumbnail: details.thumbnail?.thumbnails?.[details.thumbnail.thumbnails.length - 1]?.url || '',
+            formats
+        };
+    }
+}

package/src/utils/helpers.ts

@@ -0,0 +1,17 @@
+export const USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 14.2; rv:109.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_2_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'
+];
+
+export function getRandomUserAgent(): string {
+    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+
+export function sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/straw/__init__.py

@@ -0,0 +1,11 @@
+from .client import StrawClient
+from .web import WebScraper
+from .youtube import YouTubeScraper
+from .media import MediaScraper
+
+__all__ = [
+    "StrawClient",
+    "WebScraper",
+    "YouTubeScraper",
+    "MediaScraper"
+]