@regexto/validators 1.0.0

package/dist/zod.d.mts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { RegexPattern } from './index.mjs';
+
+type ZodStringSchema = z.ZodString;
+/**
+ * Returns a Zod string schema with the regex validator applied.
+ *
+ * @example
+ * import { zodSchema } from '@regex.to/validators/zod';
+ * const emailSchema = zodSchema('email');
+ * emailSchema.parse('user@example.com'); // ✓
+ */
+declare function zodSchema(slug: string, message?: string): ZodStringSchema;
+/**
+ * Returns a full Zod object schema from a map of field → pattern slug.
+ *
+ * @example
+ * const schema = zodObjectSchema({ email: 'email', website: 'url' });
+ */
+declare function zodObjectSchema(fieldMap: Record<string, string>, messages?: Record<string, string>): z.ZodObject<Record<string, ZodStringSchema>>;
+/**
+ * Returns the pattern definition along with its Zod schema.
+ */
+declare function getPatternWithSchema(slug: string): {
+    pattern: RegexPattern;
+    schema: ZodStringSchema;
+};
+
+export { getPatternWithSchema, zodObjectSchema, zodSchema };

package/dist/zod.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { RegexPattern } from './index.js';
+
+type ZodStringSchema = z.ZodString;
+/**
+ * Returns a Zod string schema with the regex validator applied.
+ *
+ * @example
+ * import { zodSchema } from '@regex.to/validators/zod';
+ * const emailSchema = zodSchema('email');
+ * emailSchema.parse('user@example.com'); // ✓
+ */
+declare function zodSchema(slug: string, message?: string): ZodStringSchema;
+/**
+ * Returns a full Zod object schema from a map of field → pattern slug.
+ *
+ * @example
+ * const schema = zodObjectSchema({ email: 'email', website: 'url' });
+ */
+declare function zodObjectSchema(fieldMap: Record<string, string>, messages?: Record<string, string>): z.ZodObject<Record<string, ZodStringSchema>>;
+/**
+ * Returns the pattern definition along with its Zod schema.
+ */
+declare function getPatternWithSchema(slug: string): {
+    pattern: RegexPattern;
+    schema: ZodStringSchema;
+};
+
+export { getPatternWithSchema, zodObjectSchema, zodSchema };

package/dist/zod.js

@@ -0,0 +1,81 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zod.ts
+var zod_exports = {};
+__export(zod_exports, {
+  getPatternWithSchema: () => getPatternWithSchema,
+  zodObjectSchema: () => zodObjectSchema,
+  zodSchema: () => zodSchema
+});
+module.exports = __toCommonJS(zod_exports);
+var import_zod = require("zod");
+
+// src/index.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function loadPatterns() {
+  const dir = import_path.default.join(__dirname, "..", "patterns");
+  const result = {};
+  try {
+    const files = import_fs.default.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const raw = import_fs.default.readFileSync(import_path.default.join(dir, file), "utf-8");
+      const p = JSON.parse(raw);
+      result[p.slug] = p;
+    }
+  } catch {
+  }
+  return result;
+}
+var PATTERNS = loadPatterns();
+
+// src/zod.ts
+function zodSchema(slug, message) {
+  const p = PATTERNS[slug];
+  if (!p) throw new Error(`Pattern "${slug}" not found in @regex.to/validators`);
+  const regex = new RegExp(`^(?:${p.pattern})$`, p.flags);
+  return import_zod.z.string().regex(regex, message ?? `Invalid ${p.name}`);
+}
+function zodObjectSchema(fieldMap, messages) {
+  const shape = {};
+  for (const [field, slug] of Object.entries(fieldMap)) {
+    shape[field] = zodSchema(slug, messages?.[field]);
+  }
+  return import_zod.z.object(shape);
+}
+function getPatternWithSchema(slug) {
+  return { pattern: PATTERNS[slug], schema: zodSchema(slug) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPatternWithSchema,
+  zodObjectSchema,
+  zodSchema
+});

package/dist/zod.mjs

