Works on Workers

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 { 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 { 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 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 { 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 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 { 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 yaml from 'js-yaml';

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

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 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 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 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 TOML from 'toml';

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

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 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 };