Works on Workers

import SwaggerParser from '@apidevtools/swagger-parser';

// Usage: Parse OpenAPI/Swagger specs (validation uses ajv which fails)
const spec = {
  openapi: '3.0.0',
  info: { title: 'My API', version: '1.0.0' },
  paths: { '/users': { get: { responses: { '200': { description: 'OK' } } } } }
};
const parsed = await SwaggerParser.parse(spec);
return { success: true, result: { title: parsed.info.title } };

import { library, icon } from '@fortawesome/fontawesome-svg-core';
import { faUser } from '@fortawesome/free-solid-svg-icons';

// Usage:
library.add(faUser);
const result = icon({ prefix: 'fas', iconName: 'user' });
const svg = result?.html?.[0];
return { success: svg?.includes('<svg') && svg?.includes('data-icon="user"'), result: { length: svg?.length } };

import { faUser, faHeart, faCheck } from '@fortawesome/free-solid-svg-icons';

// Usage:
const hasCorrectStructure = faUser.prefix === 'fas' && 
  faUser.iconName === 'user' && 
  Array.isArray(faUser.icon);
return { success: hasCorrectStructure, result: { icons: ['faUser', 'faHeart', 'faCheck'], prefix: faUser.prefix } };

import { makeExecutableSchema } from '@graphql-tools/schema';

// Usage:
const typeDefs = 'type Query { hello: String }';
const resolvers = { Query: { hello: () => 'world' } };
const schema = makeExecutableSchema({ typeDefs, resolvers });
return { success: schema.getQueryType()?.name === 'Query', result: 'Schema created' };

import { createClient } from '@libsql/client';

// Usage:
// Test client creation and API surface
const client = createClient({ url: 'libsql://fake-host.turso.io' });
return { success: typeof client.execute === 'function' && typeof client.batch === 'function', result: 'libSQL client created' };

import { encode, decode } from '@msgpack/msgpack';

export default {
  async fetch(request) {
    // Encode complex data
    const data = {
      name: 'User',
      nested: { foo: 'bar', num: 42 },
      tags: ['worker', 'test'],
      binary: new Uint8Array([1, 2, 3, 4, 5])
    };
    
    const encoded = encode(data);
    const decoded = decode(encoded);
    
    // MessagePack is ~25% smaller than JSON
    const jsonSize = JSON.stringify(data).length;
    const msgpackSize = encoded.byteLength;
    
    return Response.json({
      decoded,
      compression: `${msgpackSize}/${jsonSize} bytes (${(msgpackSize/jsonSize*100).toFixed(0)}%)`
    });
  }
};

import { neon } from '@neondatabase/serverless';

// Usage:
const sql = neon('postgresql://user:pass@host/db');
return { success: typeof sql === 'function', result: 'Neon client created' };

import { Octokit } from '@octokit/rest';

// Usage:
const octokit = new Octokit();
const { data } = await octokit.rest.repos.get({ owner: 'cloudflare', repo: 'workers-sdk' });
return { success: data.name === 'workers-sdk', result: data.name };

import { connect } from '@planetscale/database';

// Usage:
const conn = connect({ url: 'mysql://user:pass@host/db' });
return { success: typeof conn.execute === 'function', result: 'PlanetScale client created' };

import accepts from 'accepts';

// Usage:
const accept = accepts(request);
const type = accept.type(['json', 'html']);
return { success: true, result: { preferredType: type } };

import * as acorn from 'acorn';

export default {
  async fetch(request) {
    // Parse ES modules with modern syntax
    const code = `
      import { foo } from './bar';
      const obj = { a: 1, ...other };
      const fn = async () => await fetch('/api');
      class Foo { static bar = 42; }
    `;
    
    const ast = acorn.parse(code, { 
      ecmaVersion: 2022, 
      sourceType: 'module' 
    });
    
    return Response.json({
      type: ast.type,
      statements: ast.body.length,
      firstNode: ast.body[0].type
    });
  }
};

import AdmZip from 'adm-zip';

// Creating ZIP works:
const zip = new AdmZip();
zip.addFile('hello.txt', Buffer.from('Hello from Workers!'));
zip.addFile('data.json', Buffer.from(JSON.stringify({ test: true })));
const zipBuffer = zip.toBuffer();

// Return as downloadable ZIP:
return new Response(zipBuffer, {
  headers: {
    'Content-Type': 'application/zip',
    'Content-Disposition': 'attachment; filename="archive.zip"'
  }
});

import amqp from 'amqplib';

// Usage: Create credentials (actual connection needs TCP to RabbitMQ)
const credentials = amqp.credentials.plain('user', 'pass');
return { success: credentials.mechanism === 'PLAIN', result: { mechanism: credentials.mechanism, note: 'Use Cloudflare Queues instead' } };

import assert from 'assert-plus';

// Usage:
assert.string('hello', 'value');
assert.number(42, 'value');
assert.object({ foo: 'bar' }, 'value');
return { success: true, result: 'All assertions passed' };

import async from 'async';

// Usage:
const results = await async.parallel([
  async () => 1,
  async () => 2,
  async () => 3,
]);
return { success: results[0] === 1 && results[1] === 2 && results[2] === 3, result: results };

import retry from 'async-retry';

export default {
  async fetch(request) {
    // Retry with exponential backoff
    const result = await retry(async (bail, attemptNumber) => {
      const response = await fetch('https://api.example.com/data');
      
      // Use bail() to stop retrying on fatal errors
      if (response.status === 401) {
        bail(new Error('Unauthorized - no point retrying'));
        return;
      }
      
      if (!response.ok) throw new Error(`Attempt ${attemptNumber} failed`);
      return response.json();
    }, {
      retries: 5,
      minTimeout: 100,
      maxTimeout: 1000,
      factor: 2
    });
    
    return Response.json(result);
  }
};

import Schema from 'async-validator';

// Usage:
const descriptor = {
  name: { type: 'string', required: true, message: 'Name is required' },
  age: { type: 'number', min: 0, max: 120 }
};
const validator = new Schema(descriptor);
const result = await validator.validate({ name: 'Alice', age: 30 });
return { success: true, result };

import axios from 'axios';

// Make HTTP requests
const response = await axios.get('https://api.example.com/data');
return { success: response.status === 200, data: response.data };

import base64 from 'base-64';

// Usage:
const encoded = base64.encode('Hello, World!');
const decoded = base64.decode(encoded);
return { success: decoded === 'Hello, World!', result: { encoded, decoded } };

import * as base64 from 'base64-js';

// Usage:
const text = 'Hello World!';
const bytes = new TextEncoder().encode(text);
const encoded = base64.fromByteArray(bytes);
const decoded = base64.toByteArray(encoded);
const result = new TextDecoder().decode(decoded);
return { success: result === text, result: { encoded, decoded: result } };

import auth from 'basic-auth';

// Usage:
// Simulate an HTTP request with Basic Auth header
const credentials = btoa('user:pass'); // Base64 encode 'user:pass'
const mockRequest = {
  headers: {
    authorization: `Basic ${credentials}`
  }
};
const parsed = auth(mockRequest);
return { success: parsed?.name === 'user' && parsed?.pass === 'pass', result: parsed };

import bcrypt from 'bcryptjs';

export default {
  async fetch(request) {
    const password = 'mypassword123';
    
    // Hash password (both sync and async work)
    const salt = bcrypt.genSaltSync(10);
    const hash = bcrypt.hashSync(password, salt);
    
    // Or use async versions
    const asyncHash = await bcrypt.hash(password, 10);
    
    // Verify password
    const isValid = bcrypt.compareSync(password, hash);
    const asyncValid = await bcrypt.compare(password, asyncHash);
    
    return Response.json({ hash, isValid, asyncValid });
  }
};

import Big from 'big.js';

// Usage:
const x = new Big('0.1');
const y = new Big('0.2');
const sum = x.plus(y);
return { success: sum.toString() === '0.3', result: sum.toString() };

import BigNumber from 'bignumber.js';

// Usage:
const x = new BigNumber('0.1');
const y = new BigNumber('0.2');
const sum = x.plus(y);
return { success: sum.toString() === '0.3', result: sum.toString() };

import * as bip39 from 'bip39';

// Usage:
const mnemonic = bip39.generateMnemonic();
const isValid = bip39.validateMnemonic(mnemonic);
return { success: isValid, result: { wordCount: mnemonic.split(' ').length } };

import bl from 'bl';

// Usage:
const list = new bl();
list.append(Buffer.from('Hello '));
list.append(Buffer.from('World'));
const result = list.toString();
return { success: result === 'Hello World', result: { text: result, length: list.length } };

import Promise from 'bluebird';

export default {
  async fetch(request) {
    // Promise.map with concurrency control
    const items = [1, 2, 3, 4, 5];
    const mapped = await Promise.map(items, async (n) => {
      await Promise.delay(10);
      return n * 2;
    }, { concurrency: 2 });
    
    // Promise.props - resolve object of promises
    const props = await Promise.props({
      a: Promise.resolve(1),
      b: Promise.delay(10).then(() => 2)
    });
    
    // Promise.filter, Promise.reduce
    const filtered = await Promise.filter(items, n => n % 2 === 0);
    const sum = await Promise.reduce(items, (acc, n) => acc + n, 0);
    
    return Response.json({ mapped, props, filtered, sum });
  }
};

import BN from 'bn.js';

// Usage:
const a = new BN('1234567890123456789');
const b = new BN('9876543210987654321');
const sum = a.add(b);
return { success: sum.toString() === '11111111101111111110', result: sum.toString() };

import bodyParser from 'body-parser';

// Usage: Express middleware for parsing request bodies
// Use with httpServerHandler from cloudflare:node for Express apps
const jsonParser = bodyParser.json();
const urlencodedParser = bodyParser.urlencoded({ extended: true });
return { success: true, result: 'Middleware created' };

import Boom from 'boom';

export default {
  async fetch(request) {
    const url = new URL(request.url);
    
    try {
      if (url.pathname === '/protected') {
        throw Boom.unauthorized('Authentication required');
      }
      if (url.pathname === '/missing') {
        throw Boom.notFound('Resource not found', { id: 123 });
      }
      return Response.json({ message: 'OK' });
    } catch (error) {
      if (Boom.isBoom(error)) {
        return Response.json(error.output.payload, {
          status: error.output.statusCode,
          headers: error.output.headers
        });
      }
      throw error;
    }
  }
};

import Bottleneck from 'bottleneck';

// Usage:
const limiter = new Bottleneck({ maxConcurrent: 1, minTime: 100 });
const result = await limiter.schedule(() => Promise.resolve('done'));
return { success: result === 'done', result };

import bs58 from 'bs58';

// Usage:
const bytes = new Uint8Array([1, 2, 3, 4, 5]);
const encoded = bs58.encode(bytes);
const decoded = bs58.decode(encoded);
return { success: decoded.length === 5 && decoded[0] === 1, result: { encoded, decoded: Array.from(decoded) } };

import { BSON, ObjectId, Binary, UUID, serialize, deserialize } from 'bson';

export default {
  async fetch(request) {
    // Create MongoDB-compatible documents
    const doc = {
      _id: new ObjectId(),
      name: 'Document',
      data: new Binary(Buffer.from('binary data')),
      uuid: new UUID(),
      created: new Date()
    };
    
    // Serialize/deserialize
    const bsonData = serialize(doc);
    const restored = deserialize(bsonData);
    
    // EJSON for JSON-compatible output
    const ejson = BSON.EJSON.stringify(doc);
    
    return Response.json({ restored, ejson });
  }
};

import { Buffer } from 'buffer';

// Usage:
const buf = Buffer.from('hello world', 'utf-8');
const hex = buf.toString('hex');
const base64 = buf.toString('base64');
return { success: hex.length === 22 && base64.length === 16, result: { hex, base64 } };

import bytes from 'bytes';

// Usage:
const parsed = bytes('1MB');
const formatted = bytes(1048576);
return { success: parsed === 1048576 && formatted === '1MB', result: { parsed, formatted } };

import camelCase from 'camelcase';

// Usage:
const result1 = camelCase('foo-bar');
const result2 = camelCase('foo_bar');
const result3 = camelCase('foo bar');
return { success: result1 === 'fooBar' && result2 === 'fooBar' && result3 === 'fooBar', result: { result1, result2, result3 } };

import { encode, decode } from 'cbor';

// Usage:
const data = { name: 'test', values: [1, 2, 3] };
const encoded = encode(data);
const decoded = decode(encoded);
return { success: decoded.name === 'test', result: { decoded, encodedLength: encoded.length } };

import { expect } from 'chai';