@@ -0,0 +1,27 @@
+import {
+  PATTERNS
+} from "./chunk-DL6DNLHZ.mjs";
+
+// src/zod.ts
+import { z } from "zod";
+function zodSchema(slug, message) {
+  const p = PATTERNS[slug];
+  if (!p) throw new Error(`Pattern "${slug}" not found in @regex.to/validators`);
+  const regex = new RegExp(`^(?:${p.pattern})$`, p.flags);
+  return z.string().regex(regex, message ?? `Invalid ${p.name}`);
+}
+function zodObjectSchema(fieldMap, messages) {
+  const shape = {};
+  for (const [field, slug] of Object.entries(fieldMap)) {
+    shape[field] = zodSchema(slug, messages?.[field]);
+  }
+  return z.object(shape);
+}
+function getPatternWithSchema(slug) {
+  return { pattern: PATTERNS[slug], schema: zodSchema(slug) };
+}
+export {
+  getPatternWithSchema,
+  zodObjectSchema,
+  zodSchema
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@regexto/validators",
+  "version": "1.0.0",
+  "description": "A curated collection of battle-tested regex patterns with TypeScript types, Zod integration, and multi-language code generation.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./zod": {
+      "types": "./dist/zod.d.ts",
+      "import": "./dist/zod.mjs",
+      "require": "./dist/zod.js"
+    }
+  },
+  "files": [
+    "dist",
+    "patterns"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/zod.ts --format cjs,esm --dts --clean --shims",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch --shims",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "regex",
+    "validation",
+    "typescript",
+    "zod",
+    "validators",
+    "patterns"
+  ],
+  "author": "regex.to",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/regex-to/validators"
+  },
+  "homepage": "https://regex.to",
+  "peerDependencies": {
+    "zod": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3"
+  }
+}

package/patterns/au-abn.json

@@ -0,0 +1,15 @@
+{
+  "slug": "au-abn",
+  "name": "Australian ABN",
+  "description": "Matches an Australian Business Number (ABN) — 11 digits, optionally space-separated in groups.",
+  "category": "Identity",
+  "pattern": "\\d{2}\\s?\\d{3}\\s?\\d{3}\\s?\\d{3}",
+  "flags": "",
+  "examples": ["51 824 753 556", "51824753556", "12 345 678 901"],
+  "counterExamples": ["51 824 753", "518247535561", "AB 824 753 556"],
+  "locales": ["en-AU"],
+  "tags": ["abn", "australia", "australian", "business", "tax"],
+  "useCases": ["Australian business forms", "GST invoicing", "Tax reporting"],
+  "seoTitle": "Australian ABN Regex — Validate Business Numbers",
+  "seoDescription": "Regex for Australian Business Number (ABN) validation."
+}

package/patterns/base64.json

@@ -0,0 +1,14 @@
+{
+  "slug": "base64",
+  "name": "Base64 Encoded String",
+  "description": "Matches a valid Base64-encoded string with proper padding using = characters.",
+  "category": "Security",
+  "pattern": "^(?:[A-Za-z0-9+\\/]{4})*(?:[A-Za-z0-9+\\/]{2}==|[A-Za-z0-9+\\/]{3}=)?$",
+  "flags": "",
+  "examples": ["SGVsbG8gV29ybGQ=", "dGVzdA==", "YWJjZGVmZ2g="],
+  "counterExamples": ["SGVsbG8gV29ybGQ", "not!base64@string", "YWJjZGVmZ2g==="],
+  "tags": ["base64", "encoding", "data"],
+  "useCases": ["File upload validation", "API token parsing", "Image data URIs"],
+  "seoTitle": "Base64 Regex — Validate Base64 Encoding in JS, Go, PHP",
+  "seoDescription": "Regex for Base64 string validation with proper padding."
+}

package/patterns/bech32-address.json

@@ -0,0 +1,14 @@
+{
+  "slug": "bech32-address",
+  "name": "Bitcoin Bech32 Address (SegWit)",
+  "description": "Matches a Bitcoin native SegWit address in Bech32 format — starts with bc1 followed by 6–87 lowercase alphanumeric characters.",
+  "category": "Crypto",
+  "pattern": "bc1[ac-hj-np-z02-9]{6,87}",
+  "flags": "i",
+  "examples": ["bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq", "bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08ge52"],
+  "counterExamples": ["1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2", "0xde0B295669a9FD93d5F28D9Ec85E40f4", "bc1short"],
+  "tags": ["bitcoin", "btc", "bech32", "segwit", "p2wpkh", "crypto"],
+  "useCases": ["Bitcoin wallet validation", "Payment processors", "Crypto exchanges"],
+  "seoTitle": "Bech32 Bitcoin Address Regex — Validate SegWit Addresses",
+  "seoDescription": "Regex for Bitcoin Bech32 (bc1) native SegWit address validation."
+}

