xscrape 1.3.1 → 3.0.0

package/README.md

@@ -1,33 +1,20 @@
 # xscrape
 
-`xscrape` is a powerful and flexible library designed for extracting and
-transforming data from HTML documents using user-defined schemas. It integrates
-seamlessly with various schema validation libraries such as Zod, Yup, Joi, and
-Effect Schema, allowing you to use your preferred validation tool.
+`xscrape` is a powerful and flexible library designed for extracting and transforming data from HTML documents using user-defined schemas. It now supports any validation library that implements the **Standard Schema**, allowing you to bring your own schema for robust, type-safe data validation.
 
 ## Features
 
-- **HTML Parsing**: Extract data from HTML using CSS selectors with the help of
-  [cheerio](https://github.com/cheeriojs/cheerio).
-- **Schema Validation**: Validate and transform extracted data with schema validation libraries like [Zod](https://github.com/colinhacks/zod).
-- **Custom Transformations**: Provide custom transformations for extractedattributes.
-- **Default Values**: Define default values for missing data fields.
-- **Nested Field Support**: Define and extract nested data structures from
-  HTML elements.
+  * **HTML Parsing**: Extract data from HTML using CSS selectors with the help of [cheerio](https://github.com/cheeriojs/cheerio).
+  * **Flexible Schema Validation**: Validate and transform extracted data with any validation library that implements the [Standard Schema](https://standardschema.dev), such as Zod, Valibot, ArkType, and Effect Schema.
+  * **Custom Transformations**: Provide custom transformations for extracted attributes.
+  * **Default Values**: Define default values for missing data fields through your chosen schema library's features.
+  * **Nested Field Support**: Define and extract nested data structures from HTML elements.
 
-### Schema Support
-
-| Schema Library                                       | Status              | Notes                                                              |
-| ---------------------------------------------------- | ------------------- | ------------------------------------------------------------------ |
-| [Zod](https://github.com/colinhacks/zod)             | ✅ Supported        | Default schema tool for `xscrape`                                  |
-| [Effect/Schema](https://github.com/Effect-TS/effect) | ✅ Supported        | Support for Effect/Schema for additional flexibility               |
-| [Joi](https://github.com/sideway/joi)                | ✅ Supported        | Support for Joi for those familiar with server-side validation     |
-| [Yup](https://github.com/jquense/yup)                | 🚧 Planned          | Adding Yup support for schema validation in front-end applications |
-| Others...                                            | 🔄 In Consideration | Potential support for other schema tools as per user feedback      |
+-----
 
 ## Installation
 
-To install this library, use npm or yarn:
+To install this library, use your preferred package manager:
 
 ```bash
 pnpm add xscrape
@@ -35,142 +22,165 @@ pnpm add xscrape
 npm install xscrape
 ```
 
-## Usage
+You will also need to install your chosen schema validation library, for example, Zod:
 
-Below is an example of how to use xscrape for extracting and transforming data
-from an HTML document:
+```bash
+pnpm add zod
+# or
+npm install zod
+```
+
+-----
 
-1. Define Your Schema
+## Usage
+
+Below is an example of how to use `xscrape` with a Zod schema to extract and transform data from an HTML document.
 
 ```ts
+import { defineScraper } from 'xscrape';
 import { z } from 'zod';
 
-const schema = z.object({
-  title: z.string().default('No title'),
-  description: z.string(),
-  keywords: z.array(z.string()),
-  views: z.number(),
-  image: z
-    .object({
-      url: z.string(),
-      width: z.number(),
-      height: z.number(),
-    })
-    .default({ url: '', width: 0, height: 0 })
-    .optional(),
+const scraper = defineScraper({
+  schema: z.object({
+    title: z.string(),
+    description: z.string(),
+    keywords: z.array(z.string()),
+    views: z.coerce.number(),
+  }),
+  extract: {
+    title: {
+      selector: 'title',
+    },
+    description: {
+      selector: 'meta[name="description"]',
+      value: 'content',
+    },
+    keywords: {
+      selector: 'meta[name="keywords"]',
+      value(el) {
+        return el.attribs['content']?.split(',');
+      },
+    },
+    views: {
+      selector: 'meta[name="views"]',
+      value: 'content',
+    },
+  },
 });
-```
 
-2. Define Field Definitions
+const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta name="description" content="An example description.">
+  <meta name="keywords" content="typescript,html,parsing">
+  <meta name="views" content="1234">
+  <title>Example Title</title>
+</head>
+<body></body>
+</html>
+`;
+
+const { data, error } = await scraper(html);
+console.log(data);
 
-```ts
-import { type SchemaFieldDefinitions } from 'xscrape';
+// Outputs:
+// {
+//   title: 'Example Title',
+//   description: 'An example description.',
+//   keywords: ['typescript', 'html', 'parsing'],
+//   views: 1234
+// }
+```
 
-type FieldDefinitions = SchemaFieldDefinitions<z.infer<typeof schema>>;
+### Handling Missing Data
 
-const fields: FieldDefinitions = {
-  title: { selector: 'title' },
-  description: {
-    selector: 'meta[name="description"]',
-    attribute: 'content',
+You can handle missing data by using the features of your chosen schema library, such as default values in Zod.
 
-    defaultValue: 'No description',
-  },
-  keywords: {
-    selector: 'meta[name="keywords"]',
-    attribute: 'content',
-    transform: (value) => value.split(','),
-    defaultValue: [],
-  },
-  views: {
-    selector: 'meta[name="views"]',
-    attribute: 'content',
-    transform: (value) => parseInt(value, 10),
-    defaultValue: 0,
-  },
-  // Example of a nested field
-  image: {
-    fields: {
-      url: {
-        selector: 'meta[property="og:image"]',
-        attribute: 'content',
-      },
-      width: {
-        selector: 'meta[property="og:image:width"]',
-        attribute: 'content',
-        transform: (value) => parseInt(value, 10),
-      },
-      height: {
-        selector: 'meta[property="og:image:height"]',
-        attribute: 'content',
-        transform: (value) => parseInt(value, 10),
-      },
+```ts
+import { defineScraper } from 'xscrape';
+import { z } from 'zod';
+
+const scraper = defineScraper({
+  schema: z.object({
+    title: z.string().default('No title'),
+    description: z.string().default('No description'),
+    views: z.coerce.number().default(0),
+  }),
+  extract: {
+    title: {
+      selector: 'title',
+    },
+    description: {
+      selector: 'meta[name="description"]',
+      value: 'content',
+    },
+    views: {
+      selector: 'meta[name="views"]',
+      value: 'content',
     },
   },
-};
+});
 ```
 
-3. Create a Scraper and Extract Data
-
-```ts
-import { createScraper, ZodValidator } from 'xscrape';
+### Nested Fields
 
-const validator = new ZodValidator(schema);
-const scraper = createScraper({ fields, validator });
+`xscrape` also supports extracting nested data structures.
 
-const html = `
-   <!DOCTYPE html>
-   <html>
-   <head>
-     <meta name="description" content="An example description.">
-     <meta name="keywords" content="typescript,html,parsing">
-     <meta name="views" content="1234">
-     <meta property="og:image" content="https://example.se/images/c12ffe73-3227-4a4a-b8ad-a3003cdf1d70?h=708&amp;tight=false&amp;w=1372">
-     <meta property="og:image:width" content="1372">
-     <meta property="og:image:height" content="708">
-     <title>Example Title</title>
-   </head>
-   <body></body>
-   </html>
-   `;
-
-const data = scraper(html);
-console.log(data);
+```ts
+import { defineScraper } from 'xscrape';
+import { z } from 'zod';
 
-// Outputs:
-// {
-// title: 'Example Title',
-// description: 'An example description.',
-// keywords: ['typescript', 'html', 'parsing'],
-// views: 1234
-// image: {
-//   url: 'https://example.se/images/c12ffe73-3227-4a4a-b8ad-a3003cdf1d70?h=708&amp;tight=false&amp;w=1372',
-//   width: 1372,
-//   height: 708
-// }
-// }
+const scraper = defineScraper({
+  schema: z.object({
+    title: z.string(),
+    image: z.object({
+      url: z.string().url(),
+      width: z.coerce.number(),
+      height: z.coerce.number(),
+    }).default({ url: '', width: 0, height: 0 }).optional(),
+  }),
+  extract: {
+    title: {
+      selector: 'title',
+    },
+    image: {
+      selector: 'head',
+      value: {
+        url: {
+          selector: 'meta[property="og:image"]',
+          value: 'content',
+        },
+        width: {
+          selector: 'meta[property="og:image:width"]',
+          value: 'content',
+        },
+        height: {
+          selector: 'meta[property="og:image:height"]',
+          value: 'content',
+        },
+      },
+    },
+  },
+});
 ```
 
-## Configuration
-
-xscrape offers a range of configuration options through the types provided,
-allowing for detailed customization and robust data extraction and validation:
+-----
 
-- `SchemaFieldDefinitions`: Determines how fields are extracted from the HTML.
-- `SchemaValidator`: Validates the extracted data according to defined schemas.
+## Configuration
 
-## API Reference
+The `defineScraper` function accepts a configuration object with the following properties:
 
-- `createScraper(config: ScrapeConfig): (html: string) => T` Creates a scraping function based on the specified fields and validator.
-- `ZodValidator` A built-in validator using Zod, allowing you to define schemas andvalidate data effortlessly.
+  * **`schema`**: A schema object from any library that implements the [Standard Schema](https://standardschema.dev) interface. This schema defines the shape and validation rules for the extracted data.
+  * **`extract`**: An object that determines how fields are extracted from the HTML using CSS selectors.
+  * **`transform`** (optional): A function to apply custom transformations to the validated data.
 
-For a complete list of API methods and more advanced configuration options,refer to the documentation on the project homepage https://github.com/johnie/xscrape.
+-----
 
 ## Contributing
 
-Contributions are welcome! Please see the Contributing Guide https://github.com/johnie/xscrape/blob/main/CONTRIBUTING.md for more information.
+Contributions are welcome\! Please see the [Contributing Guide](https://github.com/johnie/xscrape/blob/main/CONTRIBUTING.md) for more information.
 
 ## License
 
-This project is licensed under the MIT License. See the LICENSE
-https://github.com/johnie/xscrape/blob/main/LICENSE file for details.
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/johnie/xscrape/blob/main/LICENSE) file for details.

package/dist/index.cjs

@@ -28,110 +28,49 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  EffectValidator: () => EffectValidator,
-  JoiValidator: () => JoiValidator,
-  ZodValidator: () => ZodValidator,
-  createScraper: () => createScraper
+var index_exports = {};
+__export(index_exports, {
+  defineScraper: () => defineScraper
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
-// src/createScraper.ts
+// src/defineScraper.ts
 var cheerio = __toESM(require("cheerio"), 1);
-var extractData = (fields, $context) => {
-  const data = {};
-  for (const key in fields) {
-    const fieldDef = fields[key];
-    if ("fields" in fieldDef) {
-      const nestedData = extractData(
-        fieldDef.fields,
-        $context
+function defineScraper(config) {
+  return async (html) => {
+    try {
+      const $ = cheerio.load(html);
+      const extractedData = $.extract(config.extract);
+      const validationResult = await Promise.resolve(
+        config.schema["~standard"].validate(extractedData)
       );
-      data[key] = nestedData;
-    } else {
-      const elements = $context(fieldDef.selector);
-      let values = [];
-      elements.each((_, element) => {
-        const value = fieldDef.attribute ? $context(element).attr(fieldDef.attribute) : $context(element).text().trim();
-        if (value !== void 0) {
-          values.push(value);
+      if (validationResult.issues) {
+        return { error: validationResult.issues };
+      }
+      if (!("value" in validationResult)) {
+        return {
+          error: new Error(
+            "xscrape: Validation succeeded but no data was returned"
+          )
+        };
+      }
+      if (config.transform) {
+        try {
+          const transformed = await Promise.resolve(
+            config.transform(validationResult.value)
+          );
+          return { data: transformed };
+        } catch (error) {
+          return { error };
         }
-      });
-      if (values.length === 0 && fieldDef.defaultValue !== void 0) {
-        data[key] = fieldDef.defaultValue;
-      } else if (fieldDef.multiple) {
-        data[key] = values.map(
-          (value) => fieldDef.transform ? fieldDef.transform(value) : value
-        );
-      } else {
-        const value = values[0];
-        data[key] = fieldDef.transform && value ? fieldDef.transform(value) : value;
       }
+      return { data: validationResult.value };
+    } catch (error) {
+      return { error };
     }
-  }
-  return data;
-};
-var createScraper = ({
-  fields,
-  validator
-}) => {
-  return (html) => {
-    const $ = typeof html === "string" ? cheerio.load(html) : html;
-    const data = extractData(fields, $);
-    return validator.validate(data);
   };
-};
-
-// src/validators/effect.ts
-var Schema = __toESM(require("effect/Schema"), 1);
-var import_effect = require("effect");
-var EffectValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    const result = Schema.decodeUnknown(this.schema)(data);
-    return import_effect.Effect.runSync(result);
-  }
-};
-
-// src/validators/zod.ts
-var import_zod = require("zod");
-var ZodValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    return this.schema.parse(data);
-  }
-};
-
-// src/validators/joi.ts
-var JoiValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    const { error, value } = this.schema.validate(data, {
-      convert: true,
-      stripUnknown: true,
-      presence: "optional",
-      abortEarly: false
-    });
-    if (error) {
-      throw new Error(this.formatError(error));
-    }
-    return value;
-  }
-  formatError(error) {
-    return error.details.map((detail) => detail.message).join("\n");
-  }
-};
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  EffectValidator,
-  JoiValidator,
-  ZodValidator,
-  createScraper
+  defineScraper
 });

package/dist/index.d.cts

@@ -1,48 +1,31 @@
-import * as cheerio from 'cheerio';
-import * as Schema from 'effect/Schema';
-import { ZodSchema } from 'zod';
-import { Schema as Schema$1 } from 'joi';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Element } from 'domhandler';
 
-type ScrapeConfig<T> = {
-    fields: SchemaFieldDefinitions<T>;
-    validator: SchemaValidator<T>;
-};
-type FieldDefinition<T> = {
+type ExtractDescriptorFn = (el: Element, key: string, obj: Record<string, unknown>) => unknown;
+interface ExtractDescriptor {
     selector: string;
-    attribute?: string;
-    transform?: (value: string) => T;
-    defaultValue?: T;
-    multiple?: boolean;
-} | NestedFieldDefinition<T>;
-type NestedFieldDefinition<T> = {
-    fields: SchemaFieldDefinitions<T>;
-};
-type SchemaFieldDefinitions<T> = {
-    [K in keyof T]: FieldDefinition<T[K]>;
-};
-interface SchemaValidator<T> {
-    validate(data: unknown): T;
+    value?: string | ExtractDescriptorFn | ExtractMap;
 }
-
-declare const createScraper: <T>({ fields, validator, }: ScrapeConfig<T>) => ((html: cheerio.CheerioAPI | string) => T);
-
-declare class EffectValidator<A, I = A> implements SchemaValidator<A> {
-    private schema;
-    constructor(schema: Schema.Schema<A, I>);
-    validate(data: unknown): A;
+type ExtractValue = string | ExtractDescriptor | [string | ExtractDescriptor];
+interface ExtractMap {
+    [key: string]: ExtractValue;
 }
 
-declare class ZodValidator<T> implements SchemaValidator<T> {
-    private schema;
-    constructor(schema: ZodSchema<T>);
-    validate(data: unknown): T;
-}
+type ScraperConfig<S extends StandardSchemaV1<any, any>, R extends StandardSchemaV1.InferOutput<S> = StandardSchemaV1.InferOutput<S>> = {
+    schema: S;
+    extract: ExtractMap;
+    transform?: (data: StandardSchemaV1.InferOutput<S>) => Promise<R> | R;
+};
+type ValidationResult<T> = {
+    success: boolean;
+    data?: T;
+    error?: unknown;
+};
+type ScraperResult<T> = {
+    data?: T;
+    error?: unknown;
+};
 
-declare class JoiValidator<T> implements SchemaValidator<T> {
-    private schema;
-    constructor(schema: Schema$1<T>);
-    validate(data: unknown): T;
-    private formatError;
-}
+declare function defineScraper<S extends StandardSchemaV1, R extends StandardSchemaV1.InferOutput<S> = StandardSchemaV1.InferOutput<S>>(config: ScraperConfig<S, R>): (html: string) => Promise<ScraperResult<R>>;
 
-export { EffectValidator, type FieldDefinition, JoiValidator, type SchemaFieldDefinitions, type SchemaValidator, type ScrapeConfig, ZodValidator, createScraper };
+export { type ScraperConfig, type ScraperResult, type ValidationResult, defineScraper };

package/dist/index.d.ts

@@ -1,48 +1,31 @@
-import * as cheerio from 'cheerio';
-import * as Schema from 'effect/Schema';
-import { ZodSchema } from 'zod';
-import { Schema as Schema$1 } from 'joi';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Element } from 'domhandler';
 
-type ScrapeConfig<T> = {
-    fields: SchemaFieldDefinitions<T>;
-    validator: SchemaValidator<T>;
-};
-type FieldDefinition<T> = {
+type ExtractDescriptorFn = (el: Element, key: string, obj: Record<string, unknown>) => unknown;
+interface ExtractDescriptor {
     selector: string;
-    attribute?: string;
-    transform?: (value: string) => T;
-    defaultValue?: T;
-    multiple?: boolean;
-} | NestedFieldDefinition<T>;
-type NestedFieldDefinition<T> = {
-    fields: SchemaFieldDefinitions<T>;
-};
-type SchemaFieldDefinitions<T> = {
-    [K in keyof T]: FieldDefinition<T[K]>;
-};
-interface SchemaValidator<T> {
-    validate(data: unknown): T;
+    value?: string | ExtractDescriptorFn | ExtractMap;
 }
-
-declare const createScraper: <T>({ fields, validator, }: ScrapeConfig<T>) => ((html: cheerio.CheerioAPI | string) => T);
-
-declare class EffectValidator<A, I = A> implements SchemaValidator<A> {
-    private schema;
-    constructor(schema: Schema.Schema<A, I>);
-    validate(data: unknown): A;
+type ExtractValue = string | ExtractDescriptor | [string | ExtractDescriptor];
+interface ExtractMap {
+    [key: string]: ExtractValue;
 }
 
-declare class ZodValidator<T> implements SchemaValidator<T> {
-    private schema;
-    constructor(schema: ZodSchema<T>);
-    validate(data: unknown): T;
-}
+type ScraperConfig<S extends StandardSchemaV1<any, any>, R extends StandardSchemaV1.InferOutput<S> = StandardSchemaV1.InferOutput<S>> = {
+    schema: S;
+    extract: ExtractMap;
+    transform?: (data: StandardSchemaV1.InferOutput<S>) => Promise<R> | R;
+};
+type ValidationResult<T> = {
+    success: boolean;
+    data?: T;
+    error?: unknown;
+};
+type ScraperResult<T> = {
+    data?: T;
+    error?: unknown;
+};
 
-declare class JoiValidator<T> implements SchemaValidator<T> {
-    private schema;
-    constructor(schema: Schema$1<T>);
-    validate(data: unknown): T;
-    private formatError;
-}
+declare function defineScraper<S extends StandardSchemaV1, R extends StandardSchemaV1.InferOutput<S> = StandardSchemaV1.InferOutput<S>>(config: ScraperConfig<S, R>): (html: string) => Promise<ScraperResult<R>>;
 
-export { EffectValidator, type FieldDefinition, JoiValidator, type SchemaFieldDefinitions, type SchemaValidator, type ScrapeConfig, ZodValidator, createScraper };
+export { type ScraperConfig, type ScraperResult, type ValidationResult, defineScraper };

package/dist/index.js

@@ -1,97 +1,39 @@
-// src/createScraper.ts
+// src/defineScraper.ts
 import * as cheerio from "cheerio";
-var extractData = (fields, $context) => {
-  const data = {};
-  for (const key in fields) {
-    const fieldDef = fields[key];
-    if ("fields" in fieldDef) {
-      const nestedData = extractData(
-        fieldDef.fields,
-        $context
+function defineScraper(config) {
+  return async (html) => {
+    try {
+      const $ = cheerio.load(html);
+      const extractedData = $.extract(config.extract);
+      const validationResult = await Promise.resolve(
+        config.schema["~standard"].validate(extractedData)
       );
-      data[key] = nestedData;
-    } else {
-      const elements = $context(fieldDef.selector);
-      let values = [];
-      elements.each((_, element) => {
-        const value = fieldDef.attribute ? $context(element).attr(fieldDef.attribute) : $context(element).text().trim();
-        if (value !== void 0) {
-          values.push(value);
+      if (validationResult.issues) {
+        return { error: validationResult.issues };
+      }
+      if (!("value" in validationResult)) {
+        return {
+          error: new Error(
+            "xscrape: Validation succeeded but no data was returned"
+          )
+        };
+      }
+      if (config.transform) {
+        try {
+          const transformed = await Promise.resolve(
+            config.transform(validationResult.value)
+          );
+          return { data: transformed };
+        } catch (error) {
+          return { error };
         }
-      });
-      if (values.length === 0 && fieldDef.defaultValue !== void 0) {
-        data[key] = fieldDef.defaultValue;
-      } else if (fieldDef.multiple) {
-        data[key] = values.map(
-          (value) => fieldDef.transform ? fieldDef.transform(value) : value
-        );
-      } else {
-        const value = values[0];
-        data[key] = fieldDef.transform && value ? fieldDef.transform(value) : value;
       }
+      return { data: validationResult.value };
+    } catch (error) {
+      return { error };
     }
-  }
-  return data;
-};
-var createScraper = ({
-  fields,
-  validator
-}) => {
-  return (html) => {
-    const $ = typeof html === "string" ? cheerio.load(html) : html;
-    const data = extractData(fields, $);
-    return validator.validate(data);
   };
-};
-
-// src/validators/effect.ts
-import * as Schema from "effect/Schema";
-import { Effect } from "effect";
-var EffectValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    const result = Schema.decodeUnknown(this.schema)(data);
-    return Effect.runSync(result);
-  }
-};
-
-// src/validators/zod.ts
-import "zod";
-var ZodValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    return this.schema.parse(data);
-  }
-};
-
-// src/validators/joi.ts
-var JoiValidator = class {
-  constructor(schema) {
-    this.schema = schema;
-  }
-  validate(data) {
-    const { error, value } = this.schema.validate(data, {
-      convert: true,
-      stripUnknown: true,
-      presence: "optional",
-      abortEarly: false
-    });
-    if (error) {
-      throw new Error(this.formatError(error));
-    }
-    return value;
-  }
-  formatError(error) {
-    return error.details.map((detail) => detail.message).join("\n");
-  }
-};
+}
 export {
-  EffectValidator,
-  JoiValidator,
-  ZodValidator,
-  createScraper
+  defineScraper
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xscrape",
-  "version": "1.3.1",
+  "version": "3.0.0",
   "description": "A flexible and powerful library designed to extract and transform data from HTML documents using user-defined schemas",
   "main": "dist/index.js",
   "exports": {
@@ -39,26 +39,31 @@
   },
   "homepage": "https://github.com/johnie/xscrape#readme",
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.16.4",
-    "@changesets/changelog-github": "^0.5.0",
-    "@changesets/cli": "^2.27.9",
-    "prettier": "^3.3.3",
-    "tsup": "^8.3.5",
-    "typescript": "^5.6.3",
-    "vite": "^5.4.10",
-    "vitest": "^2.1.3"
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@changesets/changelog-github": "^0.5.1",
+    "@changesets/cli": "^2.29.5",
+    "arktype": "^2.1.20",
+    "effect": "^3.16.12",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "valibot": "^1.1.0",
+    "vite": "^7.0.4",
+    "vitest": "^3.2.4",
+    "zod": "^4.0.2"
   },
   "dependencies": {
-    "cheerio": "^1.0.0",
-    "effect": "^3.10.4",
-    "joi": "^17.13.3",
-    "zod": "^3.23.8"
+    "@standard-schema/spec": "^1.0.0",
+    "cheerio": "^1.1.0",
+    "domhandler": "^5.0.3"
   },
   "scripts": {
     "build": "tsup",
     "ci": "npm run build && npm run check-format && npm run check-exports && npm run lint && npm run test",
     "lint": "tsc",
     "test": "vitest run",
+    "test:watch": "vitest",
     "format": "prettier --write ./src",
     "check-format": "prettier --check ./src",
     "check-exports": "attw --pack .",