// Usage:
expect(2 + 2).to.equal(4);
expect('hello').to.be.a('string');
expect([1, 2, 3]).to.have.lengthOf(3);
return { success: true, result: 'All assertions passed' };

import Chance from 'chance';

export default {
  async fetch(request) {
    const chance = new Chance();
    // Seed for reproducible results
    const seeded = new Chance(12345);
    
    return Response.json({
      person: {
        name: chance.name(),
        email: chance.email(),
        phone: chance.phone(),
        address: chance.address(),
        city: chance.city()
      },
      misc: {
        guid: chance.guid(),
        ip: chance.ip(),
        url: chance.url(),
        color: chance.color({ format: 'hex' })
      },
      // Seeded gives same result every time
      seededName: seeded.name()
    });
  }
};

import { camelCase, snakeCase } from 'change-case';

// Usage:
const camel = camelCase('hello world');
const snake = snakeCase('helloWorld');
return { success: true, result: { camel, snake } };

import * as cheerio from 'cheerio';

export default {
  async fetch(request) {
    // Fetch and parse a webpage
    const response = await fetch('https://example.com');
    const html = await response.text();
    const $ = cheerio.load(html);
    
    // Extract data with jQuery-like selectors
    const title = $('title').text();
    const h1 = $('h1').text();
    const links = $('a').map((i, el) => $(el).attr('href')).get();
    
    // Manipulate HTML
    $('h1').addClass('scraped').text('Modified');
    
    return Response.json({ title, h1, links });
  }
};

import chroma from 'chroma-js';

export default {
  async fetch(request) {
    // Parse and manipulate colors
    const color = chroma('#3498db');
    
    return Response.json({
      original: color.hex(),
      darken: color.darken().hex(),
      brighten: color.brighten().hex(),
      rgb: color.rgb(),
      hsl: color.hsl(),
      luminance: color.luminance(),
      // Generate color scales
      gradient: chroma.scale(['#fafa6e', '#2A4858']).colors(5),
      // Color mixing
      mix: chroma.mix('red', 'blue', 0.5).hex(),
      // WCAG contrast check
      contrast: chroma.contrast('white', '#3498db')
    });
  }
};

import { ValidationError } from 'class-validator';

// Usage: Decorators need TypeScript experimentalDecorators
const err = new ValidationError();
err.property = 'email';
err.constraints = { isEmail: 'must be valid email' };
return { success: true, result: { note: 'Use zod for Workers - decorators need special bundler config' } };

import classNames from 'classnames';

// Usage:
const classes = classNames('btn', { active: true, disabled: false }, 'primary');
return { success: classes === 'btn active primary', result: classes };

import Table from 'cli-table';

// Usage:
const table = new Table({ head: ['Name', 'Age'] });
table.push(['John', '30'], ['Jane', '25']);
const str = table.toString();
return { success: str.includes('John') && str.includes('30'), result: str.substring(0, 100) };

import clone from 'clone';

const original = { a: 1, b: { c: 2 } };
const cloned = clone(original);
cloned.b.c = 999;
// original.b.c is still 2
return { success: original.b.c === 2, cloned };

import co from 'co';

export default {
  async fetch(request) {
    // Generator-based control flow
    const result = await co(function* () {
      // Sequential async operations
      const response = yield fetch('https://httpbin.org/json');
      const data = yield response.json();
      
      // Parallel with arrays
      const [a, b, c] = yield [
        Promise.resolve(1),
        Promise.resolve(2),
        Promise.resolve(3)
      ];
      
      return { title: data.slideshow.title, sum: a + b + c };
    });
    
    return Response.json(result);
  }
};

import Color from 'color';

// Usage:
const color = Color('rgb(255, 0, 0)');
const hex = color.hex();
const lightened = color.lighten(0.5).hex();
return { success: hex === '#FF0000', result: { hex, lightened } };

import { stripIndent, oneLine, html } from 'common-tags';

// Usage:
const multiline = stripIndent`
      Hello
        World
          !
    `;
const single = oneLine`
      This will be
      on one line
    `;
const markup = html`<div>Hello</div>`;
return { 
  success: multiline === 'Hello\n  World\n    !' && single.includes('This will be on one line'), 
  result: { multiline, single, markup } 
};

import Emitter from 'component-emitter';

// Usage:
const emitter = new Emitter();
let result = null;
emitter.on('test', (data) => { result = data; });
emitter.emit('test', 'hello');
return { success: result === 'hello', result };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import compression from 'compression';

const app = express();
app.use(compression());