package/patterns/bitcoin-address.json

@@ -0,0 +1,14 @@
+{
+  "slug": "bitcoin-address",
+  "name": "Bitcoin Address (Legacy)",
+  "description": "Matches a legacy Bitcoin address — P2PKH (starting with 1) or P2SH (starting with 3), 25–34 Base58 characters.",
+  "category": "Crypto",
+  "pattern": "[13][a-km-zA-HJ-NP-Z1-9]{25,34}",
+  "flags": "",
+  "examples": ["1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2", "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy"],
+  "counterExamples": ["0BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2", "1BvBMSEYstWetq", "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2_extra"],
+  "tags": ["bitcoin", "btc", "crypto", "address", "blockchain"],
+  "useCases": ["Crypto payment validation", "Wallet address input", "Transaction verification"],
+  "seoTitle": "Bitcoin Address Regex — Validate BTC Addresses",
+  "seoDescription": "Regex for Bitcoin legacy address validation (P2PKH and P2SH)."
+}

package/patterns/br-cnpj.json

@@ -0,0 +1,15 @@
+{
+  "slug": "br-cnpj",
+  "name": "Brazilian CNPJ",
+  "description": "Matches a Brazilian CNPJ (Cadastro Nacional da Pessoa Jurídica) — company identifier in formatted or unformatted form.",
+  "category": "Identity",
+  "pattern": "\\d{2}\\.?\\d{3}\\.?\\d{3}\\/?\\d{4}-?\\d{2}",
+  "flags": "",
+  "examples": ["11.222.333/0001-81", "11222333000181"],
+  "counterExamples": ["11.222.333/0001", "11.222.333/0001-8", "AB.222.333/0001-81"],
+  "locales": ["pt-BR"],
+  "tags": ["cnpj", "brazil", "company", "business", "tax"],
+  "useCases": ["Brazilian B2B forms", "Invoice validation", "Company registration"],
+  "seoTitle": "Brazilian CNPJ Regex — Validate CNPJ Numbers",
+  "seoDescription": "Regex for Brazilian CNPJ company identifier validation."
+}

package/patterns/br-cpf.json

@@ -0,0 +1,15 @@
+{
+  "slug": "br-cpf",
+  "name": "Brazilian CPF",
+  "description": "Matches a Brazilian CPF (Cadastro de Pessoas Físicas) number in formatted (NNN.NNN.NNN-NN) or unformatted (NNNNNNNNNNN) form.",
+  "category": "Identity",
+  "pattern": "\\d{3}\\.?\\d{3}\\.?\\d{3}-?\\d{2}",
+  "flags": "",
+  "examples": ["123.456.789-09", "12345678909", "111.444.777-35"],
+  "counterExamples": ["123.456.789", "1234567890", "abc.456.789-09"],
+  "locales": ["pt-BR"],
+  "tags": ["cpf", "brazil", "brazilian", "identity", "tax"],
+  "useCases": ["Brazilian government forms", "E-commerce checkout", "KYC verification"],
+  "seoTitle": "Brazilian CPF Regex — Validate CPF Numbers",
+  "seoDescription": "Regex for Brazilian CPF number validation. Supports formatted and unformatted input."
+}

package/patterns/cn-resident-id.json

@@ -0,0 +1,15 @@
+{
+  "slug": "cn-resident-id",
+  "name": "Chinese Resident ID",
+  "description": "Matches a Chinese national resident identity card number — 17 digits followed by one digit or X (checksum digit).",
+  "category": "Identity",
+  "pattern": "\\d{17}[\\dXx]",
+  "flags": "",
+  "examples": ["11010519491231002X", "440301198001012158"],
+  "counterExamples": ["11010519491231002", "1101051949123100200", "1101051949123100Y"],
+  "locales": ["zh-CN"],
+  "tags": ["china", "chinese", "resident-id", "identity", "idcard"],
+  "useCases": ["Chinese government integration", "KYC for Chinese users", "Travel booking"],
+  "seoTitle": "Chinese Resident ID Regex — Validate 身份证号",
+  "seoDescription": "Regex for Chinese national resident identity card number (18 characters) validation."
+}

package/patterns/coordinates.json

@@ -0,0 +1,14 @@
+{
+  "slug": "coordinates",
+  "name": "GPS Coordinates",
+  "description": "Matches a latitude,longitude coordinate pair separated by a comma.",
+  "category": "Geo",
+  "pattern": "-?([0-8]?\\d(\\.\\d+)?|90(\\.0+)?)\\s*,\\s*-?(1[0-7]\\d(\\.\\d+)?|[0-9]?\\d(\\.\\d+)?|180(\\.0+)?)",
+  "flags": "",
+  "examples": ["51.5074,-0.1278", "40.7128, -74.0060", "-33.8688, 151.2093"],
+  "counterExamples": ["91.0,-0.1278", "51.5074,-181.0", "abc,def"],
+  "tags": ["coordinates", "gps", "geo", "location", "lat-lng"],
+  "useCases": ["Map input fields", "Geofencing", "Delivery address parsing"],
+  "seoTitle": "GPS Coordinates Regex — Validate Lat/Lng Pairs",
+  "seoDescription": "Regex for GPS coordinate pair (latitude, longitude) validation."
+}

package/patterns/credit-card.json

@@ -0,0 +1,14 @@
+{
+  "slug": "credit-card",
+  "name": "Credit Card Number",
+  "description": "Generic credit card number validator supporting Visa, Mastercard, American Express, and Discover card formats.",
+  "category": "Finance",
+  "pattern": "(?:4[0-9]{12}(?:[0-9]{3})?|[25][1-7][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\\d{3})\\d{11})",
+  "flags": "",
+  "examples": ["4111111111111111", "5500005555555559", "371449635398431"],
+  "counterExamples": ["1234567890123456", "411111111111", "0000000000000000"],
+  "tags": ["payment", "credit-card", "finance", "visa", "mastercard", "amex"],
+  "useCases": ["Payment form validation", "E-commerce checkout", "Subscription billing"],
+  "seoTitle": "Credit Card Regex — Validate Card Numbers in JS, Go, PHP",
+  "seoDescription": "Regex for validating Visa, Mastercard, Amex, and Discover credit card numbers. Generate code for JavaScript, Go, PHP."
+}

package/patterns/crypto-mnemonic-word.json

@@ -0,0 +1,17 @@
+{
+  "slug": "crypto-mnemonic-word",
+  "name": "BIP-39 Mnemonic Phrase",
+  "description": "Matches a BIP-39 mnemonic seed phrase — 12, 15, 18, 21, or 24 lowercase English words separated by single spaces.",
+  "category": "Crypto",
+  "pattern": "^([a-z]+\\s){11,23}[a-z]+$",
+  "flags": "",
+  "examples": [
+    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+    "zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"
+  ],
+  "counterExamples": ["abandon abandon", "ABANDON ABANDON ABANDON", "abandon  double-space"],
+  "tags": ["bip39", "mnemonic", "seed", "wallet", "crypto", "recovery"],
+  "useCases": ["Wallet backup verification", "Seed phrase format validation", "Crypto onboarding"],
+  "seoTitle": "BIP-39 Mnemonic Regex — Validate Seed Phrases",
+  "seoDescription": "Regex for BIP-39 mnemonic seed phrase format validation (12–24 words)."
+}

package/patterns/date-eu.json

@@ -0,0 +1,14 @@
+{
+  "slug": "date-eu",
+  "name": "Date (European Format)",
+  "description": "Matches a European-style date in DD/MM/YYYY, DD.MM.YYYY, or DD-MM-YYYY format.",
+  "category": "Date & Time",
+  "pattern": "(0?[1-9]|[12]\\d|3[01])[.\\-\\/](0?[1-9]|1[0-2])[.\\-\\/](\\d{4})",
+  "flags": "",
+  "examples": ["15/01/2024", "31.12.1999", "7-3-2024"],
+  "counterExamples": ["01/13/2024", "00/15/2024", "2024/01/15"],
+  "tags": ["date", "european", "dd/mm/yyyy", "eu"],
+  "useCases": ["European forms", "Date input validation", "Localized apps"],
+  "seoTitle": "European Date Format Regex — Validate DD/MM/YYYY in JS, Go, PHP",
+  "seoDescription": "Regex for European date DD/MM/YYYY, DD.MM.YYYY, DD-MM-YYYY formats."
+}