app.get('/test', (req, res) => {
  res.json({ data: 'x'.repeat(1000) });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import concat from 'concat-stream';

// Usage:
const { Writable } = await import('stream');
const stream = concat((data) => { 
  return { success: data.toString() === 'hello', result: data.toString() };
});
stream.write('hello');
stream.end();
return { success: true, result: 'stream created' };

import { httpServerHandler } from 'cloudflare:node';
import connect from 'connect';

const app = connect();
app.use((req, res) => {
  res.end('Hello from Connect!');
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import session from 'express-session';
import flash from 'connect-flash';

const app = express();
app.use(session({ secret: 'secret', resave: false, saveUninitialized: true }));
app.use(flash());

app.get('/set', (req, res) => { req.flash('info', 'Hello!'); res.json({ set: true }); });
app.get('/get', (req, res) => res.json({ messages: req.flash('info') }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import history from 'connect-history-api-fallback';

const app = express();
app.use(history({ rewrites: [{ from: /^\/api\/.*$/, to: ctx => ctx.parsedUrl.pathname }] }));

app.get('/index.html', (req, res) => res.send('<html>SPA</html>'));
app.get('/api/test', (req, res) => res.json({ api: true }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import contentType from 'content-type';

// Usage:
const result = contentType.parse('text/html; charset=utf-8');
return { success: result.type === 'text/html', result };

import { fromObject, fromJSON } from 'convert-source-map';

// Usage:
const map = { version: 3, sources: ['foo.js'], mappings: 'AAAA' };
const converter = fromObject(map);
const json = converter.toJSON();
const parsed = fromJSON(json);
return { success: parsed.toObject().version === 3, result: parsed.toObject() };

import cookie from 'cookie';

// Usage:
const result = cookie.parse('foo=bar; baz=qux');
return { success: result.foo === 'bar' && result.baz === 'qux', result };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import cookieParser from 'cookie-parser';

const app = express();
app.use(cookieParser('secret'));

app.get('/test', (req, res) => {
  res.cookie('test', 'value', { signed: true });
  res.json({ cookies: req.signedCookies });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { sign, unsign } from 'cookie-signature';

// Usage:
const val = sign('hello', 'secret');
const result = unsign(val, 'secret');
return { success: result === 'hello', result };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import cors from 'cors';

const app = express();
app.use(cors({ origin: 'https://example.com', methods: ['GET', 'POST'] }));

app.get('/api', (req, res) => res.json({ data: 'test' }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { crc32 } from 'crc';

// Usage:
const checksum = crc32('hello world');
return { success: typeof checksum === 'number' && checksum === 0x0d4a1185, result: '0x' + checksum.toString(16) };

import fetch from 'cross-fetch';

// Usage:
const result = await fetch('https://httpbin.org/get');
const data = await result.json();
return { success: result.ok, result: { status: result.status } };

import CryptoJS from 'crypto-js';

// Hash a string
const hash = CryptoJS.SHA256('hello world').toString();

// Encrypt/decrypt
const encrypted = CryptoJS.AES.encrypt('secret', 'password').toString();
const decrypted = CryptoJS.AES.decrypt(encrypted, 'password').toString(CryptoJS.enc.Utf8);

return { success: true, hash, decrypted };

import { parse, stringify } from 'csv/sync';

export default {
  async fetch(request) {
    // Parse CSV with headers as column names
    const csvData = 'name,age,city\nAlice,30,NYC\nBob,25,LA';
    const records = parse(csvData, { columns: true, skip_empty_lines: true });
    
    // Generate CSV from objects
    const data = [{ id: 1, product: 'Widget', price: 9.99 }];
    const csv = stringify(data, { header: true });
    
    // TSV support with custom delimiter
    const tsv = 'name\tvalue\nfoo\t100';
    const tsvRecords = parse(tsv, { columns: true, delimiter: '\t' });
    
    return Response.json({ records, csv, tsvRecords });
  }
};

import cuid from 'cuid';

export default {
  async fetch(request) {
    // Generate collision-resistant IDs
    const id = cuid();
    
    // Shorter slug version for URLs
    const slug = cuid.slug();
    
    // Validate IDs
    const isValid = cuid.isCuid(id);
    const isSlug = cuid.isSlug(slug);
    
    // Generate multiple unique IDs
    const ids = Array.from({ length: 5 }, () => cuid());
    
    return Response.json({ id, slug, isValid, isSlug, ids });
  }
};

import { min, max, mean, median, extent, group } from 'd3-array';

// Usage:
const data = [1, 5, 2, 8, 3];
const minVal = min(data);
const maxVal = max(data);
const meanVal = mean(data);
const medianVal = median(data);
const extentVal = extent(data);
const grouped = group([{key: 'a', val: 1}, {key: 'b', val: 2}, {key: 'a', val: 3}], d => d.key);
return { success: minVal === 1 && maxVal === 8 && meanVal === 3.8 && medianVal === 3, result: { minVal, maxVal, meanVal, medianVal, extentVal, grouped: grouped.size } };

import { scaleLinear, scaleLog, scalePow, scaleTime } from 'd3-scale';

// Usage:
const linear = scaleLinear().domain([0, 10]).range([0, 100]);
const log = scaleLog().domain([1, 10]).range([0, 100]);
const pow = scalePow().exponent(2).domain([0, 10]).range([0, 100]);
const time = scaleTime().domain([new Date(2020, 0, 1), new Date(2021, 0, 1)]).range([0, 100]);
const linearVal = linear(5);
const logVal = log(5);
const powVal = pow(5);
const timeVal = time(new Date(2020, 6, 1));
return { success: linearVal === 50 && logVal > 0 && powVal === 25 && timeVal > 0, result: { linearVal, logVal, powVal, timeVal } };

import { line, area, pie, arc } from 'd3-shape';

// Usage:
const lineGenerator = line().x((d, i) => i * 10).y(d => d);
const linePath = lineGenerator([10, 20, 30, 20, 10]);
const areaGenerator = area().x((d, i) => i * 10).y0(0).y1(d => d);
const areaPath = areaGenerator([10, 20, 30, 20, 10]);
const pieGenerator = pie();
const pieData = pieGenerator([1, 2, 3]);
const arcGenerator = arc().innerRadius(0).outerRadius(100);
const arcPath = arcGenerator(pieData[0]);
return { success: typeof linePath === 'string' && typeof areaPath === 'string' && pieData.length === 3 && typeof arcPath === 'string', result: { linePath: linePath.substring(0, 20), pieAngles: pieData.map(d => [d.startAngle, d.endAngle]) } };

import { format, parseISO } from 'date-fns';

// Usage:
const date = parseISO('2026-01-08');
const formatted = format(date, 'yyyy-MM-dd');
return { success: formatted === '2026-01-08', result: formatted };

import dayjs from 'dayjs';

// Usage:
const date = dayjs('2026-01-08');
const formatted = date.format('YYYY-MM-DD');
return { success: formatted === '2026-01-08', result: formatted };

import debounce from 'debounce';

// Usage:
let callCount = 0;
const debouncedFn = debounce(() => { callCount++; }, 100);
debouncedFn();
debouncedFn();
debouncedFn();
// Wait for debounce delay
await new Promise(resolve => setTimeout(resolve, 150));
return { success: callCount === 1, result: callCount };

import debug from 'debug';

// Create namespaced loggers
const logApp = debug('app:main');
const logHttp = debug('app:http');

// Enable namespaces
debug.enable('app:*');

export default {
  async fetch(request) {
    const url = new URL(request.url);
    logApp('Request: %s %s', request.method, url.pathname);
    logHttp('Headers: %O', Object.fromEntries(request.headers));
    
    return Response.json({ debugEnabled: debug.enabled('app:main') });
  }
};

import decamelize from 'decamelize';

// Usage:
const result = decamelize('unicornRainbow');
const custom = decamelize('unicornRainbow', { separator: '-' });
return { success: result === 'unicorn_rainbow' && custom === 'unicorn-rainbow', result: { result, custom } };

import Decimal from 'decimal.js';

// Usage:
const x = new Decimal(0.1);
const y = new Decimal(0.2);
const result = x.plus(y).toString();
return { success: result === '0.3', result };

import { diff, applyChange } from 'deep-diff';

// Usage:
const lhs = { name: 'Alice', age: 30, city: 'NYC' };
const rhs = { name: 'Alice', age: 31, city: 'LA' };
const differences = diff(lhs, rhs);
const hasChanges = differences && differences.length === 2;
const ageChanged = differences.some(d => d.path[0] === 'age' && d.lhs === 30 && d.rhs === 31);
const cityChanged = differences.some(d => d.path[0] === 'city' && d.lhs === 'NYC' && d.rhs === 'LA');
return { success: hasChanges && ageChanged && cityChanged, result: differences };

import deepEqual from 'deep-equal';

// Usage:
const result1 = deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } });
const result2 = deepEqual({ a: 1 }, { a: 2 });
return { success: result1 && !result2, result: { result1, result2 } };

import deepExtend from 'deep-extend';

// Usage:
const result = deepExtend({ a: 1, b: { c: 2 } }, { b: { d: 3 } });
return { success: result.a === 1 && result.b.c === 2 && result.b.d === 3, result };

import deepmerge from 'deepmerge';

// Usage:
const result = deepmerge({ a: 1, b: { c: 2 } }, { b: { d: 3 } });
return { success: result.a === 1 && result.b.c === 2 && result.b.d === 3, result };

import depd from 'depd';

const deprecate = depd('my-module');

function oldFunction() {
  deprecate('oldFunction() is deprecated');
  return 'result';
}

export default {
  async fetch(request) {
    const result = oldFunction();
    return Response.json({ result, message: 'Check console for deprecation warning' });
  }
};

import destroy from 'destroy';
import { Readable } from 'node:stream';

// Usage:
const stream = new Readable({ read() {} });
destroy(stream);
return { success: stream.destroyed, result: { destroyed: stream.destroyed } };

import { stringify, parse } from 'devalue';

// Usage:
const obj = { a: 1, b: new Date('2026-01-10'), c: /test/ };
const str = stringify(obj);
const result = parse(str);
return { success: result.a === 1 && result.b instanceof Date, result };

import * as diff from 'diff';

// Usage:
const result = diff.diffChars('hello', 'hallo');
return { success: result.length > 0 && result.some(p => p.added || p.removed), result };

import Dinero from 'dinero.js';

// Usage:
const price = Dinero({ amount: 500, currency: 'USD' });
const total = price.add(Dinero({ amount: 200, currency: 'USD' }));
return { success: total.getAmount() === 700, result: total.toFormat('$0,0.00') };

import { sql } from 'drizzle-orm';

// Usage:
const query = sql`SELECT * FROM users WHERE id = ${123}`;
return { success: query.queryChunks.length > 0, result: 'SQL query built' };

import validator from 'email-validator';

// Usage:
const valid = validator.validate('test@example.com');
const invalid = validator.validate('notanemail');
return { success: valid && !invalid, result: { valid, invalid } };

import { convert } from 'encoding';

// Usage:
const result = convert('hello', 'UTF-8');
return { success: result.toString() === 'hello', result: result.toString() };

import { Promise } from 'es6-promise';

// Usage:
const p = new Promise((resolve) => resolve('ok'));
const result = await p;
return { success: result === 'ok', result };

import { promisify } from 'es6-promisify';

// Usage:
// Create a callback-based function
const callbackFn = (a, b, callback) => {
  setTimeout(() => callback(null, a + b), 10);
};
// Convert to promise-based
const promiseFn = promisify(callbackFn);
const result = await promiseFn(2, 3);
return { success: result === 5, result };

import escapeHtml from 'escape-html';

// Usage:
const escaped = escapeHtml('<script>alert("xss")</script>');
return { success: escaped.includes('&lt;'), result: escaped };

import escapeStringRegexp from 'escape-string-regexp';

// Usage:
const result = escapeStringRegexp('foo.bar*baz');
return { success: result === 'foo\\.bar\\*baz', result };

import { parseScript } from 'esprima';

// Usage:
const ast = parseScript('const x = 42;');
return { success: ast.type === 'Program', result: ast.type };

import etag from 'etag';

// Usage:
const body = 'Hello World';
const tag = etag(body);
return { success: tag.startsWith('"') || tag.startsWith('W/'), result: { etag: tag } };

import es from 'event-stream';

// Usage:
const results = [];
const stream = es.through(function(data) { results.push(data); this.emit('data', data); });
stream.write('test');
return { success: results[0] === 'test', result: results };

import { EventEmitter2 } from 'eventemitter2';

// Usage:
const emitter = new EventEmitter2();
let called = false;
emitter.on('test', () => { called = true; });
emitter.emit('test');
return { success: called, result: { called } };

import EventEmitter from 'eventemitter3';

// Usage:
const emitter = new EventEmitter();
let value = '';
emitter.on('event', (msg) => { value = msg; });
emitter.emit('event', 'hello');
return { success: value === 'hello', result: { value } };

import { EventEmitter } from 'events';

// Usage:
const ee = new EventEmitter();
let count = 0;
ee.on('test', () => { count++; });
ee.emit('test');
return { success: count === 1, result: { count } };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';

const app = express();
app.use(express.json());

app.get('/',(req, res) => res.json({ message: 'Express on Workers!' }));
app.post('/echo', (req, res) => res.json({ received: req.body }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import session from 'express-session';

// Usage:
const middleware = session({ secret: 'test', resave: false, saveUninitialized: true });
return { success: typeof middleware === 'function', result: 'session middleware created' };

import extend from 'extend';

// Usage:
const result = extend({ a: 1 }, { b: 2 }, { c: 3 });
return { success: result.a === 1 && result.b === 2 && result.c === 3, result };

import extend from 'extend-shallow';

// Usage:
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const obj3 = { c: 5, d: 6 };
const result = extend(obj1, obj2, obj3);
const success = result.a === 1 && result.b === 3 && result.c === 5 && result.d === 6;
return { success, result };

import equal from 'fast-deep-equal';

// Usage:
const a = { x: 1, y: { z: 2 } };
const b = { x: 1, y: { z: 2 } };
const c = { x: 1, y: { z: 3 } };
const result1 = equal(a, b);
const result2 = equal(a, c);
return { success: result1 === true && result2 === false, result: { equal: result1, notEqual: result2 } };

import { XMLParser, XMLBuilder, XMLValidator } from 'fast-xml-parser';

export default {
  async fetch(request) {
    // Parse XML to JSON
    const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: '@_' });
    const xml = '<catalog><book id="1"><title>JS Guide</title></book></catalog>';
    const parsed = parser.parse(xml);
    
    // Build XML from JSON
    const builder = new XMLBuilder({ ignoreAttributes: false, attributeNamePrefix: '@_' });
    const built = builder.build({ root: { item: [{ '@_id': '1', name: 'Item' }] } });
    
    // Validate XML
    const isValid = XMLValidator.validate(xml);
    
    return Response.json({ parsed, built, isValid });
  }
};

import { gzipSync, gunzipSync, zipSync, unzipSync, strToU8, strFromU8 } from 'fflate';

export default {
  async fetch(request) {
    // GZIP compression
    const text = 'Hello '.repeat(100);
    const gzipped = gzipSync(strToU8(text));
    const ungzipped = strFromU8(gunzipSync(gzipped));
    
    // Create ZIP archive
    const archive = zipSync({
      'hello.txt': strToU8('Hello World'),
      'data.json': strToU8(JSON.stringify({ test: true }))
    });
    
    // Extract ZIP
    const extracted = unzipSync(archive);
    
    return Response.json({
      gzipRatio: (gzipped.length / text.length * 100).toFixed(1) + '%',
      zipFiles: Object.keys(extracted)
    });
  }
};

import figlet from 'figlet';
import standard from 'figlet/importable-fonts/Standard.js';

// Usage: Must preload fonts
figlet.parseFont('Standard', standard);
const ascii = figlet.textSync('Hi!', { font: 'Standard' });
return { success: ascii.length > 0, result: { ascii } };

import { fileTypeFromBuffer } from 'file-type';

// Usage:
// PNG magic bytes: 89 50 4E 47 0D 0A 1A 0A (with some extra bytes for the tokenizer)
const pngBytes = new Uint8Array([
  0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
  0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
  0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
  0x08, 0x06, 0x00, 0x00, 0x00, 0x1F, 0x15, 0xC4
]);
const result = await fileTypeFromBuffer(pngBytes);
return { success: result?.ext === 'png' && result?.mime === 'image/png', result };

import { filesize } from 'filesize';

filesize(1024); // '1.02 kB'

import { httpServerHandler } from 'cloudflare:node';
import { createServer } from 'node:http';
import finalhandler from 'finalhandler';

const server = createServer((req, res) => {
  const done = finalhandler(req, res);
  
  if (req.url === '/') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: 'Hello!' }));
  } else {
    done(); // 404 for unknown routes
  }
});

server.listen(3000);
export default httpServerHandler({ port: 3000 });

import { flatten, unflatten } from 'flat';

const flat = flatten({ a: { b: 1 } });
// { 'a.b': 1 }

import FormData from 'form-data';

// Usage:
const form = new FormData();
form.append('key', 'value');
return { success: true, result: 'FormData created' };

import forwarded from 'forwarded';

// Usage:
const req = { 
  headers: { 'x-forwarded-for': '192.168.1.1, 10.0.0.1' },
  connection: { remoteAddress: '127.0.0.1' }
};
const addresses = forwarded(req);
return { success: Array.isArray(addresses) && addresses.length === 3, result: addresses };

import fm from 'front-matter';

// Usage:
const content = `---
title: Hello World
date: 2026-01-09
tags: [test, markdown]
---

# Article Content

This is the body of the article.
`;
const parsed = fm(content);
return { 
  success: parsed.attributes.title === 'Hello World' && parsed.body.includes('Article Content'),
  result: { attributes: parsed.attributes, bodyLength: parsed.body.length }
};

import * as fs from 'node:fs';

// Usage:
const result = { existsSync: typeof fs.existsSync === 'function', readFileSync: typeof fs.readFileSync === 'function' };
return { success: result.existsSync && result.readFileSync, result };

import { createPool } from 'generic-pool';

const pool = createPool({
  create: async () => ({ id: Date.now() }),
  destroy: async (r) => {}
}, { max: 10 });

const resource = await pool.acquire();
await pool.release(resource);

import global from 'global';

// Usage:
// global is a polyfill for accessing global variables across environments
// It returns the global object (globalThis in Workers)
const hasGlobal = typeof global === 'object';
const hasGlobalThis = global === globalThis;
return { success: hasGlobal && hasGlobalThis, result: { type: typeof global, isGlobalThis: hasGlobalThis } };

import { graphql, buildSchema, parse, validate, GraphQLSchema, GraphQLObjectType, GraphQLString } from 'graphql';

export default {
  async fetch(request) {
    // SDL-based schema
    const schema = buildSchema(`
      type Query {
        hello: String
        user(id: Int!): User
      }
      type User { id: Int, name: String }
    `);
    const root = {
      hello: () => 'Hello from Workers!',
      user: ({ id }) => ({ id, name: 'User ' + id })
    };
    
    const result = await graphql({
      schema,
      source: '{ hello user(id: 1) { name } }',
      rootValue: root
    });
    
    return Response.json(result);
  }
};

import gql from 'graphql-tag';

// Usage:
const query = gql`
  query GetUser($id: ID!) {
    user(id: $id) {
      name
      email
    }
  }
`;
return { success: query.kind === 'Document' && query.definitions.length > 0, result: { kind: query.kind, definitions: query.definitions.length } };

import { makeExecutableSchema } from 'graphql-tools';

// Usage:
// Create a simple GraphQL schema
const typeDefs = `
  type Query {
    hello: String
  }
`;
const resolvers = {
  Query: {
    hello: () => 'Hello from Workers!'
  }
};
const schema = makeExecutableSchema({ typeDefs, resolvers });
return { 
  success: schema != null && schema.getQueryType()?.name === 'Query',
  result: { hasSchema: true, queryType: schema.getQueryType()?.name }
};

import matter from 'gray-matter';

export default {
  async fetch(request) {
    // Parse YAML front matter
    const markdown = `---
title: My Post
date: 2024-01-15
tags: [js, workers]
---

# Content Here`;
    const { data, content } = matter(markdown);
    
    // JSON front matter
    const json = `---json
{"title": "JSON"}
---
Content`;
    const jsonParsed = matter(json);
    
    // Stringify back to front matter
    const output = matter.stringify('New content', { title: 'Generated' });
    
    return Response.json({ yaml: data, json: jsonParsed.data, output });
  }
};

import hashSum from 'hash-sum';

// Usage:
const hash = hashSum({ foo: 'bar', nested: { value: 123 } });
return { success: typeof hash === 'string' && hash.length > 0, result: hash };

import { sha256, sha512 } from 'hash.js';

const hash = sha256().update('hello world').digest('hex');
return { success: hash.length === 64, hash };

import he from 'he';

// Usage:
const encoded = he.encode('<script>alert("xss")</script>');
const decoded = he.decode('&lt;div&gt;Hello&lt;/div&gt;');
return { success: decoded === '<div>Hello</div>', result: { encoded, decoded } };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import helmet from 'helmet';

const app = express();
app.use(helmet());

app.get('/test', (req, res) => {
  res.json({ secure: true });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import H from 'highland';

// Usage:
const result: number[] = [];
H([1, 2, 3, 4])
  .map((x: number) => x * 2)
  .each((x: number) => result.push(x));
return { success: result.join(',') === '2,4,6,8', result };

import hljs from 'highlight.js';

// Usage:
const result = hljs.highlight('const x = 5;', { language: 'javascript' });
return { success: result.value.includes('const'), result: { highlighted: result.value.substring(0, 50) } };

import { createMemoryHistory } from 'history';

// Usage:
const history = createMemoryHistory();
history.push('/test');
return { success: history.location.pathname === '/test', result: { pathname: history.location.pathname } };

import Hogan from 'hogan.js';

// Usage:
const template = Hogan.compile('Hello {{name}}!');
const result = template.render({ name: 'World' });
return { success: result === 'Hello World!', result };

import hoistStatics from 'hoist-non-react-statics';

// Usage:
function Target() {}
function Source() {}
Source.foo = 'bar';
hoistStatics(Target, Source);
return { success: (Target as any).foo === 'bar', result: { foo: (Target as any).foo } };

import { Hono } from 'hono';
import { cors } from 'hono/cors';
import { prettyJSON } from 'hono/pretty-json';

const app = new Hono();
app.use('*', cors());
app.use('*', prettyJSON());

app.get('/', (c) => c.json({ message: 'Hello!' }));
app.get('/users/:id', (c) => c.json({ userId: c.req.param('id') }));
app.post('/data', async (c) => c.json({ body: await c.req.json() }));

export default app;

import { encode, decode } from 'html-entities';

// Usage:
const encoded = encode('<div>Hello & goodbye</div>');
const decoded = decode('&lt;div&gt;Hello &amp; goodbye&lt;/div&gt;');
return { success: encoded === '&lt;div&gt;Hello &amp; goodbye&lt;/div&gt;' && decoded === '<div>Hello & goodbye</div>', result: { encoded, decoded } };

import { parseDocument, DomUtils } from 'htmlparser2';
import render from 'dom-serializer';

export default {
  async fetch(request) {
    const response = await fetch('https://example.com');
    const html = await response.text();
    const dom = parseDocument(html);
    
    // Find elements
    const h1 = DomUtils.findOne(el => el.name === 'h1', dom.children, true);
    const title = h1 ? DomUtils.textContent(h1) : null;
    const links = DomUtils.findAll(el => el.name === 'a', dom.children, true);
    
    // Serialize back to HTML
    const serialized = render(dom);
    
    return Response.json({ title, linkCount: links.length });
  }
};

import createError from 'http-errors';

// Usage:
const err = createError(404, 'User not found');
return { success: err.status === 404, result: { status: err.status, message: err.message } };

import httpProxy from 'http-proxy';

// Usage:
// http-proxy creates HTTP proxy servers - requires node:http server APIs
const proxy = httpProxy.createProxyServer();
return { success: true, result: 'HTTP proxy created' };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import { createProxyMiddleware } from 'http-proxy-middleware';

const app = express();

// Note: Basic proxying works but may have edge cases
const apiProxy = createProxyMiddleware({
  target: 'https://api.example.com',
  changeOrigin: true
});

app.use('/api', apiProxy);
app.get('/', (req, res) => res.json({ message: 'Proxy ready' }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { StatusCodes, getReasonPhrase } from 'http-status-codes';

// Usage:
const ok = StatusCodes.OK;
const notFound = StatusCodes.NOT_FOUND;
const phrase = getReasonPhrase(200);
return { success: ok === 200 && notFound === 404 && phrase === 'OK', result: { ok, notFound, phrase } };

import { HttpsProxyAgent } from 'https-proxy-agent';

// Usage:
const agent = new HttpsProxyAgent('http://proxy.example.com:8080');
return { success: agent.proxy.hostname === 'proxy.example.com', result: { host: agent.proxy.hostname, port: agent.proxy.port } };

import i18next from 'i18next';

export default {
  async fetch(request) {
    await i18next.init({
      lng: 'en',
      fallbackLng: 'en',
      resources: {
        en: { translation: { greeting: 'Hello, {{name}}!', welcome: 'Welcome' } },
        es: { translation: { greeting: '¡Hola, {{name}}!', welcome: 'Bienvenido' } }
      }
    });
    
    const en = i18next.t('greeting', { name: 'World' });
    await i18next.changeLanguage('es');
    const es = i18next.t('greeting', { name: 'Mundo' });
    
    return Response.json({ en, es });
  }
};

import iconv from 'iconv-lite';

// Usage:
const encoded = iconv.encode('Hello', 'utf8');
const decoded = iconv.decode(encoded, 'utf8');
return { success: decoded === 'Hello', result: decoded };

import identityObj from 'identity-obj-proxy';

// Usage:
// Identity proxy returns property names as values (for testing)
const result = identityObj.foo === 'foo' && identityObj.bar === 'bar';
return { success: result, result: { foo: identityObj.foo, bar: identityObj.bar } };

import sizeOf from 'image-size';

// Usage:
// Create a simple 1x1 PNG (base64 encoded)
const pngData = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
const dimensions = sizeOf(pngData);
return { success: dimensions.width === 1 && dimensions.height === 1 && dimensions.type === 'png', result: dimensions };

import { produce, enableMapSet } from 'immer';
enableMapSet();

export default {
  async fetch(request) {
    const state = {
      users: [{ id: 1, name: 'Alice' }],
      settings: { theme: 'light' }
    };
    
    const nextState = produce(state, draft => {
      draft.users.push({ id: 2, name: 'Bob' });
      draft.settings.theme = 'dark';
    });
    
    // Curried producer
    const addUser = produce((draft, user) => { draft.users.push(user); });
    const withNewUser = addUser(nextState, { id: 3, name: 'Charlie' });
    
    return Response.json({ original: state, updated: withNewUser });
  }
};

import update from 'immutability-helper';

// Usage:
const state = { name: 'Alice', age: 30 };
const newState = update(state, { age: { $set: 31 } });
return { success: newState.age === 31 && state.age === 30, result: newState };

import { Map } from 'immutable';

// Usage:
const map = Map({ a: 1, b: 2 });
const map2 = map.set('c', 3);
return { success: map2.get('c') === 3 && map2.size === 3, result: map2.toObject() };

import inflection from 'inflection';

// Usage:
const plural = inflection.pluralize('person');
const singular = inflection.singularize('people');
const camel = inflection.camelize('hello_world');
return { success: plural === 'people' && singular === 'person' && camel === 'HelloWorld', result: { plural, singular, camel } };

import inherits from 'inherits';

// Usage:
function Parent() { this.name = 'parent'; }
Parent.prototype.getName = function() { return this.name; };
function Child() { Parent.call(this); this.name = 'child'; }
inherits(Child, Parent);
const child = new Child();
return { success: child.getName() === 'child', result: child.getName() };

import ini from 'ini';

// Usage:
const obj = { section: { key: 'value', number: 42 } };
const str = ini.stringify(obj);
const parsed = ini.parse(str);
return { success: parsed.section.key === 'value', result: parsed };

import { IntlMessageFormat } from 'intl-messageformat';

// Usage:
const msg = new IntlMessageFormat('Hello {name}!', 'en-US');
const result = msg.format({ name: 'World' });
return { success: result === 'Hello World!', result };

import invariant from 'invariant';

// Usage:
let error;
try {
  invariant(false, 'This is an error');
} catch (e) {
  error = e.message;
}
return { success: error === 'This is an error', result: error };

import { Container, injectable, inject } from 'inversify';

// Usage:
@injectable()
class Warrior {
  constructor() {}
  fight() { return 'fight!'; }
}
const container = new Container();
container.bind(Warrior).toSelf();
const warrior = container.get(Warrior);
return { success: warrior.fight() === 'fight!', result: warrior.fight() };

import ip from 'ip';

// Usage:
const isPrivate = ip.isPrivate('192.168.1.1');
const isPublic = ip.isPublic('8.8.8.8');
return { success: isPrivate && isPublic, result: { isPrivate, isPublic } };

import isNumber from 'is-number';

// Usage:
const results = [isNumber(123), isNumber('123'), isNumber('abc'), isNumber(null)];
return { success: results[0] && results[1] && !results[2] && !results[3], result: results };

import { isPlainObject } from 'is-plain-object';

// Usage:
const r1 = isPlainObject({});
const r2 = isPlainObject([]);
return { success: r1 && !r2, result: { object: r1, array: r2 } };

import isPromise from 'is-promise';

// Usage:
const a = isPromise(Promise.resolve(123));
const b = isPromise({ then: () => {} });
const c = isPromise(123);
return { success: a === true && b === true && c === false, result: { a, b, c } };

import isUrl from 'is-url';

// Usage:
const results = [
  isUrl('https://example.com'),
  isUrl('http://example.com/path'),
  isUrl('not a url'),
  isUrl('example.com')
];
return { success: results[0] && results[1] && !results[2] && !results[3], result: results };

import isObject from 'isobject';

// Usage:
const results = [isObject({}), isObject([]), isObject(null), isObject('test')];
return { success: results[0] && !results[1] && !results[2] && !results[3], result: results };

import 'isomorphic-fetch';

// Usage:
// isomorphic-fetch polyfills fetch globally
const result = typeof fetch === 'function';
return { success: result, result: 'fetch is available' };

import { AutoRouter } from 'itty-router';

const router = AutoRouter();

// Routes return objects - auto-converted to JSON
router.get('/', () => ({ message: 'Hello!' }));
router.get('/users/:id', ({ id }) => ({ userId: id }));
router.get('/search', (req) => {
  const url = new URL(req.url);
  return { query: url.searchParams.get('q') };
});
router.post('/data', async (req) => ({ body: await req.json() }));

export default router;

import { Jimp } from 'jimp';

// Usage:
const image = new Jimp({ width: 100, height: 100, color: 0xff0000ff });
return { success: true, result: { width: image.width, height: image.height } };

import Joi from 'joi';

export default {
  async fetch(request) {
    const userSchema = Joi.object({
      username: Joi.string().alphanum().min(3).max(30).required(),
      email: Joi.string().email().required(),
      age: Joi.number().integer().min(0).max(120),
      role: Joi.string().valid('admin', 'user').default('user')
    });
    
    const body = await request.json();
    const { error, value } = userSchema.validate(body, { abortEarly: false });
    
    if (error) {
      return Response.json({ errors: error.details.map(d => d.message) }, { status: 400 });
    }
    return Response.json({ valid: true, data: value });
  }
};

import * as jose from 'jose';

export default {
  async fetch(request) {
    // Sign JWT with HS256
    const secret = new TextEncoder().encode('my-secret-32-chars-minimum-key!');
    const jwt = await new jose.SignJWT({ sub: 'user123', role: 'admin' })
      .setProtectedHeader({ alg: 'HS256' })
      .setIssuedAt()
      .setExpirationTime('2h')
      .sign(secret);
    
    // Verify JWT
    const { payload } = await jose.jwtVerify(jwt, secret);
    
    // RSA key pair
    const { publicKey, privateKey } = await jose.generateKeyPair('RS256');
    
    // Encrypted JWT (JWE)
    const key = await jose.generateSecret('A256GCM');
    const jwe = await new jose.EncryptJWT({ secret: 'data' })
      .setProtectedHeader({ alg: 'dir', enc: 'A256GCM' })
      .encrypt(key);
    
    return Response.json({ jwt, payload });
  }
};

import { Base64 } from 'js-base64';

// Usage:
const encoded = Base64.encode('hello');
const decoded = Base64.decode(encoded);
return { success: decoded === 'hello', result: { encoded, decoded } };

import beautify from 'js-beautify';

// Usage:
const result = beautify('var x=1;', { indent_size: 2 });
return { success: result.includes('var x'), result };

import Cookies from 'js-cookie';

// Usage: js-cookie needs document.cookie (browser only)
// In Workers, parse cookies manually from request headers
const cookieHeader = request.headers.get('Cookie') || '';
return { success: true, result: { note: 'Use request.headers.get("Cookie") in Workers' } };

import sha256 from 'js-sha256';

// Usage:
const result = sha256('hello');
return { success: result.length === 64, result };

import yaml from 'js-yaml';

// Usage:
const obj = yaml.load('name: Alice\nage: 30');
return { success: true, result: obj };

import stringify from 'json-stable-stringify';

// Usage:
const result = stringify({ b: 2, a: 1 });
return { success: result === '{"a":1,"b":2}', result };

import stringify from 'json-stringify-safe';

// Usage:
const obj: any = { a: 1 };
obj.circular = obj;
const result = stringify(obj);
return { success: result.includes('"a":1'), result };

import JSON5 from 'json5';

// Usage:
const obj = JSON5.parse('{ key: "value", /* comment */ }');
return { success: obj.key === 'value', result: obj };

import jsonfile from 'jsonfile';
import { mkdirSync } from 'node:fs';

export default {
  async fetch(request) {
    // Write JSON to /tmp (ephemeral, per-request)
    mkdirSync('/tmp/data', { recursive: true });
    const data = { name: 'test', timestamp: Date.now() };
    jsonfile.writeFileSync('/tmp/data/config.json', data, { spaces: 2 });
    
    // Read it back
    const result = jsonfile.readFileSync('/tmp/data/config.json');
    return Response.json({ written: data, readBack: result });
  }
};

import { Validator } from 'jsonschema';

// Usage:
const v = new Validator();
const result = v.validate({ name: 'test' }, { type: 'object', properties: { name: { type: 'string' } } });
return { success: result.valid, result: result.valid };

import JSONStream from 'JSONStream';

// Usage:
const stream = JSONStream.parse('*');
return { success: stream !== undefined && typeof stream.pipe === 'function', result: 'Stream created' };

import jwt from 'jsonwebtoken';

// Usage:
const token = jwt.sign({ sub: '123' }, 'secret');
const decoded = jwt.verify(token, 'secret');
return { success: decoded.sub === '123', result: decoded };

import JSZip from 'jszip';

// Usage:
const zip = new JSZip();
zip.file('hello.txt', 'Hello World!');
const content = await zip.generateAsync({ type: 'blob' });
return { success: content.size > 0, result: { size: content.size } };

import { jwtDecode } from 'jwt-decode';

// Usage:
const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
const decoded = jwtDecode(token);
return { success: decoded.sub === '1234567890' && decoded.name === 'John Doe', result: decoded };

import kindOf from 'kind-of';

// Usage:
const result = [kindOf('test'), kindOf(123), kindOf([]), kindOf({})];
return { success: result.join(',') === 'string,number,array,object', result };

import { httpServerHandler } from 'cloudflare:node';
import Koa from 'koa';

const app = new Koa();
app.use(async (ctx) => {
  ctx.body = { message: 'Koa on Workers!' };
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import ky from 'ky';

const data = await ky.get('https://api.example.com/data').json();
const posted = await ky.post('https://api.example.com/items', { json: { name: 'test' } }).json();
return { success: true, data };

import { Kysely, sql } from 'kysely';

// Usage:
return { success: typeof Kysely === 'function' && typeof sql === 'function', result: 'Kysely exports available' };

import { Liquid } from 'liquidjs';

// Usage:
const engine = new Liquid();
const result = await engine.parseAndRender('Hello {{ name }}!', { name: 'World' });
return { success: result === 'Hello World!', result };

import _ from 'lodash';

// Usage:
const result = _.chunk(['a', 'b', 'c', 'd'], 2);
return { success: true, result };

import { chunk } from 'lodash-es';

// Usage:
const result = chunk(['a', 'b', 'c', 'd'], 2);
return { success: true, result };

import assign from 'lodash.assign';

// Usage:
const result = assign({}, { a: 1 }, { b: 2 });
return { success: result.a === 1 && result.b === 2, result };

import camelCase from 'lodash.camelcase';

// Usage:
const result = camelCase('foo-bar');
return { success: result === 'fooBar', result };

import cloneDeep from 'lodash.clonedeep';

// Usage:
const obj = { a: { b: 1 } };
const clone = cloneDeep(obj);
clone.a.b = 2;
return { success: obj.a.b === 1 && clone.a.b === 2, result: { original: obj, clone } };

import debounce from 'lodash.debounce';

// Usage:
let count = 0;
const fn = debounce(() => { count++; }, 50);
fn(); fn(); fn();
await new Promise(r => setTimeout(r, 100));
return { success: count === 1, result: { count } };

import defaults from 'lodash.defaults';

// Usage:
const result = defaults({ a: 1 }, { a: 2, b: 3 });
return { success: result.a === 1 && result.b === 3, result };

import flatten from 'lodash.flatten';

// Usage:
const result = flatten([[1, 2], [3, 4]]);
return { success: result.join(',') === '1,2,3,4', result };

import forEach from 'lodash.foreach';

// Usage:
const result: number[] = [];
forEach([1, 2, 3], (n) => result.push(n * 2));
return { success: result.join(',') === '2,4,6', result };

import get from 'lodash.get';

// Usage:
const obj = { a: { b: { c: 123 } } };
const result = get(obj, 'a.b.c');
const missing = get(obj, 'x.y.z', 'default');
return { success: result === 123 && missing === 'default', result: { result, missing } };

import isEmpty from 'lodash.isempty';

// Usage:
const result = [isEmpty({}), isEmpty([]), isEmpty(''), isEmpty({ a: 1 })];
return { success: result[0] && result[1] && result[2] && !result[3], result };

import isEqual from 'lodash.isequal';

// Usage:
const result1 = isEqual({ a: 1 }, { a: 1 });
const result2 = isEqual({ a: 1 }, { a: 2 });
return { success: result1 && !result2, result: { result1, result2 } };

import isFunction from 'lodash.isfunction';

// Usage:
const result = [isFunction(() => {}), isFunction({}), isFunction(null)];
return { success: result[0] && !result[1] && !result[2], result };

import isPlainObject from 'lodash.isplainobject';

// Usage:
const result = [isPlainObject({}), isPlainObject([]), isPlainObject(null)];
return { success: result[0] && !result[1] && !result[2], result };

import isString from 'lodash.isstring';

// Usage:
const result = [isString('hello'), isString(123), isString(null)];
return { success: result[0] && !result[1] && !result[2], result };

import map from 'lodash.map';

// Usage:
const result = map([1, 2, 3], n => n * 2);
return { success: result.join(',') === '2,4,6', result };

import merge from 'lodash.merge';

// Usage:
const result = merge({ a: 1, b: { c: 2 } }, { b: { d: 3 } });
return { success: result.a === 1 && result.b.c === 2 && result.b.d === 3, result };

import omit from 'lodash.omit';

// Usage:
const result = omit({ a: 1, b: 2, c: 3 }, ['a', 'c']);
return { success: result.b === 2 && !result.a, result };

import pick from 'lodash.pick';

// Usage:
const result = pick({ a: 1, b: 2, c: 3 }, ['a', 'c']);
return { success: result.a === 1 && result.c === 3 && !result.b, result };

import set from 'lodash.set';

// Usage:
const obj = {};
set(obj, 'a.b.c', 123);
return { success: obj.a?.b?.c === 123, result: obj };

import throttle from 'lodash.throttle';

// Usage:
const fn = throttle(() => 'throttled', 100);
const result = fn();
return { success: result === 'throttled', result };

import uniq from 'lodash.uniq';

// Usage:
const result = uniq([1, 2, 2, 3, 1, 4]);
return { success: result.join(',') === '1,2,3,4', result };

import logSymbols from 'log-symbols';

// Usage:
const result = {
  success: typeof logSymbols.success === 'string',
  error: typeof logSymbols.error === 'string',
  warning: typeof logSymbols.warning === 'string',
  info: typeof logSymbols.info === 'string',
};
return { success: result.success && result.error && result.warning && result.info, result };

import log from 'loglevel';

// Usage:
log.setLevel('info');
const level = log.getLevel();
log.info('test');
return { success: typeof level === 'number', result: { level } };

import Long from 'long';

// Usage:
const val = Long.fromNumber(123456789);
const result = val.toString();
return { success: result === '123456789', result };

import { Low } from 'lowdb';

// Usage:
const db = new Low({ read: async () => ({ posts: [] }), write: async () => {} }, { posts: [] });
await db.read();
return { success: Array.isArray(db.data.posts), result: db.data };

import { LRUCache } from 'lru-cache';

// Usage:
const cache = new LRUCache({ max: 100 });
cache.set('key', 'value');
const result = cache.get('key');
return { success: result === 'value', result };

import { DateTime } from 'luxon';

// Usage:
const dt = DateTime.fromISO('2026-01-08');
const formatted = dt.toFormat('yyyy-MM-dd');
return { success: formatted === '2026-01-08', result: formatted };

import LZString from 'lz-string';

// Usage:
const compressed = LZString.compress('hello world');
const decompressed = LZString.decompress(compressed);
return { success: decompressed === 'hello world', result: { compressed, decompressed } };

import mapStream from 'map-stream';

// Usage:
const stream = mapStream((data, callback) => {
  callback(null, data * 2);
});
return { success: typeof stream === 'object', result: 'stream-utility' };

import { markdown } from 'markdown';

// Usage:
const result = markdown.toHTML('# Hello');
return { success: result.includes('<h1>'), result };

import MarkdownIt from 'markdown-it';

// Usage:
const md = new MarkdownIt();
const result = md.render('# Hello World');
return { success: result.includes('<h1>') && result.includes('Hello World'), result };

import { marked } from 'marked';

// Usage:
const result = marked('# Hello **World**');
return { success: result.includes('<h1>') && result.includes('<strong>'), result };

import { evaluate, sqrt, multiply, matrix } from 'mathjs';

// Usage:
const expr = evaluate('2 + 3 * 4');
const sqrtResult = sqrt(16);
const m = multiply(matrix([[1, 2], [3, 4]]), 2);
return { success: expr === 14, result: { expr, sqrt: sqrtResult, matrix: m.toArray() } };

import md5 from 'md5';

// Usage:
const result = md5('hello');
return { success: result === '5d41402abc4b2a76b9719d911017c592', result };

import typer from 'media-typer';

// Usage:
const parsed = typer.parse('text/html');
const formatted = typer.format({ type: 'application', subtype: 'json' });
return { success: parsed.type === 'text', result: { parsed, formatted } };

import memoizeOne from 'memoize-one';

// Usage:
let calls = 0;
const fn = memoizeOne((a, b) => { calls++; return a + b; });
fn(1, 2); fn(1, 2); fn(2, 3);
return { success: calls === 2, result: { calls } };

import memoize from 'memoizee';

// Usage:
let callCount = 0;
const expensive = memoize((x) => { callCount++; return x * 2; });
expensive(5); expensive(5); expensive(10);
return { success: callCount === 2, result: { callCount } };

import merge from 'merge';

// Usage:
const result = merge({ a: 1 }, { b: 2 });
return { success: result.a === 1 && result.b === 2, result };

import mergeStream from 'merge-stream';
import { Readable } from 'node:stream';

export default {
  async fetch(request) {
    // Create readable streams
    const stream1 = Readable.from(['Hello ', 'from ', 'stream1! ']);
    const stream2 = Readable.from(['And ', 'stream2 ', 'too!']);
    
    // Merge them
    const merged = mergeStream(stream1, stream2);
    
    // Collect all data
    const chunks = [];
    for await (const chunk of merged) {
      chunks.push(chunk);
    }
    
    return Response.json({ result: chunks.join('''') });
  }
};

import methodOverride from 'method-override';

// Usage:
const fn = methodOverride();
return { success: typeof fn === 'function', result: 'middleware function' };

import methods from 'methods';

// Usage:
return { success: Array.isArray(methods) && methods.includes('get'), result: methods.slice(0, 5) };

import micromatch from 'micromatch';

// Usage:
const result = micromatch(['foo.js', 'bar.txt'], '*.js');
return { success: result.length === 1 && result[0] === 'foo.js', result };

import mime from 'mime';

const type = mime.getType('file.json'); // 'application/json'
const ext = mime.getExtension('text/html'); // 'html'
return { success: type === 'application/json', type, ext };

import mimeTypes from 'mime-types';

// Usage:
const type = mimeTypes.lookup('test.json');
const ext = mimeTypes.extension('application/json');
return { success: type === 'application/json', result: { type, ext } };

import { minimatch } from 'minimatch';

// Usage:
const result = minimatch('foo.js', '*.js');
return { success: result === true, result };

import minimist from 'minimist';

// Usage:
const args = minimist(['--foo', 'bar', '-n', '3']);
return { success: args.foo === 'bar' && args.n === 3, result: args };

import mitt from 'mitt';

// Usage:
const emitter = mitt();
let result = '';
emitter.on('test', (data) => { result = data; });
emitter.emit('test', 'hello');
return { success: result === 'hello', result };

import { observable, autorun } from 'mobx';

// Usage:
const state = observable({ count: 0 });
let result = 0;
autorun(() => { result = state.count; });
state.count = 5;
return { success: result === 5, result };

import Mock from 'mockjs';

// Usage:
const result = Mock.mock({ 'number|1-100': 1 });
return { success: typeof result.number === 'number', result };

import moment from 'moment';

// Usage:
const date = moment('2026-01-08');
const formatted = date.format('YYYY-MM-DD');
return { success: formatted === '2026-01-08', result: formatted };

import moment from 'moment-timezone';

// Usage:
const la = moment.tz('2026-01-08 12:00', 'America/Los_Angeles');
const tokyo = la.clone().tz('Asia/Tokyo');
return { success: true, result: { la: la.format(), tokyo: tokyo.format() } };

import mqtt from 'mqtt';

// Usage: MQTT needs WebSocket URL in Workers (not TCP)
const clientId = 'worker-' + Math.random().toString(16).slice(2, 8);
// const client = mqtt.connect('wss://broker.example.com:8884');
return { success: true, result: { clientId, note: 'Use wss:// WebSocket URL, not tcp://' } };

import ms from 'ms';

// Usage:
const result = ms('2 days');
const str = ms(60000);
return { success: result === 172800000 && str === '1m', result: { parsed: result, formatted: str } };

import msgpack from 'msgpack-lite';

// Usage:
const data = { hello: 'world', num: 42 };
const encoded = msgpack.encode(data);
const decoded = msgpack.decode(encoded);
return { success: decoded.hello === 'world' && decoded.num === 42, result: decoded };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import multer from 'multer';

const app = express();
const upload = multer({ storage: multer.memoryStorage() });

app.post('/upload', upload.single('file'), (req, res) => {
  res.json({ filename: req.file.originalname, size: req.file.size });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import multimatch from 'multimatch';

// Usage:
const result = multimatch(['foo.js', 'bar.css', 'baz.html'], ['*.js', '*.css']);
return { success: result.length === 2 && result.includes('foo.js'), result };

import Mustache from 'mustache';

// Usage:
const template = 'Hello {{name}}!';
const result = Mustache.render(template, { name: 'World' });
return { success: result === 'Hello World!', result };

import * as pkg from 'mysql';

// Usage:
const keys = Object.keys(pkg);
return { success: keys.length > 0, result: { exports: keys.slice(0, 5) } };

import { nanoid } from 'nanoid';

// Usage:
const id = nanoid();
return { success: id.length === 21, result: id };

import Negotiator from 'negotiator';

// Usage:
const negotiator = new Negotiator({ headers: { accept: 'text/html,application/json;q=0.9' } });
const types = negotiator.mediaTypes();
return { success: types.includes('text/html'), result: types };

import NodeCache from 'node-cache';

// Usage:
const cache = new NodeCache();
cache.set('key', 'value', 10);
const result = cache.get('key');
return { success: result === 'value', result };

import * as emoji from 'node-emoji';

// Usage:
const result = emoji.emojify('I :heart: :coffee:!');
const hasEmoji = emoji.has(':heart:');
return { success: hasEmoji, result: { text: result, hasHeart: hasEmoji } };

import fetch from 'node-fetch';

// Usage:
return { success: true, result: 'Use native fetch instead' };

import forge from 'node-forge';

// Usage:
const md = forge.md.sha256.create();
md.update('test');
const result = md.digest().toHex();
return { success: result.length === 64, result };

import extend from 'node.extend';

// Usage:
const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const result = extend(obj1, obj2);
return { success: result.a === 1 && result.b === 3 && result.c === 4, result };

import normalizeUrl from 'normalize-url';

// Usage:
const url = normalizeUrl('https://example.com:443//foo/../bar?c=1&a=2');
return { success: url === 'https://example.com/bar?a=2&c=1', result: url };

import numeral from 'numeral';

// Usage:
const formatted = numeral(1000).format('0,0');
const value = numeral('1,000').value();
return { success: formatted === '1,000' && value === 1000, result: { formatted, value } };

import objectAssign from 'object-assign';

// Usage:
const result = objectAssign({}, { a: 1 }, { b: 2 }, { a: 3 });
return { success: result.a === 3 && result.b === 2, result };

import hash from 'object-hash';

// Key order doesn't matter
const h1 = hash({ a: 1, b: 2 });
const h2 = hash({ b: 2, a: 1 });
return { success: h1 === h2, hash: h1 };

import objectPath from 'object-path';

// Usage:
const obj = { a: { b: { c: 1 } } };
const val = objectPath.get(obj, 'a.b.c');
objectPath.set(obj, 'a.b.d', 2);
return { success: val === 1 && obj.a.b.d === 2, result: { val, obj } };

import onFinished from 'on-finished';

// Usage:
const mockRes = { 
  finished: false, 
  headersSent: false,
  on: function(event, cb) { if (event === 'finish') setTimeout(cb, 0); return this; },
  once: function(event, cb) { return this.on(event, cb); },
  removeListener: function() { return this; }
};
let called = false;
onFinished(mockRes, () => { called = true; });
return { success: true, result: 'onFinished called' };

import once from 'once';

// Usage:
let count = 0;
const fn = once(() => count++);
fn(); fn(); fn();
return { success: count === 1, result: count };

import type { OpenAPI, OpenAPIV3 } from 'openapi-types';

// Usage:
const schema: OpenAPIV3.SchemaObject = { type: 'string' };
return { success: schema.type === 'string', result: schema };

import os from 'node:os';

// Get system info
const info = {
  platform: os.platform(),
  arch: os.arch(),
  tmpdir: os.tmpdir()
};
return { success: true, info };

import pAll from 'p-all';

// Usage:
const tasks = [
  () => Promise.resolve(1),
  () => Promise.resolve(2),
  () => Promise.resolve(3)
];
const result = await pAll(tasks, { concurrency: 2 });
return { success: result.length === 3 && result[0] === 1, result };

import pLimit from 'p-limit';

// Usage:
const limit = pLimit(2);
const results = await Promise.all([
  limit(() => Promise.resolve(1)),
  limit(() => Promise.resolve(2)),
]);
return { success: true, result: results };

import pMap from 'p-map';

// Usage:
const input = [1, 2, 3];
const mapper = x => Promise.resolve(x * 2);
const result = await pMap(input, mapper, { concurrency: 2 });
return { success: result.length === 3 && result[0] === 2, result };

import PQueue from 'p-queue';

// Usage:
const queue = new PQueue({ concurrency: 1 });
const results = await Promise.all([
  queue.add(() => Promise.resolve(1)),
  queue.add(() => Promise.resolve(2)),
]);
return { success: true, result: results };

import pRetry from 'p-retry';

// Usage:
let count = 0;
const run = async () => {
  count++;
  if (count < 3) throw new Error('fail');
  return 'success';
};
const result = await pRetry(run, { retries: 5 });
return { success: result === 'success' && count === 3, result: { result, count } };

import pThrottle from 'p-throttle';

// Usage:
const throttle = pThrottle({ limit: 2, interval: 1000 });
const throttled = throttle(async (x) => x * 2);
const result = await throttled(5);
return { success: result === 10, result: { value: result } };

import pako from 'pako';

// Usage:
const input = new TextEncoder().encode('Hello, World!');
const compressed = pako.deflate(input);
const decompressed = pako.inflate(compressed);
const output = new TextDecoder().decode(decompressed);
return { success: output === 'Hello, World!', result: output };

import Papa from 'papaparse';

// Usage:
const csv = 'name,age\nJohn,30\nJane,25';
const result = Papa.parse(csv, { header: true });
return { success: result.data.length === 2, result: result.data };

import { parse } from 'parse5';

// Usage:
const doc = parse('<html><body><h1>Test</h1></body></html>');
return { success: doc.nodeName === '#document', result: { nodeName: doc.nodeName } };

import parseurl from 'parseurl';

// Usage:
const req = { url: '/path?foo=bar' };
const parsed = parseurl(req);
return { success: parsed.pathname === '/path', result: parsed.pathname };

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import session from 'express-session';
import passport from 'passport';
import { Strategy as LocalStrategy } from 'passport-local';

const app = express();
app.use(express.urlencoded({ extended: false }));
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

passport.use(new LocalStrategy((username, password, done) => {
  if (username === 'admin' && password === 'pass') return done(null, { id: 1, username });
  return done(null, false);
}));
passport.serializeUser((user, done) => done(null, user.id));
passport.deserializeUser((id, done) => done(null, { id, username: 'admin' }));

app.post('/login', passport.authenticate('local'), (req, res) => res.json({ user: req.user }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import session from 'express-session';
import passport from 'passport';
import { Strategy as LocalStrategy } from 'passport-local';

const app = express();
app.use(express.urlencoded({ extended: false }));
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

passport.use(new LocalStrategy((username, password, done) => {
  // Verify credentials against your user store
  if (username === 'admin' && password === 'pass') {
    return done(null, { id: 1, username });
  }
  return done(null, false, { message: 'Invalid credentials' });
}));

passport.serializeUser((user, done) => done(null, user.id));
passport.deserializeUser((id, done) => done(null, { id }));

app.post('/login', passport.authenticate('local'), (req, res) => {
  res.json({ success: true, user: req.user });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import session from 'express-session';
import passport from 'passport';
import { OAuthStrategy } from 'passport-oauth';

const app = express();
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

passport.use(new OAuthStrategy({
  requestTokenURL: 'https://api.example.com/oauth/request_token',
  accessTokenURL: 'https://api.example.com/oauth/access_token',
  userAuthorizationURL: 'https://api.example.com/oauth/authorize',
  consumerKey: process.env.OAUTH_CONSUMER_KEY,
  consumerSecret: process.env.OAUTH_CONSUMER_SECRET,
  callbackURL: 'https://myapp.com/auth/callback'
}, (token, tokenSecret, profile, done) => done(null, { token, profile })));

passport.serializeUser((user, done) => done(null, user));
passport.deserializeUser((user, done) => done(null, user));

app.get('/auth/provider', passport.authenticate('oauth'));
app.get('/auth/callback', passport.authenticate('oauth'), (req, res) => res.json({ user: req.user }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import session from 'express-session';
import passport from 'passport';
import OAuth2Strategy from 'passport-oauth2';

const app = express();
app.use(session({ secret: 'secret', resave: false, saveUninitialized: false }));
app.use(passport.initialize());
app.use(passport.session());

passport.use(new OAuth2Strategy({
  authorizationURL: 'https://github.com/login/oauth/authorize',
  tokenURL: 'https://github.com/login/oauth/access_token',
  clientID: process.env.GITHUB_CLIENT_ID,
  clientSecret: process.env.GITHUB_CLIENT_SECRET,
  callbackURL: 'https://myapp.com/auth/callback'
}, (accessToken, refreshToken, profile, done) => done(null, { accessToken, profile })));

passport.serializeUser((user, done) => done(null, user));
passport.deserializeUser((user, done) => done(null, user));

app.get('/auth/github', passport.authenticate('oauth2'));
app.get('/auth/callback', passport.authenticate('oauth2'), (req, res) => res.json({ user: req.user }));

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import { httpServerHandler } from 'cloudflare:node';
import express from 'express';
import passport from 'passport';
import Strategy from 'passport-strategy';

// Custom API key strategy
class ApiKeyStrategy extends Strategy {
  constructor() { super(); this.name = 'apikey'; }
  authenticate(req) {
    const apiKey = req.headers['x-api-key'];
    if (apiKey === 'valid-key') this.success({ id: 1, name: 'API User' });
    else this.fail({ message: 'Invalid API key' }, 401);
  }
}

const app = express();
app.use(passport.initialize());
passport.use(new ApiKeyStrategy());

app.get('/api/protected', passport.authenticate('apikey', { session: false }), (req, res) => {
  res.json({ user: req.user });
});

app.listen(3000);
export default httpServerHandler({ port: 3000 });

import path from 'path';

// Usage:
const result = {
  join: path.join('/foo', 'bar', 'baz.txt'),
  dirname: path.dirname('/foo/bar/baz.txt'),
  extname: path.extname('index.html')
};
return { success: result.join === '/foo/bar/baz.txt' && result.dirname === '/foo/bar' && result.extname === '.html', result };

import pathIsAbsolute from 'path-is-absolute';

// Usage:
const abs = pathIsAbsolute('/foo/bar');
const rel = pathIsAbsolute('foo/bar');
return { success: abs === true && rel === false, result: { abs, rel } };

import { match } from 'path-to-regexp';

// Usage:
const matchFn = match('/user/:id');
const result = matchFn('/user/123');
return { success: result !== false && result.params.id === '123', result };

import { PDFDocument } from 'pdf-lib';

// Usage:
const pdfDoc = await PDFDocument.create();
const page = pdfDoc.addPage([600, 400]);
page.drawText('Hello Workers!', { x: 50, y: 350, size: 30 });
const pdfBytes = await pdfDoc.save();
return { success: pdfBytes.length > 0, result: { size: pdfBytes.length } };

import pkg from 'pg';

// Usage:
const { Client } = pkg;
const client = new Client({ connectionString: 'postgresql://test' });
return { success: typeof client.connect === 'function', result: { hasClient: true } };

import picomatch from 'picomatch';

// Usage:
const isMatch = picomatch('*.js');
const result = { match: isMatch('test.js'), noMatch: !isMatch('test.css') };
return { success: result.match && result.noMatch, result };

import pify from 'pify';

// Usage:
const fn = (arg: string, callback: (err: null, result: string) => void) => {
  callback(null, arg.toUpperCase());
};
const promisified = pify(fn);
const result = await promisified('hello');
return { success: result === 'HELLO', result };

import pino from 'pino';

// Usage:
const logger = pino({ level: 'info' });
logger.info({ test: true }, 'Hello from pino');
return { success: true, result: 'logged' };

import plist from 'plist';

// Usage:
const obj = { name: 'test', version: 1 };
const xml = plist.build(obj);
const parsed = plist.parse(xml);
return { success: parsed.name === 'test', result: parsed };

import pluralize from 'pluralize';

// Usage:
const result1 = pluralize('person'); // 'people'
const result2 = pluralize('person', 1); // 'person'
const result3 = pluralize('person', 5); // 'people'
return { 
  success: result1 === 'people' && result2 === 'person' && result3 === 'people',
  result: { result1, result2, result3 }
};

import { PNG } from 'pngjs';

// Usage:
const png = new PNG({ width: 10, height: 10 });
return { success: png.width === 10, result: { width: png.width, height: png.height } };

import { darken, lighten } from 'polished';

// Usage:
const darker = darken(0.1, '#CCCCCC');
const lighter = lighten(0.1, '#333333');
return { success: typeof darker === 'string' && typeof lighter === 'string', result: { darker, lighter } };

import { h } from 'preact';
import renderToString from 'preact-render-to-string';

// Usage:
const element = h('div', null, 'Hello, World!');
const html = renderToString(element);
return { success: html.includes('Hello, World!'), result: html };

import prettyBytes from 'pretty-bytes';

// Usage:
const result = prettyBytes(1337);
return { success: result === '1.34 kB', result };

import PrettyError from 'pretty-error';

// Usage:
const pe = new PrettyError();
const err = new Error('Something went wrong');
const rendered = pe.render(err);
return { success: rendered.includes('Something went wrong'), result: { length: rendered.length } };

import prettyjson from 'prettyjson';

// Usage:
const data = { name: 'test', count: 42 };
const pretty = prettyjson.render(data);
return { success: pretty.includes('name'), result: { length: pretty.length } };

import PropTypes from 'prop-types';

// Usage:
const stringType = PropTypes.string.isRequired;
const numberType = PropTypes.number;
const objectShape = PropTypes.shape({
  name: PropTypes.string,
  age: PropTypes.number
});
return { 
  success: typeof stringType === 'function' && typeof numberType === 'function',
  result: { hasString: !!stringType, hasNumber: !!numberType, hasShape: !!objectShape }
};

import protobuf from 'protobufjs/light';

// Usage: Use protobufjs/light with pre-compiled protos
// Pre-compile with: pbjs -t static-module -o proto.js *.proto
const root = new protobuf.Root();
return { success: true, result: { note: 'Pre-compile .proto files with pbjs CLI' } };

import proxyAddr from 'proxy-addr';

// Usage:
// Create mock request object
const req = {
  connection: { remoteAddress: '127.0.0.1' },
  headers: { 'x-forwarded-for': '203.0.113.195, 70.41.3.18, 150.172.238.178' }
};

// Parse proxy address with trust function
const addr = proxyAddr(req, () => true);

return { 
  success: addr === '203.0.113.195',
  result: { address: addr }
};

import pull from 'pull-stream';

// Usage:
const result = [];
pull(
  pull.values([1, 2, 3]),
  pull.map(x => x * 2),
  pull.drain(x => result.push(x))
);
return { success: result.length === 3 && result[0] === 2, result };

import pump from 'pump';

// Usage:
const { Readable, Writable } = await import('node:stream');

const source = Readable.from(['hello', ' ', 'world']);
const chunks: string[] = [];
const dest = new Writable({
  write(chunk, encoding, callback) {
    chunks.push(chunk.toString());
    callback();
  }
});

await new Promise((resolve, reject) => {
  pump(source, dest, (err) => {
    if (err) reject(err);
    else resolve(undefined);
  });
});

return { 
  success: chunks.join('') === 'hello world',
  result: chunks.join('')
};

import Q from 'q';

// Usage:
const deferred = Q.defer();
setTimeout(() => deferred.resolve('hello'), 10);

const result = await deferred.promise;

return { 
  success: result === 'hello',
  result
};

import qs from 'qs';

// Usage:
const parsed = qs.parse('a=1&b=2');
const stringified = qs.stringify({ c: 3, d: 4 });
return { success: true, result: { parsed, stringified } };

import queryString from 'query-string';

// Usage:
const parsed = queryString.parse('a=1&b=2');
return { success: true, result: parsed };

import querystring from 'querystring';

// Usage:
const parsed = querystring.parse('foo=bar&abc=xyz&abc=123');
const stringified = querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'] });

return { 
  success: parsed.foo === 'bar' && stringified.includes('foo=bar'),
  result: { parsed, stringified }
};

import QuickLRU from 'quick-lru';

// Usage:
const lru = new QuickLRU({ maxSize: 100 });
lru.set('foo', 'bar');
lru.set('hello', 'world');

return { 
  success: lru.has('foo') && lru.get('foo') === 'bar' && lru.get('hello') === 'world',
  result: { foo: lru.get('foo'), hello: lru.get('hello'), size: lru.size }
};

import raf from 'raf';

// Usage:
let executed = false;
const id = raf(() => { executed = true; });

// Wait a bit for the callback to execute
await new Promise(resolve => setTimeout(resolve, 50));

return { 
  success: executed,
  result: { executed, id }
};

import * as R from 'ramda';

// Usage:
const result = R.map(x => x * 2, [1, 2, 3]);
return { success: true, result };

import randomBytes from 'randombytes';

// Usage:
const bytes = randomBytes(16);
return { success: bytes.length === 16, result: { length: bytes.length } };

import randomstring from 'randomstring';

// Usage:
const str = randomstring.generate(10);
return { success: str.length === 10, result: { length: str.length, sample: str } };

import rangeParser from 'range-parser';

// Usage:
const result = rangeParser(1000, 'bytes=0-499');
return { success: Array.isArray(result) && result[0].start === 0 && result[0].end === 499, result };

import { RateLimiterMemory } from 'rate-limiter-flexible';

// Usage:
const limiter = new RateLimiterMemory({ points: 5, duration: 1 });
const res = await limiter.consume('user-1', 1);
return { success: res.remainingPoints === 4, result: { remaining: res.remainingPoints } };

import getRawBody from 'raw-body';
import { Readable } from 'node:stream';

// Usage:
const stream = Readable.from(['Hello ', 'World']);
const body = await getRawBody(stream, { encoding: 'utf8' });
return { success: body === 'Hello World', result: { body } };

import rc from 'rc';

// Usage:
const config = rc('myapp', { port: 8080, host: 'localhost' });
return { success: config.port === 8080 && config.host === 'localhost', result: config };

import { createClient } from 'redis';

const client = createClient({ url: 'redis://your-redis-server:6379' });
await client.connect();
await client.set('key', 'value');
const value = await client.get('key');
return { success: true, value };

import { createStore } from 'redux';

// Usage:
const reducer = (state = 0, action) => action.type === 'INC' ? state + 1 : state;
const store = createStore(reducer);
store.dispatch({ type: 'INC' });
return { success: store.getState() === 1, result: store.getState() };

import { createLogger } from 'redux-logger';

// Usage:
const logger = createLogger();
return { success: typeof logger === 'function', result: { isFunction: typeof logger === 'function' } };

import createSagaMiddleware from 'redux-saga';

// Usage:
const sagaMiddleware = createSagaMiddleware();
return { success: typeof sagaMiddleware === 'function', result: { isFunction: typeof sagaMiddleware === 'function' } };

import { thunk } from 'redux-thunk';

// Usage:
const middleware = thunk;
return { success: typeof middleware === 'function', result: { isFunction: typeof middleware === 'function' } };

import 'reflect-metadata';

// Usage:
const metadataKey = Symbol('test');
class Test {}
Reflect.defineMetadata(metadataKey, 'value', Test);
const result = Reflect.getMetadata(metadataKey, Test);
return { success: result === 'value', result };

import regenerate from 'regenerate';

// Usage:
const set = regenerate().addRange(0x61, 0x7A); // a-z
const result = set.toString();
return { success: result.includes('[a-z]'), result };

import 'regenerator-runtime/runtime';

// Usage:
async function* asyncGen() { yield 1; yield 2; }
const gen = asyncGen();
const result = await gen.next();
return { success: result.value === 1, result: result.value };

import rp from 'request-promise';

const data = await rp({ uri: 'https://api.example.com', json: true });
return { success: true, data };

import { createSelector } from 'reselect';

// Usage:
const selectItems = state => state.items;
const selectTotal = createSelector(
  [selectItems],
  items => items.reduce((sum, item) => sum + item, 0)
);

const state = { items: [1, 2, 3, 4] };
const result = selectTotal(state);

return { success: result === 10, result };

import resolve from 'resolve';

// Usage:
const fsIsCore = resolve.isCore('fs');
const fakeIsCore = resolve.isCore('nonexistent');
return { success: fsIsCore && !fakeIsCore, result: { fsIsCore, fakeIsCore } };

import rfdc from 'rfdc';

// Usage:
const clone = rfdc();
const obj = { a: 1, b: { c: 2 } };
const cloned = clone(obj);

cloned.b.c = 3;

return { 
  success: obj.b.c === 2 && cloned.b.c === 3,
  result: { original: obj, cloned }
};

import { Promise as RSVPPromise } from 'rsvp';

// Usage:
const p = new RSVPPromise((resolve) => resolve(42));
const result = await p;

return { success: result === 42, result };

import { of, map } from 'rxjs';

// Usage:
const observable = of(1, 2, 3).pipe(
  map(x => x * 2)
);

let result = [];
await new Promise((resolve) => {
  observable.subscribe({
    next: value => result.push(value),
    complete: () => resolve(undefined)
  });
});

return { success: result.join(',') === '2,4,6', result };

import { Buffer } from 'safe-buffer';

// Usage:
const buf = Buffer.from('hello', 'utf8');
const result = buf.toString('base64');

return { success: result === 'aGVsbG8=', result };

import sanitize from 'sanitize-filename';

// Usage:
const result = sanitize('hello/world.txt');
return { success: result === 'helloworld.txt', result };

import sanitizeHtml from 'sanitize-html';

// Usage:
const dirty = '<div><script>alert("xss")</script><p>Safe content</p></div>';
const clean = sanitizeHtml(dirty);

return { success: !clean.includes('script') && clean.includes('Safe content'), result: clean };

import sax from 'sax';

// Usage:
const parser = sax.parser(true);
let tagName = '';
parser.onopentag = (node) => { tagName = node.name; };
parser.write('<xml>').close();
return { success: tagName === 'xml', result: tagName };

import semver from 'semver';

// Usage:
const valid = semver.valid('1.2.3');
const gt = semver.gt('2.0.0', '1.0.0');
const satisfies = semver.satisfies('1.5.0', '^1.0.0');

return { success: valid === '1.2.3' && gt === true && satisfies === true, result: { valid, gt, satisfies } };

import { serializeError } from 'serialize-error';

// Usage:
const error = new Error('Test error');
error.name = 'TestError';
const serialized = serializeError(error);

return { success: serialized.message === 'Test error' && serialized.name === 'TestError', result: serialized };

import sha1 from 'sha1';

// Usage:
const result = sha1('hello');
return { success: result === 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d', result };

import shallowEqual from 'shallowequal';

// Usage:
const result = shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 });
return { success: result === true, result };

import { parse } from 'shell-quote';

// Usage:
const result = parse('echo "hello world"');
return { success: result.length === 2, result };

import shortUUID from 'short-uuid';

// Usage:
// Test the generate function
const uuid = shortUUID.generate();
const isValid = typeof uuid === 'string' && uuid.length > 0;

return { success: isValid, result: { uuid } };

import { Converter } from 'showdown';

// Usage:
const converter = new Converter();
const html = converter.makeHtml('# Hello World');
return { success: html.includes('<h1') && html.includes('Hello World'), result: html };

import slash from 'slash';

// Usage:
const result = slash('foo\\bar\\baz');
return { success: result === 'foo/bar/baz', result };

import slug from 'slug';

// Usage:
const result = slug('Hello World!');
return { success: result === 'hello-world', result };

import slugify from 'slugify';

// Usage:
const slug = slugify('Hello World!');
return { success: slug === 'Hello-World!', result: slug };

import * as soap from 'soap';

// Usage:
const hasClient = typeof soap.createClientAsync === 'function';
const securityTypes = ['BasicAuthSecurity', 'BearerSecurity', 'WSSecurity'];
return { success: hasClient, result: { securityTypes, note: 'Use createClientAsync(wsdlUrl) to create SOAP client' } };

import { SourceMapConsumer } from 'source-map';

// Usage:
// Test that SourceMapConsumer is available
const hasConsumer = typeof SourceMapConsumer === 'function';
return { success: hasConsumer, result: { hasConsumer } };

import sourceMapSupport from 'source-map-support';

// Usage:
// Install source map support
sourceMapSupport.install();
return { success: true, result: 'installed' };

import split from 'split';

// Usage:
// Split is a stream transformer
const hasSplit = typeof split === 'function';
return { success: hasSplit, result: { hasSplit } };

import split from 'split2';

// Usage:
const stream = split();
return { success: typeof stream.pipe === 'function', result: 'stream created' };

import { sprintf } from 'sprintf-js';

// Usage:
const result = sprintf('Hello %s!', 'World');
return { success: result === 'Hello World!', result };

import * as stackTrace from 'stack-trace';

// Usage:
const err = new Error('test');
const trace = stackTrace.parse(err);
return { success: trace.length > 0, result: { frames: trace.length } };

import statuses from 'statuses';

// Usage:
const code = statuses('OK');
const msg = statuses(404);
return { success: code === 200 && msg === 'Not Found', result: { code, msg } };

import S from 'string';

// Usage:
const result = S('hello world').capitalize().s;
return { success: result === 'Hello world', result };

import stripAnsi from 'strip-ansi';

// Usage:
const result = stripAnsi('\u001b[31mHello\u001b[0m');
return { success: result === 'Hello', result };

import stripJsonComments from 'strip-json-comments';

// Usage:
const jsonWithComments = '{ "name": "test" /* comment */ }';
const clean = stripJsonComments(jsonWithComments);
const parsed = JSON.parse(clean);
return { success: parsed.name === 'test', result: parsed };

import superjson from 'superjson';

// Usage:
const data = { date: new Date('2026-01-10'), set: new Set([1, 2, 3]) };
const serialized = superjson.stringify(data);
const deserialized = superjson.parse(serialized);
return { success: deserialized.date instanceof Date && deserialized.set instanceof Set, result: { serialized } };

import { object, string, number } from 'superstruct';

// Usage:
const User = object({ name: string(), age: number() });
try {
  const result = User.create({ name: 'Alice', age: 30 });
  return { success: result.name === 'Alice', result };
} catch (e) {
  return { success: false, result: e.message };
}

import supportsColor from 'supports-color';

// Usage:
const result = supportsColor.stdout;
return { success: true, result: { hasBasic: result !== false } };

import table from 'text-table';

// Usage:
const t = table([['master', 'now', 'origin/master'], ['0.1.0', '4 minutes ago']]);
return { success: t.includes('master'), result: t };

import { throttle, debounce } from 'throttle-debounce';

// Usage:
const fn = () => 42;
const throttled = throttle(100, fn);
const debounced = debounce(100, fn);
return { success: typeof throttled === 'function' && typeof debounced === 'function', result: { throttled: typeof throttled, debounced: typeof debounced } };

import through from 'through';

// Usage:
// through is a stream transformer
const stream = through((data) => data);
return { success: typeof stream.write === 'function', result: { hasWrite: typeof stream.write } };

import through2 from 'through2';

// Usage:
// through2 is a stream transformer
const stream = through2((chunk, enc, callback) => {
  callback(null, chunk);
});
return { success: typeof stream.write === 'function', result: { hasWrite: true } };

import Emitter from 'tiny-emitter';

// Usage:
const emitter = new Emitter();
let called = false;
emitter.on('test', () => { called = true; });
emitter.emit('test');
return { success: called, result: { emitted: called } };

import invariant from 'tiny-invariant';

// Usage:
try {
  invariant(true, 'should not throw');
  invariant(false, 'should throw');
  return { success: false, result: 'did not throw' };
} catch (e) {
  return { success: true, result: 'threw as expected' };
}

import tinycolor from 'tinycolor2';

// Usage:
const color = tinycolor('#ff0000');
const hex = color.toHexString();
return { success: hex === '#ff0000', result: hex };

import TOML from 'toml';

// Usage:
const obj = TOML.parse('name = "Alice"\nage = 30');
return { success: true, result: obj };

import { Cookie } from 'tough-cookie';

// Usage:
const cookie = Cookie.parse('foo=bar; Path=/; Domain=example.com');
return { success: cookie && cookie.key === 'foo' && cookie.value === 'bar', result: { key: cookie?.key, value: cookie?.value } };

import traverse from 'traverse';

// Usage:
const obj = { a: 1, b: { c: 2 } };
const result = traverse(obj).map(function(x) {
  if (typeof x === 'number') this.update(x * 2);
});
return { success: result.a === 2 && result.b.c === 4, result };

// ts-essentials is type-only

// Usage:
return { success: true, result: 'ts-essentials is type-only' };

import * as tslib from 'tslib';

// Usage:
return { success: typeof tslib.__extends === 'function', result: { hasExtends: true } };

import nacl from 'tweetnacl';

// Usage:
const pair = nacl.sign.keyPair();
const message = new Uint8Array([1, 2, 3]);
const signed = nacl.sign(message, pair.secretKey);
const opened = nacl.sign.open(signed, pair.publicKey);
return { success: opened !== null && opened.length === 3, result: 'signature verified' };

import typeis from 'type-is';

const isJson = typeis.is('application/json', ['json']); // 'json'
const isHtml = typeis.is('text/html', ['html']); // 'html'
return { success: isJson === 'json' };

import { ulid } from 'ulid';

// Usage:
const id = ulid();
return { success: id.length === 26, result: id };

import _ from 'underscore';

// Usage:
const result = _.flatten([[1, 2], [3, 4]]);
return { success: true, result };

import s from 'underscore.string';

// Usage:
const result = s.capitalize('hello');
return { success: result === 'Hello', result };

import { visit } from 'unist-util-visit';

// Usage:
const tree = { type: 'root', children: [{ type: 'text', value: 'hello' }] };
const values: string[] = [];
visit(tree, 'text', (node: any) => values.push(node.value));
return { success: values[0] === 'hello', result: values };

import URI from 'urijs';

// Usage:
const uri = new URI('http://example.com/path?query=value');
return { success: uri.hostname() === 'example.com', result: { host: uri.hostname(), path: uri.path() } };

import urljoin from 'url-join';

// Usage:
const result = urljoin('https://example.com', 'path', 'to', 'file.html');
return { success: result === 'https://example.com/path/to/file.html', result };

import URL from 'url-parse';

// Usage:
const parsed = new URL('https://example.com/path?q=1');
return { success: parsed.hostname === 'example.com', result: { hostname: parsed.hostname } };

import utf8 from 'utf8';

// Usage:
const encoded = utf8.encode('hello');
const decoded = utf8.decode(encoded);
return { success: decoded === 'hello', result: { encoded, decoded } };

import * as util from 'util';

// Usage:
const result = util.format('Hello %s', 'World');
return { success: result === 'Hello World', result };

import merge from 'utils-merge';

// Usage:
const result = merge({ a: 1 }, { b: 2 });
return { success: result.a === 1 && result.b === 2, result };

import { v4 as uuidv4, validate } from 'uuid';

// Usage:
const id = uuidv4();
const isValid = validate(id);
return { success: isValid, result: id };

import * as v from 'valibot';

// Usage:
const schema = v.object({ name: v.string() });
const result = v.safeParse(schema, { name: 'Alice' });
return { success: result.success, result: result.output };

import validUrl from 'valid-url';

// Usage:
const valid = validUrl.isUri('http://example.com');
const invalid = validUrl.isUri('not a url');
return { success: valid && !invalid, result: { valid, invalid } };

import validate from 'validate-npm-package-name';

// Usage:
const valid = validate('my-package');
const invalid = validate('INVALID NAME');
return { success: valid.validForNewPackages && !invalid.validForNewPackages, result: { valid: valid.validForNewPackages, errors: invalid.errors } };

import validator from 'validator';

// Usage:
const email = validator.isEmail('test@example.com');
const notEmail = validator.isEmail('not-an-email');
return { success: email && !notEmail, result: { email, notEmail } };

import vary from 'vary';

// Usage:
// vary.append() appends field to header value
const result = vary.append('Accept', 'Accept-Encoding');
return { success: result === 'Accept, Accept-Encoding', result };

import VError from 'verror';

// Usage:
const err = new VError('test error');
return { success: err.message === 'test error', result: { message: err.message } };

import warning from 'warning';

// Usage:
// warning is a dev-only warning utility
// Just check that it's a function
const result = typeof warning === 'function';
warning(true, 'This should not warn');
return { success: result, result: 'warning is callable' };

import * as XLSX from 'xlsx';

// Usage:
const wb = XLSX.utils.book_new();
const ws = XLSX.utils.aoa_to_sheet([['Name', 'Age'], ['Alice', 30]]);
XLSX.utils.book_append_sheet(wb, ws, 'Sheet1');
const csv = XLSX.utils.sheet_to_csv(ws);
return { success: csv.includes('Alice'), result: csv };

import { parseString } from 'xml2js';

// Usage:
let result: any;
parseString('<root><name>test</name></root>', (err, res) => { result = res; });
return { success: result?.root?.name?.[0] === 'test', result };

import builder from 'xmlbuilder';

// Usage:
const xml = builder.create('root').ele('name', 'test').end();
return { success: xml.includes('<name>test</name>'), result: xml };

import { DOMParser, XMLSerializer } from '@xmldom/xmldom';

const parser = new DOMParser();
const doc = parser.parseFromString('<root><item>test</item></root>', 'text/xml');
const item = doc.getElementsByTagName('item')[0].textContent;
return { success: item === 'test', item };

import XRegExp from 'xregexp';

// Usage:
const pattern = XRegExp('(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})');
const match = XRegExp.exec('2026-01-08', pattern);
return { success: match.groups.year === '2026', result: match.groups };

import xtend from 'xtend';

// Usage:
const result = xtend({ a: 1 }, { b: 2 }, { c: 3 });
return { success: result.a === 1 && result.b === 2 && result.c === 3, result };

import YAML from 'yaml';

// Usage:
const obj = { name: 'test', age: 30 };
const str = YAML.stringify(obj);
const parsed = YAML.parse(str);
return { success: parsed.name === 'test' && parsed.age === 30, result: parsed };

import YAML from 'yamljs';

// Usage:
const obj = { name: 'test', age: 30 };
const str = YAML.stringify(obj);
const parsed = YAML.parse(str);
return { success: parsed.name === 'test' && parsed.age === 30, result: parsed };

import * as yup from 'yup';

// Usage:
const schema = yup.object({ name: yup.string().required() });
const result = await schema.validate({ name: 'Alice' });
return { success: true, result };

import { z } from 'zod';

// Usage:
const schema = z.object({ name: z.string(), age: z.number() });
const result = schema.safeParse({ name: 'Alice', age: 30 });
return { success: result.success, result: result.data };