package/patterns/date-us.json

@@ -0,0 +1,14 @@
+{
+  "slug": "date-us",
+  "name": "Date (US Format)",
+  "description": "Matches a US-style date in MM/DD/YYYY format.",
+  "category": "Date & Time",
+  "pattern": "(0?[1-9]|1[0-2])\\/(0?[1-9]|[12]\\d|3[01])\\/(\\d{4})",
+  "flags": "",
+  "examples": ["01/15/2024", "12/31/1999", "3/7/2024"],
+  "counterExamples": ["13/01/2024", "00/15/2024", "2024/01/15", "15/01/2024"],
+  "tags": ["date", "us", "mm/dd/yyyy", "american"],
+  "useCases": ["US address forms", "American date input fields", "Legacy system integration"],
+  "seoTitle": "US Date Format Regex — Validate MM/DD/YYYY in JS, Go, PHP",
+  "seoDescription": "Regex for US date format MM/DD/YYYY validation."
+}

package/patterns/datetime-iso.json

@@ -0,0 +1,14 @@
+{
+  "slug": "datetime-iso",
+  "name": "ISO 8601 DateTime",
+  "description": "Matches an ISO 8601 datetime string with timezone offset or Z (UTC).",
+  "category": "Date & Time",
+  "pattern": "\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})",
+  "flags": "",
+  "examples": ["2024-01-15T10:30:00Z", "2024-01-15T10:30:00.000Z", "2024-01-15T10:30:00+02:00"],
+  "counterExamples": ["2024-01-15 10:30:00", "2024-01-15T10:30:00", "not-a-date"],
+  "tags": ["iso8601", "datetime", "timestamp", "utc"],
+  "useCases": ["API request/response validation", "Database timestamp parsing", "Log file parsing"],
+  "seoTitle": "ISO 8601 DateTime Regex — Validate Timestamps in JS, Go, PHP",
+  "seoDescription": "Regex for ISO 8601 datetime with timezone. Covers Z and ±HH:MM offsets."
+}

package/patterns/de-plz.json

@@ -0,0 +1,15 @@
+{
+  "slug": "de-plz",
+  "name": "German Postal Code (PLZ)",
+  "description": "Matches a German postal code (Postleitzahl / PLZ) — exactly 5 digits.",
+  "category": "Address",
+  "pattern": "\\d{5}",
+  "flags": "",
+  "examples": ["10115", "80331", "20095", "01067"],
+  "counterExamples": ["1234", "123456", "A1234"],
+  "locales": ["de"],
+  "tags": ["plz", "postal", "germany", "german", "address"],
+  "useCases": ["German address forms", "Delivery validation", "Tax region determination"],
+  "seoTitle": "German PLZ Regex — Validate German Postal Codes",
+  "seoDescription": "Regex for German postal code (PLZ) validation — 5 digits."
+}

package/patterns/de-steuerid.json

@@ -0,0 +1,15 @@
+{
+  "slug": "de-steuerid",
+  "name": "German Tax ID (Steuer-IdNr)",
+  "description": "Matches a German personal tax identification number (Steuerliche Identifikationsnummer) — 11 digits, first digit 1–9.",
+  "category": "Identity",
+  "pattern": "[1-9]\\d{10}",
+  "flags": "",
+  "examples": ["12345678901", "98765432109"],
+  "counterExamples": ["0123456789", "1234567890", "1234567890A"],
+  "locales": ["de"],
+  "tags": ["steuerid", "germany", "german", "tax", "identity"],
+  "useCases": ["German tax forms", "Payroll systems", "ELSTER integration"],
+  "seoTitle": "German Tax ID Regex — Validate Steuer-IdNr",
+  "seoDescription": "Regex for German personal tax identification number (Steuer-IdNr) validation."
+}

package/patterns/domain.json

@@ -0,0 +1,14 @@
+{
+  "slug": "domain",
+  "name": "Domain Name",
+  "description": "Matches a valid domain name including subdomains and international TLDs.",
+  "category": "Internet",
+  "pattern": "(?:[a-zA-Z0-9](?:[a-zA-Z0-9\\-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,}",
+  "flags": "i",
+  "examples": ["example.com", "sub.domain.co.uk", "my-site.io", "regex.to"],
+  "counterExamples": ["-invalid.com", "invalid-.com", ".com", "localhost"],
+  "tags": ["domain", "internet", "dns", "hostname"],
+  "useCases": ["DNS validation", "Link parsing", "Domain registration checks"],
+  "seoTitle": "Domain Name Regex — Validate Domains in JS, Go, PHP",
+  "seoDescription": "Regex for domain name validation including subdomains and modern TLDs."
+}

package/patterns/email.json

@@ -0,0 +1,14 @@
+{
+  "slug": "email",
+  "name": "Email Address",
+  "description": "RFC 5321 compliant email address validation. Supports subdomains, plus-addressing, and international TLDs.",
+  "category": "Internet",
+  "pattern": "[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}",
+  "flags": "i",
+  "examples": ["user@example.com", "john.doe+tag@sub.domain.co.uk", "contact@regex.to"],
+  "counterExamples": ["plainaddress", "@missinglocal.com", "user@.com", "user@"],
+  "tags": ["email", "internet", "contact", "validation"],
+  "useCases": ["Contact form validation", "User registration", "Newsletter signups"],
+  "seoTitle": "Email Address Regex — Validate Email Patterns in JS, Go, PHP",
+  "seoDescription": "Copy the battle-tested email regex for JavaScript, TypeScript (Zod), Go, and PHP. Includes unit test generation and live testing."
+}

package/patterns/ens-name.json

@@ -0,0 +1,14 @@
+{
+  "slug": "ens-name",
+  "name": "ENS Name (Ethereum Name Service)",
+  "description": "Matches an Ethereum Name Service domain — alphanumeric label(s) ending with .eth.",
+  "category": "Crypto",
+  "pattern": "[a-z0-9][a-z0-9\\-]{1,61}[a-z0-9]\\.eth",
+  "flags": "i",
+  "examples": ["vitalik.eth", "my-wallet.eth", "regex.eth"],
+  "counterExamples": ["-invalid.eth", "a.eth", "vitalik.com", "vitalik.ETH2"],
+  "tags": ["ens", "ethereum", "domain", "web3", "naming"],
+  "useCases": ["Web3 profile lookup", "Wallet address resolution", "ENS search"],
+  "seoTitle": "ENS Name Regex — Validate .eth Domains",
+  "seoDescription": "Regex for Ethereum Name Service (ENS) .eth domain validation."
+}

package/patterns/es-nif.json

@@ -0,0 +1,15 @@
+{
+  "slug": "es-nif",
+  "name": "Spanish NIF / DNI",
+  "description": "Matches a Spanish National Identity Document number (NIF/DNI) — 8 digits followed by a letter, or an NIE starting with X, Y, or Z.",
+  "category": "Identity",
+  "pattern": "[0-9XYZ]\\d{7}[A-HJ-NP-TV-Z]",
+  "flags": "i",
+  "examples": ["12345678Z", "X1234567L", "Y0000000T"],
+  "counterExamples": ["1234567Z", "123456789Z", "12345678I"],
+  "locales": ["es"],
+  "tags": ["nif", "dni", "nie", "spain", "spanish", "identity"],
+  "useCases": ["Spanish government forms", "Bank KYC", "Online identity verification"],
+  "seoTitle": "Spanish NIF/DNI Regex — Validate Spanish ID Numbers",
+  "seoDescription": "Regex for Spanish NIF, DNI and NIE number validation."
+}

package/patterns/ethereum-address.json

@@ -0,0 +1,14 @@
+{
+  "slug": "ethereum-address",
+  "name": "Ethereum Address",
+  "description": "Matches an Ethereum address — 0x followed by exactly 40 hexadecimal characters.",
+  "category": "Crypto",
+  "pattern": "0x[a-fA-F0-9]{40}",
+  "flags": "i",
+  "examples": ["0x742d35Cc6634C0532925a3b844Bc454e4438f44e", "0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe"],
+  "counterExamples": ["742d35Cc6634C0532925a3b844Bc454e4438f44e", "0x742d35Cc6634C0532925a3b844Bc454e4438f44", "0xGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG"],
+  "tags": ["ethereum", "eth", "evm", "crypto", "address", "blockchain"],
+  "useCases": ["Crypto payment validation", "Smart contract interaction", "DeFi apps"],
+  "seoTitle": "Ethereum Address Regex — Validate ETH Addresses",
+  "seoDescription": "Regex for Ethereum (and EVM) address validation."
+}

package/patterns/fr-postal.json

@@ -0,0 +1,15 @@
+{
+  "slug": "fr-postal",
+  "name": "French Postal Code",
+  "description": "Matches a French postal code — exactly 5 digits, starting with 0–9.",
+  "category": "Address",
+  "pattern": "0[1-9]\\d{3}|[1-8]\\d{4}|9[0-5]\\d{3}",
+  "flags": "",
+  "examples": ["75001", "69001", "13001", "06000"],
+  "counterExamples": ["00000", "99000", "1234", "750011"],
+  "locales": ["fr"],
+  "tags": ["postal", "france", "french", "address", "cp"],
+  "useCases": ["French address forms", "VAT region detection", "Delivery zones"],
+  "seoTitle": "French Postal Code Regex — Validate French ZIP Codes",
+  "seoDescription": "Regex for French postal code (code postal) validation."
+}

package/patterns/fr-siren.json

@@ -0,0 +1,15 @@
+{
+  "slug": "fr-siren",
+  "name": "French SIREN Number",
+  "description": "Matches a French SIREN (Système d'Identification du Répertoire des ENtreprises) number — 9 digits.",
+  "category": "Identity",
+  "pattern": "\\d{9}",
+  "flags": "",
+  "examples": ["732829320", "404833048", "123456789"],
+  "counterExamples": ["73282932", "7328293200", "73282932A"],
+  "locales": ["fr"],
+  "tags": ["siren", "france", "company", "business", "tax"],
+  "useCases": ["French business identification", "Trade register lookups", "Tax forms"],
+  "seoTitle": "French SIREN Regex — Validate SIREN Numbers",
+  "seoDescription": "Regex for French SIREN company identifier (9 digits) validation."
+}

package/patterns/fr-siret.json

@@ -0,0 +1,15 @@
+{
+  "slug": "fr-siret",
+  "name": "French SIRET Number",
+  "description": "Matches a French SIRET (Système d'Identification du Répertoire des Établissements) number — 14 digits.",
+  "category": "Identity",
+  "pattern": "\\d{14}",
+  "flags": "",
+  "examples": ["73282932000074", "40483304800022"],
+  "counterExamples": ["7328293200007", "732829320000741", "73282932000074A"],
+  "locales": ["fr"],
+  "tags": ["siret", "france", "company", "tax", "business"],
+  "useCases": ["French business registration", "Invoice validation", "B2B onboarding"],
+  "seoTitle": "French SIRET Regex — Validate SIRET Numbers",
+  "seoDescription": "Regex for French SIRET company identifier (14 digits) validation."
+}

package/patterns/git-sha.json

@@ -0,0 +1,14 @@
+{
+  "slug": "git-sha",
+  "name": "Git Commit SHA",
+  "description": "Matches a Git commit SHA — either short form (7+ chars) or full 40-character SHA-1 hash.",
+  "category": "Dev",
+  "pattern": "[0-9a-f]{7,40}",
+  "flags": "i",
+  "examples": ["a1b2c3d", "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2"],
+  "counterExamples": ["xyz", "ZZZZZZ", "123456"],
+  "tags": ["git", "sha", "commit", "version-control"],
+  "useCases": ["CI/CD pipelines", "Deployment tracking", "Code review tools"],
+  "seoTitle": "Git SHA Regex — Validate Git Commits in JS, Go, PHP",
+  "seoDescription": "Regex for Git commit SHA validation — short (7 chars) or full 40-char SHA-1."
+}