# S3eidat Tools (npm · s3eidat-tools-mcp)

Free, private PDF, image, text, developer, calculator and QR tools. Runs locally; no uploads.

- Trust score: 62/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-04

## Components

- npm · `s3eidat-tools-mcp`: 62/100 (this document), [markdown](https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp.md), [page](https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp)

## Channel facts

- Registry: `npm`
- Package: `s3eidat-tools-mcp`
- Version: `0.1.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-04.

- **Supply Chain Security**: 88/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects image-size 1.2.1, reached via pptxgenjs > image-size. A fixed version is available.
  - No install/post-install scripts declared.
  - Dependency health was assessed across the 400 of 513 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 4 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 49482 tokens (~305/item across 162 items; 162 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 99/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 98% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "image_exif_strip" implies "remove" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 163 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the S3eidat Tools MCP server?

S3eidat Tools runs locally as an npm package, launched with npx -y s3eidat-tools-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add s3eidat-s3eidat-tools-mcp -- npx -y s3eidat-tools-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "s3eidat-s3eidat-tools-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "s3eidat-tools-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "s3eidat-s3eidat-tools-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "s3eidat-tools-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add s3eidat-s3eidat-tools-mcp -- npx -y s3eidat-tools-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "s3eidat-s3eidat-tools-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "s3eidat-tools-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add s3eidat-s3eidat-tools-mcp --command npx --arg -y --arg s3eidat-tools-mcp
```

### Hermes

```yaml
mcp_servers:
  s3eidat-s3eidat-tools-mcp:
    command: "npx"
    args: ["-y", "s3eidat-tools-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "s3eidat-s3eidat-tools-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "s3eidat-tools-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add s3eidat-s3eidat-tools-mcp -t stdio -c npx -a -y s3eidat-tools-mcp
```

### Other

```json
{
  "mcpServers": {
    "s3eidat-s3eidat-tools-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "s3eidat-tools-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-31 (score 62, +15)

- [security regression] CVE-2026-118764 affects this package: high
- [security improvement] Malware scan: unverified → pass

### 2026-10-30 (score 47)

First indexed and scored.

## MCP tools (162)

### `ai_chart` (~457 tokens)

Chart to SVG/PNG

Render a chart to an SVG or PNG file, offline. Either give a simple description ({ type: bar|line|area|pie|scatter, data: rows, x, y, color?, title? }; y may be a list of fields for multi-series line/bar charts), or a full Vega-Lite (or Vega) spec in "spec" with the rows inline in data.values. Field types are inferred (numbers = quantitative, ISO dates = temporal, other = categories). Loading data or images from URLs or files is refused. Up to 50,000 rows. PNG is rasterised from the SVG at "scale" (default 2×).

Input parameters:

- `background` (string): Background colour. Default white; "transparent" for none.
- `color` (string): Optional field that splits the data into coloured series.
- `data` (array): Rows for the simple chart, e.g. [{"month":"Jan","sales":12}].
- `format` (string): Output format: svg (default) or png.
- `height` (integer): Plot height in px (default 360).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `scale` (number): PNG only: pixel density multiplier (2 = twice the SVG size, sharp on high-DPI screens). Default 2.
- `spec` (object): A full Vega-Lite spec (or Vega, if its $schema says so). Data must be inline (data.values). Use this or "type".
- `title` (string)
- `type` (string): Simple chart type. Use with data, x and y.
- `width` (integer): Plot width in px (default 600; pie 360).
- `x` (string): Field for the x axis (the category / slice label for pie).
- `y`: Numeric field for the y axis (slice size for pie). A list of fields draws one series per field.

### `ai_chunk_text` (~437 tokens)

Chunk text for RAG

Split text, markdown or a text file into token-sized chunks for retrieval (RAG) and embeddings. Splits at markdown headings (ATX "#" headings, never inside code fences) and paragraphs first, then sentences (lines inside code blocks), and only cuts mid-sentence when a single sentence is longer than maxTokens. Consecutive chunks of the same section share about overlapTokens of text. Each chunk returns index, text, tokens, startChar/endChar (JavaScript string offsets, end exclusive, so text === source.slice(startChar, endChar) once CRLF line endings are normalised to \n) and the heading path it sits under. Tokens are counted with tiktoken (o200k_base by default; for Claude treat counts as estimates). Give "text" or "path" (file path or base64); give "output" to also write the chunks as JSONL (one JSON object per line).

Input parameters:

- `encoding` (string): Tokenizer: "o200k_base" (GPT-4o / o-series, default) or "cl100k_base" (GPT-4 / GPT-3.5 / text-embedding-3).
- `includeText` (boolean): Return each chunk's text inline. Default: true, or false when "output" is given.
- `markdown` (boolean): Treat "#" lines as section headings (default true). Set false for plain text.
- `maxChunks` (integer): Most chunks to return inline (the JSONL file always has all). Default 2000.
- `maxTokens` (integer): Largest chunk, in tokens. Default 500.
- `output` (string): Also write the chunks as JSONL to this file (or folder ending in "/").
- `overlapTokens` (integer): Tokens repeated from the end of the previous chunk (same section only). Default 50. Must be below maxTokens.
- `path` (string): Or: a UTF-8 text/markdown file, as a local path or base64 (raw or a data: URI).
- `text` (string): The text (inline).

### `ai_create_pptx` (~276 tokens)

Create a PowerPoint deck

Build a 16:9 PowerPoint (.pptx) deck from a simple outline: an optional title slide, then slides with a title plus any of bullets (nested), a paragraph, an image (file path or base64), a table (first row = header; long tables continue on extra slides), a native editable chart (bar, line, pie) and speaker notes. Light or dark theme with clean, readable defaults; text plus a visual are laid out side by side. Arabic/Hebrew text is set right-to-left. Up to 300 slides. Opens in PowerPoint, Keynote, Google Slides and LibreOffice.

Input parameters:

- `author` (string)
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `slideNumbers` (boolean): Show slide numbers on content slides. Default true.
- `slides` (array, required)
- `subtitle` (string): Subtitle on the title slide.
- `theme` (string)
- `title` (string): Deck title: adds a title slide and sets the file title.

### `ai_create_xlsx` (~339 tokens)

Create an Excel workbook (.xlsx)

Build a real Excel .xlsx file from data: one or more sheets, each with optional column definitions (header, key, width, numFmt) and rows given as objects or arrays. Bold shaded header, frozen header row and filter buttons (both on by default), column widths fitted to the content, Excel number formats (raw codes like "#,##0.00" or aliases: integer, number, percent, currency, usd, eur, gbp, date, datetime, time, text), strings starting with "=" written as live formulas (=SUM(B2:B9), =B2*C2, cross-sheet refs), ISO date strings written as real dates, and an optional totals row (SUM/AVERAGE/COUNT/MIN/MAX formulas). Up to 50 sheets and 1,000,000 rows per sheet. Formulas are calculated by Excel when the file is opened. Writes to "output" (default "workbook.xlsx" in the output folder) and returns the path and a summary of each sheet.

Input parameters:

- `author` (string): Author in the file properties.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `parseDates` (boolean): Write ISO date strings as Excel dates (default true).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `sheets` (array, required)
- `title` (string): Workbook title (file properties, and the default file name).

### `ai_csv_profile` (~326 tokens)

Profile a table (CSV, JSON, XLSX)

Profile a table to understand and clean it before analysis: row and column counts, and per column the inferred type (integer, number, boolean, date, datetime, string), non-null and null counts, unique count, top 5 values, sample values, min/max/mean/median/stddev for numbers, min/max for ISO dates, min/max length for text, plus data-quality warnings (mixed types, leading/trailing spaces, mostly missing, constant columns, duplicate rows, ragged headers). Input: "file" (local path or base64 of CSV, TSV, JSON array, JSONL or .xlsx, first sheet or "sheet") or inline "csv" / "json". Empty cells, "null" and "NULL" count as missing. Runs locally; nothing is uploaded.

Input parameters:

- `columns` (array): Only profile these columns (default: all).
- `csv` (string): Or: CSV/TSV text inline (delimiter detected; first row is the header).
- `file` (string): A table file: local path (absolute, or relative to --root) or base64. CSV, TSV, JSON array, JSONL or .xlsx.
- `format` (string): Force the file format (default "auto": by extension, then by content).
- `json`: Or: JSON inline: an array of objects (or of arrays, first one the header), as a value or as JSON/JSONL text.
- `sheet` (string): For .xlsx: the sheet name to read (default: the first sheet).

### `ai_detect_language` (~250 tokens)

Detect language

Detect the language of a text with franc-min (82 languages with 8M+ speakers, ISO 639-3 codes) and the writing systems it uses (Latin, Arabic, Cyrillic, Han/CJK, Hangul, Devanagari, Greek, Hebrew, Thai…). Returns the top 3 candidates with scores (1 = best match, relative to the others), English names and ISO 639-1 codes where they exist, plus a share per script. Texts under 20 characters are "too short": only the script is reported. Works best on a sentence or more of one language; for mixed text the dominant script wins; long texts are judged on their first 100,000 characters. Hebrew is not among the languages (script only). Give "text" or "path" (file path or base64).

Input parameters:

- `only` (array): Restrict to these ISO 639-3 codes (e.g. ["arb","eng","fra"]).
- `path` (string): Or: a UTF-8 text/markdown file, as a local path or base64 (raw or a data: URI).
- `text` (string): The text (inline).

### `ai_diagram` (~392 tokens)

Diagram to SVG/PNG

Draw a flowchart / graph diagram from a tiny text language and save it as SVG or PNG, laid out automatically (dagre). One statement per line: `direction: LR` (TB, LR, BT, RL), `title: My flow`, `A [shape=diamond, label="Ready?", color=#fde68a]` (shapes: box, round, diamond, circle, ellipse), edges `A -> B: label`, chains `A -> B -> C`, `-->` dashed, `==>` thick, `<->` both ends, `--` no arrow; quote names with spaces ("Start here" -> A); `\n` in labels breaks lines; # starts a comment. Or pass JSON { nodes: [{id, label, shape, color}], edges: [{from, to, label, style, arrow}] } as "graph". Up to 500 nodes and 2000 edges. Labels use Helvetica/Arial metrics (Latin text is measured best).

Input parameters:

- `direction` (string): Override the layout direction: TB (top-bottom, default), LR, BT, RL.
- `format` (string): Output format: svg (default) or png.
- `graph` (object): The diagram as JSON instead of "source".
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `scale` (number): PNG only: pixel density multiplier (2 = twice the SVG size, sharp on high-DPI screens). Default 2.
- `source` (string): Diagram text in the DSL (or a JSON graph as text).
- `theme` (string)

### `ai_docx_to_markdown` (~266 tokens)

Word (.docx) to Markdown

Convert a Word .docx document to Markdown: headings (from Heading styles), bold/italic, lists, links, tables, footnotes. Images become placeholders like ![](image-1.png) unless embedImages is true (then data: URIs, which can be very large). Returns the number of conversion warnings (unrecognised styles and the like) and the first few messages. Old binary .doc files are not supported. Accepts a local path or base64. Inline Markdown is cut at maxChars (default 200k); "output" saves it to a file. Runs locally; nothing is uploaded.

Input parameters:

- `embedImages` (boolean): Embed images as base64 data: URIs instead of placeholders. Default false.
- `file` (string, required): The .docx document: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.

### `ai_extract_entities` (~382 tokens)

Extract entities

Pull structured items out of text or a text file, deduplicated with counts: emails, URLs, phone numbers (libphonenumber, validated, E.164 plus type/country; local numbers read with defaultRegion, default JO), dates (ISO, D/M/Y or M/D/Y, Y/M/D, English month names; normalised to YYYY-MM-DD; a date like 03/04/2024 is flagged ambiguous with the other reading), money ($, €, £, JOD/JD/د.أ, SAR/ر.س, AED/د.إ, KWD, EGP… and Arabic currency words, with amount and ISO currency), percentages, #hashtags, @mentions, IPv4/IPv6, IBANs (country length and mod-97 checked) and card-like numbers (only Luhn-valid ones with a known brand prefix, always masked: only the last 4 digits are shown, the full number is never returned). Arabic-Indic digits are understood. Regex-based, not NLP: no names, places or organisations. Give "text" or "path" (file path or base64).

Input parameters:

- `defaultRegion` (string): Two-letter country for local phone numbers, regional currencies (dinar, riyal…) and D/M/Y vs M/D/Y. Default JO.
- `maxPerType` (integer): Most unique items to return per type. Default 500.
- `path` (string): Or: a UTF-8 text/markdown file, as a local path or base64 (raw or a data: URI).
- `text` (string): The text (inline).
- `types` (array): Only these types (default all): emails, urls, phones, dates, money, percentages, hashtags, mentions, ipv4, ipv6, ibans, cards.

### `ai_file_identify` (~204 tokens)

Identify a file type

Find out what a file really is from its content (magic bytes, via file-type: images, video, audio, archives, Office, PDF, fonts, executables… ~150 formats), not its name. Reports the detected type and MIME, whether the extension disagrees with the content, size, SHA-256, and for text files an encoding guess (UTF-8, UTF-8/16/32 with BOM, UTF-16 without BOM, ASCII, 8-bit legacy) plus a text kind (JSON, XML, SVG, HTML…). Accepts a file path or base64. Nothing is executed.

Input parameters:

- `file` (string, required): The file to identify: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `name` (string): File name to compare the extension against (handy for base64 input). Default: the path's own name.

### `ai_html_to_markdown` (~356 tokens)

HTML to Markdown

Convert HTML to clean Markdown for reading or feeding to a model: headings, lists, links, images, code blocks, GitHub-style tables and strikethrough. Give the HTML inline ("html") or as a file ("path": local path or base64). Optional "readable" keeps only the main article (Mozilla Readability, falls back to the whole body), "selector" converts only matching elements, "baseUrl" makes relative links absolute, "includeLinks": false drops link URLs and images. Scripts, styles and forms are removed. Inline Markdown is cut at maxChars (default 200k) with a note; give "output" to save the whole thing to a .md file. Runs locally; nothing is uploaded.

Input parameters:

- `baseUrl` (string): URL the HTML came from, to make relative links and images absolute.
- `html` (string): The HTML text. Give this or "path".
- `includeLinks` (boolean): Keep links and images. False turns links into plain text and drops images.
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.
- `path` (string): An .html file instead of "html": local path or base64.
- `readable` (boolean): Keep only the main content (article text), dropping navigation, ads and footers.
- `selector` (string): CSS selector: convert only the matching elements (e.g. "main", "article .post").

### `ai_image_diff` (~329 tokens)

Compare two images

Compare two images pixel by pixel (pixelmatch, anti-aliasing aware) and write a diff PNG with changed pixels in red over a faded copy of the first image. Returns the number and percentage of different pixels. Images must be the same size unless resize is true (the second is stretched to the first's size). Reads PNG, JPEG, WebP, AVIF, GIF (first frame), TIFF and SVG; file path or base64; up to 50 MP. Good for visual regression checks.

Input parameters:

- `a` (string, required): The first (reference) image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `b` (string, required): The second image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `includeAA` (boolean): Count anti-aliased edge pixels as differences too. Default false.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `resize` (boolean): Resize the second image to the first one's size when they differ (otherwise that is an error).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `threshold` (number): Colour difference tolerance 0..1; smaller is stricter. Default 0.1.

### `ai_json_schema_infer` (~398 tokens)

Infer a JSON Schema from samples

Generate a JSON Schema (draft 2020-12) from one or more sample JSON values: types (integer vs number, mixed types as a type list), "null" added where a value can be null, required = keys present in every sample object, array items merged across all elements, string formats guessed when every sample matches (date-time, date, email, uri, uuid), and optional enums for small repeated string sets. Give "samples" (an array of sample values), or "text" (JSON, or JSONL = one sample per line), or "file" (path or base64 of a .json/.jsonl file). An array sample describes an array; to treat its elements as separate samples set eachItem. Pure local code; optionally writes the schema to "output".

Input parameters:

- `additionalProperties` (boolean): false adds additionalProperties: false to every object (strict). Default true (left open).
- `eachItem` (boolean): If the only sample is an array, use its elements as the samples (schema of one record). Default false.
- `enums` (boolean): Emit "enum" for string fields with few distinct values that repeat. Default false.
- `file` (string): Or: a .json/.jsonl file (local path or base64).
- `formats` (boolean): Guess string formats (default true).
- `maxEnumValues` (integer): Largest string set turned into an enum (default 8).
- `output` (string): Optional: also write the schema as a .json file here.
- `required` (boolean): List keys present in every sample as "required" (default true).
- `samples` (array): Sample values; each element is one sample.
- `text` (string): Or: JSON text (one sample) or JSONL (one sample per line).
- `title` (string): Optional "title" for the schema.

### `ai_json_schema_validate` (~301 tokens)

Validate JSON against a JSON Schema

Validate JSON data against a JSON Schema with Ajv, reporting every error (allErrors) with its instancePath (JSON Pointer), schemaPath, keyword, message and params. Draft 2020-12 is used when the schema's $schema says 2020-12 (2019-09 likewise), otherwise draft-07 (draft-04/06 schemas are checked as draft-07). Formats checked: date, time, date-time, email, hostname, ipv4, ipv6, uri, uri-reference, uuid, regex, json-pointer (other formats are ignored and listed). Data: inline "data" (any JSON value), "dataText" (JSON text) or "dataFile" (path or base64). Schema: inline "schema" (object or JSON text) or "schemaFile". Remote $ref URLs are never fetched. Runs locally.

Input parameters:

- `data`: The JSON value to validate, inline (a string here is validated as a string; use dataText for JSON text).
- `dataFile` (string): Or: a JSON file (local path or base64).
- `dataText` (string): Or: the data as JSON text.
- `maxErrors` (integer): Most errors to return (default 100).
- `schema`: The JSON Schema inline: an object (or JSON text).
- `schemaFile` (string): Or: a JSON Schema file (local path or base64).

### `ai_markdown_to_docx` (~394 tokens)

Markdown to Word (.docx)

Convert Markdown (GitHub flavoured) to a real Word .docx: headings H1-H6 (Word heading styles, so the navigation pane and table of contents work), paragraphs with bold, italic, strikethrough, inline code and clickable links, bullet and numbered lists (nested, numbering restarts per list, task-list checkboxes), tables (header row shaded, column alignment kept), blockquotes, fenced code blocks in a monospace font, horizontal rules, and a page break wherever a line says \newpage. Arabic/Hebrew paragraphs are laid out right-to-left automatically (rtl: "auto"). Images are not embedded (their alt text is shown); raw HTML tags are dropped. Options: title and author (document properties), font (default Calibri), fontSize. Give "markdown" inline or "path" to a .md file. Writes the .docx to "output" (default name from the title or first heading).

Input parameters:

- `author` (string): Author shown in the file properties.
- `font` (string): Body font (default Calibri).
- `fontSize` (number): Body font size in points (default 11).
- `markdown` (string): The Markdown text inline.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `path` (string): Or: a Markdown file (local path or base64).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `rtl` (string): Right-to-left paragraphs: "auto" (detect Arabic/Hebrew per paragraph), "on" or "off".
- `title` (string): Document title (file properties, and the default file name).

### `ai_markdown_to_pdf` (~461 tokens)

Markdown to PDF

Turn Markdown (GitHub-flavoured) into a clean, paginated A4/Letter/A5 PDF: headings, paragraphs with word wrap, bold/italic/strikethrough, inline code, links (clickable), bullet / numbered / task lists (nested), tables (wrapped cells, header repeated on new pages), blockquotes, code blocks, horizontal rules, local images (relative to the Markdown file; remote images are never fetched and show as alt text), page breaks (\pagebreak, \newpage or <!-- pagebreak -->), page numbers, margins and title metadata. Text uses the built-in PDF fonts: Latin text only (English and Western European). Arabic, CJK and other scripts are not supported yet: such characters are replaced with "?" (or rejected with onUnsupportedChar: "error"); emoji are dropped; arrows and common symbols are transliterated. Give "markdown" inline or "path" to a .md file.

Input parameters:

- `author` (string)
- `font` (string): Body font: sans (Helvetica) or serif (Times). Code is always Courier.
- `fontSize` (number): Body font size in pt. Default 10.5.
- `landscape` (boolean)
- `margin` (number): Page margin in mm. Default 20.
- `markdown` (string): Markdown text. Use this or "path".
- `onUnsupportedChar` (string): What to do with characters the PDF fonts can't show: replace with "?" (default) or fail.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pageNumbers` (boolean): Print "n / total" at the bottom of each page. Default true.
- `paper` (string)
- `path` (string): A .md file: local path or base64. Relative image links resolve against its folder.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `title` (string): PDF title metadata. Default: the first # / ## heading.

### `ai_media_info` (~204 tokens)

Audio/video metadata

Read audio and video file metadata offline (music-metadata): container, codec, duration, bitrate, sample rate, bit depth, channels, lossless or not, tags (title, artist, album, year, genre, track…), embedded cover art, and per-track info (including video width/height for MP4/MKV/WebM). Formats: MP3, AAC/M4A/MP4/MOV, FLAC, WAV, AIFF, OGG/Opus/Vorbis, WebM/Matroska, WMA/ASF, APE, WavPack, DSD and more. File path (streamed, any size) or base64. Duration of VBR MP3s without a header is computed by scanning the file.

Input parameters:

- `file` (string, required): The audio or video file: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).

### `ai_ocr` (~398 tokens)

OCR (image or scanned PDF to text)

Read the text in an image (PNG, JPEG, WebP, TIFF incl. multi-page, GIF, AVIF) or a scanned PDF with Tesseract (tesseract.js), fully offline: the English and Arabic models ship with the server and nothing is downloaded or uploaded. Languages: "eng", "ara" or "eng+ara" (default). PDF pages are rendered at 200 dpi by default. Returns the text per page and the mean word confidence (0-100); give "output" to also write a .txt file. Limits: up to 200 pages per call, roughly 1-5 s per page; printed text works well, handwriting and very small or skewed text poorly. For PDFs that already have a text layer, pdf_to_text is faster and exact. Give "file" as a local path or base64.

Input parameters:

- `dpi` (integer): Render resolution for PDF pages. Default 200.
- `file` (string, required): The image or PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `languages` (string): Languages to read. Default "eng+ara".
- `maxChars` (integer): Cut the inline text after this many characters (the file is never cut).
- `output` (string): Also write the text to this .txt file (or folder ending in "/").
- `pages` (string): PDF pages / TIFF frames, e.g. "1-3, 5" (default all).
- `perPage` (boolean): Also return the text of each page separately in "pages". Default false (the joined "text" has page separators).
- `psm` (string): Page layout: "auto" (default), "block" (one uniform block), "line", "word", or "sparse" (scattered text).

### `ai_pdf_to_markdown` (~316 tokens)

PDF to Markdown

Convert a text PDF to structured Markdown: headings guessed from font size (text clearly larger than the body becomes #, ##, ###), paragraphs rebuilt from line spacing with hyphenated words mended, bullet and numbered lists kept, right-to-left lines in reading order. Optional page range ("1-5, 8") and page markers. Scanned PDFs without a text layer give empty pages (listed in pagesWithoutText; run OCR first). Tables and columns are read line by line. Accepts a local path or base64. Inline Markdown is cut at maxChars (default 200k); "output" saves it to a file.

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.
- `pageMarkers` (boolean): Put "<!-- Page N -->" before each page and "---" between pages. Default false.
- `pages` (string): Pages to convert, e.g. "1-3, 7" or "5-" (1-based). Default: all.
- `password` (string): Password, if the PDF is protected.

### `ai_pptx_to_markdown` (~294 tokens)

PowerPoint (.pptx) to Markdown

Extract the text of a PowerPoint .pptx deck as Markdown: one "## Slide N: title" section per slide in presentation order, text boxes as paragraphs and bullet lists (with indent levels), tables as Markdown tables, and speaker notes as a quote under each slide. Images, charts and SmartArt text are not extracted. Old binary .ppt is not supported. Optional "slides" range (e.g. "1-5, 8"). Accepts a local path or base64. Inline Markdown is cut at maxChars (default 200k); "output" saves it to a file. Runs locally; nothing is uploaded.

Input parameters:

- `file` (string, required): The .pptx presentation: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `notes` (boolean): Include speaker notes. Default true.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.
- `slides` (string): Slides to include, e.g. "1-3, 7" or "5-" (1-based). Default: all.

### `ai_sql_query` (~416 tokens)

SQL query over tables

Run one read-only SQL SELECT (alasql dialect: JOIN, GROUP BY, HAVING, ORDER BY, LIMIT, UNION, WITH, subqueries, CASE, SUM/COUNT/AVG/MIN/MAX/MEDIAN/STDEV, string and date functions) over one or more tables. Each table is { name, file | csv | json }: a local path or base64 of a CSV, TSV, JSON array, JSONL or .xlsx (first sheet, or "sheet"), or inline CSV text / JSON rows. CSV cells are typed (numbers, true/false, empty → null; ISO dates stay ISO text, so they sort and compare correctly; YEAR()/MONTH() work on them). Only SELECT is allowed: INSERT/UPDATE/DELETE/DROP/CREATE/ALTER/ATTACH, SELECT INTO, file readers like FROM CSV(...), inline JavaScript and the -> operator are refused. Table names are case-sensitive; quote odd column names and reserved words (total, value, count, date…) as [My Column]. Returns columns and up to maxRows rows (default 500) with the total count; set "output" (.csv, .tsv, .json, .jsonl or .xlsx) to save every row to a file. Runs locally; nothing is uploaded.

Input parameters:

- `maxRows` (integer): Rows to return inline (default 500). "total" always counts all rows.
- `output` (string): Optional: save ALL result rows to this file; the type comes from the extension (.csv, .tsv, .json, .jsonl, .xlsx; default .csv).
- `query` (string, required): One SELECT statement, e.g. SELECT region, SUM(amount) AS revenue FROM sales GROUP BY region ORDER BY revenue DESC
- `tables` (array, required): The tables the query can read (1-20).
- `types` (boolean): Type CSV cells (numbers, booleans, null). Default true; false keeps every CSV cell as text.

### `ai_text_similarity` (~381 tokens)

Text similarity and near-duplicates

Compare two or more texts (or text files) for overlap. For every pair returns: Jaccard similarity of word shingles (k=3 words by default), a MinHash estimate of that Jaccard (128 hashes), and cosine similarity of word frequencies. Words are lower-cased, punctuation and Arabic diacritics ignored. Measures wording overlap, not meaning (no embeddings): paraphrases score low. Mode "pairs" (default) lists pairs sorted by the chosen metric; mode "dedupe" groups near-duplicates whose metric is at least "threshold" (default 0.8; groups are connected, so A~B and B~C put A, B, C together). Give "texts" (inline strings) and/or "paths" (file paths or base64). Up to 1000 texts.

Input parameters:

- `labels` (array): Optional names for the texts, in order (texts first, then paths). Default: "#1", "#2"… or the file name.
- `maxPairs` (integer): Most pairs to return (highest first). Default 200.
- `metric` (string): Metric used to sort pairs and to group duplicates. Default jaccard.
- `mode` (string): "pairs" (similarity of each pair) or "dedupe" (groups of near-duplicates).
- `numHashes` (integer): MinHash signature length. Default 128 (error about ±0.09).
- `paths` (array): Or/also: UTF-8 text files (local paths or base64).
- `shingleSize` (integer): Words per shingle (k). Default 3.
- `texts` (array): Texts to compare (inline).
- `threshold` (number): Dedupe: pairs at or above this are duplicates. Default 0.8.

### `ai_token_count` (~279 tokens)

Count tokens

Count LLM tokens in a text or text file with the OpenAI tiktoken tokenizers ("o200k_base", default, used by GPT-4o and the o-series; or "cl100k_base", used by GPT-4/3.5 and text-embedding-3). Also returns characters and words, and whether the text fits in common context windows (8k, 32k, 128k, 200k, 1M: e.g. "fits in 200k: yes"). Claude's tokenizer is not public, so for Claude the count is an estimate (typically within ~10-20%; Claude usually needs a little more), returned as a rough range. Runs locally, no API calls. Give "text" or "path" (file path or base64). Large texts (many MB) take a few seconds.

Input parameters:

- `encoding` (string): Tokenizer: "o200k_base" (GPT-4o / o-series, default) or "cl100k_base" (GPT-4 / GPT-3.5 / text-embedding-3).
- `path` (string): Or: a UTF-8 text/markdown file, as a local path or base64 (raw or a data: URI).
- `text` (string): The text (inline).

### `ai_web_fetch` (~352 tokens)

Fetch a web page as Markdown

Fetch a web page (http/https) and return its readable content as clean Markdown, with title, byline, final URL after redirects and a word count. Uses Mozilla Readability to keep the main article (falls back to the whole page), or a CSS "selector" you give. Respects robots.txt (refuses pages disallowed for the s3eidat-tools-mcp user agent), only reads HTML and text responses, stops at 5 MB and 20 seconds, follows up to 5 redirects, and refuses private, local and loopback addresses unless allowPrivate is true. Does not run JavaScript, so pages that build their content in the browser may come back nearly empty. Inline Markdown is cut at maxChars (default 200k); "output" saves it to a file.

Input parameters:

- `allowPrivate` (boolean): Allow private, local and loopback hosts (e.g. a dev server on localhost). Default false.
- `includeLinks` (boolean): Keep links (made absolute) and images. False turns links into plain text and drops images.
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.
- `readable` (boolean): Keep only the main content (default true). False converts the whole page body.
- `selector` (string): CSS selector: convert only the matching elements instead of the Readability main content.
- `url` (string, required): The page to fetch (http:// or https://).

### `ai_xlsx_to_markdown` (~345 tokens)

Excel (.xlsx/.csv) to Markdown tables

Turn an Excel .xlsx workbook (or a .csv/.tsv file) into Markdown tables, one "## sheet" section per sheet, or only the sheet you name. The first used row is the table header; empty rows and columns around the data are dropped. Formulas show their cached result (as last saved by Excel), dates are ISO (2026-10-30, or 2026-10-30T14:05:00), merged cells show their value once, hyperlinks become Markdown links. Each sheet shows at most maxRows data rows (default 200) and says how many were left out. Old binary .xls is not supported. Accepts a local path or base64. Runs locally.

Input parameters:

- `file` (string, required): The .xlsx or .csv file: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `format` (string): Input format. "auto" tells .xlsx (a ZIP) from CSV by its bytes.
- `maxChars` (integer): Cut the inline Markdown after this many characters, with a note (a file written with "output" is never cut). Default 200000.
- `maxRows` (integer): Data rows to show per sheet (after the header). Default 200.
- `output` (string): Write the Markdown to this file (or folder ending in "/") and return its path instead of the inline text.
- `sheet` (string): Only this sheet: its name, or its 1-based position (e.g. "2"). Default: every sheet.

### `ai_zip` (~310 tokens)

ZIP create / extract / list

Work with ZIP archives locally. action "create": zip files and folders (given as paths; folders keep their own name as the top folder, symlinks are skipped) into one .zip. action "extract": unpack a .zip (path or base64) into the "output" folder; entries with "..", absolute paths or drive letters are refused (zip-slip protection), existing files are kept unless overwrite is true. action "list": entry names with sizes, no extraction. Limits: total uncompressed size 500 MB and 10000 files by default (maxTotalMB / maxFiles). Encrypted ZIPs are not supported.

Input parameters:

- `action` (string, required)
- `files` (array): create: files and folders to add (local paths).
- `level` (integer): create: compression level 0 (store) to 9 (smallest). Default 6.
- `maxFiles` (integer): Cap on the number of entries. Default 10000.
- `maxTotalMB` (number): Cap on the total uncompressed size, MB. Default 500.
- `output` (string): create: the .zip path (or a folder ending in "/"). extract: the folder to extract into. Default: the server output folder.
- `overwrite` (boolean): extract: replace files that already exist in the output folder. Default false (they are skipped).
- `zip` (string): extract / list: the ZIP archive, a local path or base64.

### `barcode_generate` (~431 tokens)

Barcode generator

Make 1D barcodes as SVG or PNG: Code 128 (any printable ASCII; digit runs packed with subset C automatically), EAN-13 (12 digits, check digit added; or 13, check digit verified), UPC-A (11 or 12 digits, same) and Code 39 (A-Z, 0-9, space, - . $ / + %, optional mod-43 check). Same encoders, quiet zones, guard bars and human-readable digits as the website. Give "value" for one barcode, or "values" (up to 1000) to write one file per value into a folder; invalid values are reported, not fatal. PNG text uses the system monospace font. Web version: https://s3eidat.github.io/barcode-gen/

Input parameters:

- `background` (string): Background colour, hex.
- `barWidth` (integer): Narrow bar (module) width in px, 1-6 (default 2).
- `code39Check` (boolean): Code 39 only: append the mod-43 check character.
- `foreground` (string): Bar colour, hex.
- `format` (string): Output format (default svg).
- `height` (integer): Bar height in px, 30-220 (default 80).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `scale` (integer): PNG only: pixel scale (1×, 2× default, 4×…).
- `showText` (boolean): Print the human-readable text/digits under the bars.
- `symbology` (string): Barcode type (default code128).
- `value` (string): The value to encode (one barcode).
- `values` (array): Or: many values; each becomes its own file in the output folder.

### `base_convert` (~281 tokens)

Number base convert

Convert a whole number of any size (BigInt) between bases 2–36: binary, octal, decimal, hex, base 36 or any other. Input base can be auto-detected from 0x / 0b / 0o prefixes; spaces, _ and , separators are ignored; negatives OK. Also shows bit length and the two's complement view (signed/unsigned value, hex, bits) at 8/16/32/64 bits, and whether it fits. Fractions are not supported (same as the website). Web version: https://s3eidat.github.io/base-convert/

Input parameters:

- `from`: Input base 2–36, or "auto" (prefix, else decimal).
- `group` (boolean): Group digits like the website (binary/hex by 4, octal by 3, decimal with commas).
- `to` (array): Output bases. Default [2, 8, 10, 16, 36].
- `uppercase` (boolean): Upper-case letters for bases above 10.
- `value` (string, required): The number, e.g. "0xC0FFEE", "-0b101", "1_000_000", "zz" (with from=36).
- `width`: Bit width for the two's complement view.

### `base64_decode` (~197 tokens)

Base64 decode

Decode Base64 (standard or URL-safe, padding optional, whitespace and data: URI prefix allowed). Valid UTF-8 text is returned inline; binary data (or anything when "output" is given) is written to a file whose extension comes from the detected type (PNG, JPEG, GIF, WebP, BMP, PDF, ZIP, gzip, MP3, Ogg, MP4, WOFF2, SVG, JSON). Web version: https://s3eidat.github.io/base64-kit/

Input parameters:

- `base64` (string, required): The Base64 text to decode (may be a data: URI).
- `fileName` (string): Base name for the written file (extension follows the detected type). Default "decoded".
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).

### `base64_encode` (~246 tokens)

Base64 encode

Encode text (as UTF-8) or a file (path or base64) to Base64. Options: URL-safe alphabet (- and _, no padding), wrap at 76 columns (MIME), or a data: URI for files (MIME type detected from magic bytes). Results over 1 MB, or when "output" is given, are written to a text file instead of returned inline. Web version: https://s3eidat.github.io/base64-kit/

Input parameters:

- `dataUri` (boolean): Return a data: URI (data:<mime>;base64,…) instead of bare Base64.
- `file` (string): Or: a file to encode: local path or base64 data.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `text` (string): Text to encode (UTF-8).
- `urlSafe` (boolean): Use the URL-safe alphabet (- and _) and drop "=" padding.
- `wrap` (boolean): Insert a line break every 76 characters (MIME style).

### `bytes_convert` (~148 tokens)

Text ⇄ UTF-8 bytes

Turn text into its UTF-8 bytes (hex, binary or decimal), or bytes back into text. Byte input is lenient: "48 65", "4865", "0x48,0x69", "01001000 01101001", "72 105". Invalid UTF-8 is reported and shown with � replacements. Web version: https://s3eidat.github.io/base-convert/

Input parameters:

- `bytes` (string): Or: bytes to turn into text, in the chosen format.
- `format` (string): Byte format. Default hex.
- `text` (string): Text to turn into bytes.
- `uppercase` (boolean): Upper-case hex digits.

### `calc_age` (~200 tokens)

Age calculator

Exact age in years, months and days from a date of birth (on today or any "on" date), with totals in months, weeks, days and hours, the weekday of birth, Hijri (Umm al-Qura) birth date and Hijri age, next birthday (Feb 29 birthdays fall on Feb 28 in common years), star sign, Chinese zodiac, the next 1,000-day milestone, and optionally the age gap to a second person. Dates are ISO YYYY-MM-DD. Web version: https://s3eidat.github.io/age-calc/

Input parameters:

- `birthDate` (string, required): Date of birth, YYYY-MM-DD.
- `onDate` (string): Work out the age on this date (YYYY-MM-DD). Default: today.
- `otherBirthDate` (string): Optional second person's date of birth, to compare.
- `otherName` (string): Name of the second person (default "They").

### `calc_bmi` (~287 tokens)

BMI calculator

Body mass index with the WHO adult category, the healthy weight range for your height (BMI 18.5–24.9), BMI Prime, optional waist-to-height ratio, and for adults (18–120, with age) BMR by Mifflin-St Jeor plus daily calories to maintain or lose ~0.5 kg (1 lb) a week at five activity levels. Metric (cm, kg) or imperial (ft + in, lb). Height 50–272 cm, weight 10–650 kg. Not medical advice; children need percentile charts. Web version: https://s3eidat.github.io/bmi-calc/

Input parameters:

- `age` (number|string): Age in years (adults 18+ get BMR and calories).
- `heightCm` (number|string): Height in cm (metric).
- `heightFt` (number|string): Height, feet part (imperial).
- `heightIn` (number|string): Height, inches part (imperial).
- `sex` (string): Sex, for BMR (m or f).
- `units` (string): metric: cm and kg; imperial: ft + in and lb.
- `waist` (number|string): Optional waist size in cm (metric) or inches (imperial).
- `weight` (number|string): Weight in kg (metric) or lb (imperial).

### `calc_cash_count` (~227 tokens)

Cash counter

Count a cash drawer by denomination with exact integer maths (no float errors): JOD (3 decimals, fils), USD, EUR, SAR, AED, GBP, KWD, EGP, or a custom currency (your own note and coin values, 0/2/3 decimals). Give how many of each note/coin (by value like 50 or 0.25, by label like "50 JD" or "¼ dinar"); returns per-denomination amounts, the total, notes and coins counted, and over/short against an expected amount. list=true shows the denominations of a currency. Web version: https://s3eidat.github.io/cash-counter/

Input parameters:

- `counts` (array): What you counted.
- `currency` (string): Currency preset, or CUSTOM.
- `custom` (object): CUSTOM currency definition.
- `expected` (number|string): Expected total, to show over/short.
- `list` (boolean): Just list the denominations.
- `note` (string): Optional note for the summary (e.g. "Evening shift").

### `calc_compound_interest` (~255 tokens)

Compound interest / savings growth

Project savings with compound interest: an initial deposit plus monthly contributions (at the start or end of each month), a nominal annual rate compounded yearly, half-yearly, quarterly, monthly, daily or continuously, optionally adjusted for inflation ("today's money"). Returns final balance, total deposits, interest earned and a year-by-year table. Rate -50–100 %, 1 month to 100 years. Web version: https://s3eidat.github.io/compound-interest/

Input parameters:

- `annualRate` (number|string, required): Nominal annual interest rate in percent, e.g. 7.
- `compounding` (string): How often interest compounds.
- `inflation` (number|string): Optional yearly inflation in percent, to show the balance in today's money.
- `initial` (number|string): Initial deposit (default 0).
- `monthly` (number|string): Monthly contribution (default 0).
- `table` (boolean): Include the year-by-year table.
- `timing` (string): Contributions at the end (ordinary annuity) or start (annuity due) of each month.
- `years` (number|string, required): Duration in years (fractions allowed, e.g. 1.5; at least one month).

### `calc_date_diff` (~299 tokens)

Date difference / add days

Two date jobs. difference: days between two dates (optionally counting the end day), as years/months/days, weeks, whole months, working days and weekend days for a chosen weekend (Fri–Sat default, Sat–Sun, Fri only, Sun only; public holidays are not counted). add: add or subtract days, business days, weeks, months or years to a date (month ends clamp: Jan 31 + 1 month = Feb 28/29). Results include the weekday and Umm al-Qura Hijri date. Dates are ISO YYYY-MM-DD; for Hijri ⇄ Gregorian conversion use calc_hijri. Web version: https://s3eidat.github.io/date-diff/

Input parameters:

- `amount` (integer): add: how many units to add (use subtract to go back).
- `date` (string): add: the starting date YYYY-MM-DD (default today).
- `end` (string): difference: end date YYYY-MM-DD (default today).
- `inclusive` (boolean): difference: count the end date too.
- `mode` (string): difference between two dates, or add/subtract an amount.
- `start` (string): difference: start date YYYY-MM-DD (default today).
- `subtract` (boolean): add: go back in time instead.
- `unit` (string): add: unit of amount.
- `weekend` (string): Weekend days skipped by working-day counts.

### `calc_discount` (~344 tokens)

Discount / sale price calculator

Three shop maths jobs. sale: price after one or two stacked discounts (each a percent or a fixed amount) plus optional tax/VAT, with what you save and the effective total discount (stacked percents multiply). reverse: the discount % between an old and a new price. compare: which of two deals is cheaper per unit (price and amount of each). Money is rounded to the cent at each step like a till. Web version: https://s3eidat.github.io/discount-calc/

Input parameters:

- `amountA` (number|string): compare: amount of deal A (e.g. 0.5 for 500 g when unit is kg).
- `amountB` (number|string): compare: amount of deal B.
- `discount` (number|string): sale: first discount (percent by default).
- `discountType` (string): sale: first discount is a percent or a fixed amount.
- `extraDiscount` (number|string): sale: optional second discount applied after the first.
- `extraDiscountType` (string): sale: second discount type.
- `mode` (string): Which calculator.
- `now` (number|string): reverse: the new price.
- `price` (number|string): sale: original price.
- `priceA` (number|string): compare: price of deal A.
- `priceB` (number|string): compare: price of deal B.
- `taxPercent` (number|string): sale: optional tax / VAT percent added after the discounts.
- `unit` (string): compare: the unit name (kg, L, item…). Default "unit".
- `was` (number|string): reverse: the old price.

### `calc_due_date` (~253 tokens)

Pregnancy due date

Estimated pregnancy due date from the first day of the last period (Naegele's rule, adjusted for cycle length 20–45 days), the conception date, or an IVF embryo transfer date (day-3 or day-5 embryo). Also gives the estimated conception date, full-term date, how far along you are on a given day (weeks + days, trimester, days to go) and a dated timeline of common milestones (weeks 4–42), optionally with Hijri dates. Estimate only, not medical advice. Web version: https://s3eidat.github.io/due-date/

Input parameters:

- `cycleLength` (integer): lmp: average cycle length in days (default 28).
- `date` (string, required): The date for that method, YYYY-MM-DD.
- `hijri` (boolean): Also give Umm al-Qura Hijri dates.
- `ivfEmbryoDay`: ivf: embryo age at transfer, day 3 or day 5.
- `method` (string): lmp = first day of last period; conception; ivf = embryo transfer date.
- `today` (string): Work out progress on this date, YYYY-MM-DD (default today).

### `calc_equation` (~280 tokens)

Equation solver

Solve equations exactly with worked steps, like the website: linear a·x + b = c, quadratic a·x² + b·x + c = 0 (exact rational or surd roots like 1/2 + √5/2, complex roots), cubic a·x³ + b·x² + c·x + d = 0 (rational root test, else trigonometric/Cardano to 10 significant digits), and systems of 2 or 3 linear equations (Gauss–Jordan; no solution and infinitely many solutions are detected and parametrised). Coefficients may be integers, decimals, fractions ("3/4"), mixed numbers ("-1 1/2") or e-notation. Web version: https://s3eidat.github.io/equation-solver/

Input parameters:

- `coefficients` (array): linear: [a, b, c] for a·x + b = c; quadratic: [a, b, c]; cubic: [a, b, c, d].
- `system` (array): system: rows of the augmented matrix, 2 rows of [a, b, rhs] (x, y) or 3 rows of [a, b, c, rhs] (x, y, z).
- `type` (string, required): Equation type.

### `calc_expression` (~279 tokens)

Scientific calculator

Evaluate a maths expression safely with the website's own parser (never eval): + − × ÷ ^ (right-associative), implicit multiplication (2(3+4), 2x), postfix ! and %, √, brackets; functions sin cos tan sec csc cot (+ asin acos atan atan2) in degrees (default), radians or grads, sinh cosh tanh and inverses, sqrt cbrt root(x,n) abs exp ln log(x[,base]) log10 log2 floor ceil round sign min max mod nCr nPr fact gamma; constants pi π e tau phi; "ans" and your own variables. Results to 12 significant digits, plain or scientific notation. Web version: https://s3eidat.github.io/sci-calc/

Input parameters:

- `angle` (string): Angle unit for trig functions.
- `ans` (number): Value of "ans" (the previous answer). Default 0.
- `expression` (string, required): The expression, e.g. "sin(30) + 2^3^2", "5!/(2!×3!)", "200×15%".
- `format` (string): Display: normal, or always scientific notation.
- `variables` (object): Variables to use, e.g. {"x": 2, "r": 5}.

### `calc_fraction` (~210 tokens)

Fraction calculator

Exact fraction maths with big integers (never rounded) and worked steps. calculate: an expression with fractions, mixed numbers ("1 1/2"), decimals and repeating decimals ("0.(3)"), + − × ÷ ^ and brackets (a/b binds tighter than ÷). decimal_to_fraction: "0.75", "0.1(6)" (brackets mark the repeating part), with close small-denominator approximations. fraction_to_decimal: exact decimal with the repeating block, and percent. compare: put two or more fractions in order. Web version: https://s3eidat.github.io/fraction-calc/

Input parameters:

- `input` (string, required): calculate: "1 1/2 + 3/4 × 2/5"; decimal_to_fraction: "0.1(6)"; fraction_to_decimal: "5/7"; compare: "2/3, 3/5, 7/10".
- `mode` (string): What to do.

### `calc_fuel_cost` (~311 tokens)

Fuel cost of a trip

Fuel needed and cost of a trip from distance (km or miles, optionally round trip), fuel price (per litre, US gallon or UK gallon) and consumption in L/100 km, km/L, mpg (US) or mpg (UK); split between people; cost per km/mile and per 100. Optionally compare a second car (its own consumption and, if different, fuel price). Also converts the consumption to the other units. Web version: https://s3eidat.github.io/fuel-cost/

Input parameters:

- `compare` (object): Optional second car to compare.
- `consumption` (number|string, required): Car consumption / economy, e.g. 7.5 (L/100 km) or 35 (mpg).
- `consumptionUnit` (string): l100 = L/100 km, kml = km/L, mpgus, mpguk.
- `currency` (string): Currency label for the text, e.g. "JD" or "$".
- `distance` (number|string, required): Trip distance (one way unless roundTrip).
- `distanceUnit` (string): Distance unit.
- `name` (string): Name of the car (default "Car A").
- `people` (integer): Split the cost between this many people.
- `price` (number|string, required): Fuel price per priceUnit.
- `priceUnit` (string): The price is per litre, US gallon or UK gallon.
- `roundTrip` (boolean): Double the distance (there and back).

### `calc_gpa` (~272 tokens)

GPA calculator

Credit-weighted semester GPA, cumulative GPA (with previous credits and GPA) and the average you need over the remaining credits to reach a target. Scales: 4.0 (A…F, no A+), 4.3 (A+ = 4.3), 5.0 (A+ 5, A 4.75, B+ 4.5 … F 1) with letter grades, or "percent" with numeric marks between a minimum and maximum (default 35–100). Courses with no credits or an invalid grade are skipped (and listed). Up to 40 courses. Web version: https://s3eidat.github.io/gpa-calc/

Input parameters:

- `courses` (array, required): This semester's courses.
- `percentMax` (number|string): percent scale: highest mark (default 100).
- `percentMin` (number|string): percent scale: lowest passing mark (default 35).
- `previousCredits` (number|string): Credits completed before this semester.
- `previousGpa` (number|string): GPA before this semester.
- `remainingCredits` (number|string): Credits still to take after this semester (for the target).
- `scale` (string): Grading scale.
- `targetGpa` (number|string): Target cumulative GPA.

### `calc_hijri` (~359 tokens)

Hijri ⇄ Gregorian converter

Convert between Gregorian and Hijri dates with the Umm al-Qura calendar (the same Intl calendar the website uses), both ways. Modes: to_hijri (a Gregorian date), to_gregorian (Hijri year, month 1–12, day), month (length of a Hijri month and its Gregorian start/end), age (age in Hijri and Gregorian years, next Hijri birthday). Results come in English and Arabic (Arabic-Indic digits by default; Gregorian month names in the Egyptian/Gulf or Levant style). Supported range 1300–1600 AH (1882–2174). Web version: https://s3eidat.github.io/hijri-converter/

Input parameters:

- `arabicDigits` (boolean): Use Arabic-Indic digits in the Arabic text.
- `birthDate` (string): age: Gregorian date of birth YYYY-MM-DD.
- `date` (string): to_hijri: Gregorian date YYYY-MM-DD (default today).
- `gregorianArabicMonths` (string): Arabic Gregorian month names: intl (Egypt/Gulf style, January = Yanayir) or levant (Syria/Jordan style, January = Kanun al-Thani).
- `hijriDay` (integer): to_gregorian: Hijri day 1–30.
- `hijriMonth` (integer): to_gregorian / month: Hijri month 1–12 (1 = Muharram, 9 = Ramadan).
- `hijriYear` (integer): to_gregorian / month: Hijri year (1300–1600).
- `mode` (string, required): Which conversion.
- `onDate` (string): age: age on this Gregorian date (default today).

### `calc_hours` (~295 tokens)

Work hours / time card

Weekly time card: add shifts (start and end "HH:MM", unpaid break minutes; an end at or before the start is an overnight shift), up to 6 shifts a day. Totals per shift, per day and per week in h:mm and decimal hours; optional rounding of each shift to 5, 6 or 15 minutes; overtime over N hours a day and/or N regular hours a week (daily first, then weekly), paid at a multiplier (default 1.5); pay at an hourly rate. Web version: https://s3eidat.github.io/hours-calc/

Input parameters:

- `currency` (string): Currency label for the summary.
- `dailyOvertimeHours` (number): Hours per day after which time is overtime (e.g. 8).
- `hourlyRate` (number): Pay per regular hour.
- `overtimeMultiplier` (number): Overtime pay multiplier.
- `roundMinutes`: Round each shift to the nearest 5, 6 or 15 minutes (0 = off).
- `shifts` (array, required): The week's shifts.
- `weekOf` (string): Optional: any date in that week (YYYY-MM-DD) to date each day.
- `weekStart` (string): First day of the week (order of the days).
- `weeklyOvertimeHours` (number): Regular hours per week after which time is overtime (e.g. 40).

### `calc_loan` (~254 tokens)

Loan / mortgage calculator

Monthly payment, total interest, total paid and payoff month for a fixed-rate loan or mortgage, with an optional extra monthly payment (shows interest saved and how much sooner it ends) and an amortization schedule by year or by month (or none). Maths is in whole cents like the website; the last payment absorbs the rounding so the balance ends at 0. Rate 0–100 %, term 1 month to 100 years. Web version: https://s3eidat.github.io/loan-calc/

Input parameters:

- `amount` (number|string, required): Loan amount (principal), e.g. 250000 or "250,000".
- `annualRate` (number|string, required): Annual interest rate in percent, e.g. 6.5. 0 is allowed.
- `extraMonthly` (number|string): Optional extra principal paid every month.
- `schedule` (string): Amortization table: per calendar year, per month, or omit it.
- `startMonth` (string): First payment month "YYYY-MM". Default: next month.
- `term` (number|string, required): Loan term, in years (default) or months (see termUnit).
- `termUnit` (string): Unit of "term".

### `calc_percentage` (~306 tokens)

Percentage calculator

Every percentage question the website answers: "X% of Y" (percent_of: percent, value), "X is what % of Y" (what_percent: part, whole), percent change from A to B (change: from, to), increase/decrease a value by X% (increase/decrease: value, percent), find the original before a X% increase/decrease (reverse_increase/reverse_decrease: value, percent), and profit margin vs markup (margin_markup: cost, price). Returns the number, a display string and the worked formula. Web version: https://s3eidat.github.io/percentage-calc/

Input parameters:

- `cost` (number|string): margin_markup: cost price.
- `from` (number|string): change: the old value.
- `mode` (string, required): Which question to answer (see the description for the fields each one uses).
- `part` (number|string): what_percent: the part X in "X is what % of Y".
- `percent` (number|string): The percentage X (percent_of, increase, decrease, reverse_*).
- `price` (number|string): margin_markup: selling price.
- `to` (number|string): change: the new value.
- `value` (number|string): The value Y (percent_of: Y in "X% of Y"; increase/decrease: the starting value; reverse_*: the final value).
- `whole` (number|string): what_percent: the whole Y.

### `calc_primes` (~297 tokens)

Prime number tools

Number theory with big integers, like the website. check: is a number prime (trial division, deterministic Miller-Rabin below 2^64, probabilistic above), its prime factorisation (Pollard rho), number of divisors, sum of divisors σ, Euler φ, the divisor list, previous/next prime and whether it is perfect; the number may be an expression like "2^61-1", "10!+1" or "1000003*1000033" (up to 400 digits). gcd_lcm: GCD and LCM of 2–50 numbers with Euclid's steps. range: list the primes between two numbers (below 10^15, at most 10,000,000 numbers per range). Web version: https://s3eidat.github.io/prime-tools/

Input parameters:

- `from` (integer): range: start (inclusive).
- `limit` (integer): range: return at most this many primes in the list (the count is always exact).
- `mode` (string): What to do.
- `number` (string|number): check: the number or expression, e.g. "600851475143" or "2^89-1".
- `numbers` (array): gcd_lcm: the whole numbers (2–50, expressions allowed).
- `to` (integer): range: end (inclusive), below 10^15.

### `calc_roman` (~250 tokens)

Roman numerals

Convert numbers to Roman numerals (1–3,999 in standard form; up to 3,999,999 with a vinculum bar, which multiplies by 1,000) and Roman numerals back to numbers with strict validation that explains mistakes (IIII, IC, VV, non-standard forms like IIX…) and the symbol-by-symbol working. Also writes a date in Roman numerals (day/month/year order and separator of your choice, years 1–3999). Web version: https://s3eidat.github.io/roman-numerals/

Input parameters:

- `date` (string): date: YYYY-MM-DD.
- `mode` (string, required): to_roman (number → Roman), from_roman (Roman → number) or date.
- `number` (number|string): to_roman: a whole number 1–3,999,999.
- `order` (string): date: order of day, month, year.
- `roman` (string): from_roman: the numeral, e.g. "MCMXCIV" (any case).
- `separator` (string): date: separator, e.g. " · ", ".", " - ", " / ".

### `calc_salary` (~314 tokens)

Salary / pay period converter

Convert pay between per hour, day, week, every 2 weeks, twice a month, month and year using your hours per week, days per week and weeks per year (defaults 40 / 5 / 52). Optional overtime (hours per week × multiplier, e.g. 1.25, 1.5, 2) and a raise given as a percent or as the new monthly pay. Amounts are rounded to 2 decimals. Web version: https://s3eidat.github.io/salary-calc/

Input parameters:

- `amount` (number|string, required): The pay amount, e.g. 1200.
- `currency` (string): Optional ISO currency code for the text summary (e.g. USD, JOD).
- `daysPerWeek` (number|string): Working days per week (0–7, default 5).
- `hoursPerWeek` (number|string): Working hours per week (0–168, default 40).
- `newMonthlyPay` (number|string): Or: the new monthly pay (gives the raise percent).
- `overtimeHours` (number|string): Optional overtime hours per week.
- `overtimeMultiplier` (number|string): Overtime rate multiplier (default 1.5).
- `period` (string): The period "amount" is paid for.
- `raisePercent` (number|string): Optional raise in percent (gives the new pay).
- `weeksPerYear` (number|string): Paid weeks per year (0–53, default 52).

### `calc_sleep` (~257 tokens)

Sleep cycle calculator

Sleep in whole cycles so you wake in light sleep: given a wake-up time, the bedtimes for 6, 5, 4 or 3 cycles; given a bedtime (or "now"), the wake-up times. Defaults: 90-minute cycles (70–110) and 15 minutes to fall asleep (0–60). With mode "bed"/"now" it also lists nap alarms (20, 30, 60 min and one full cycle). 12- or 24-hour clock. Web version: https://s3eidat.github.io/sleep-calc/

Input parameters:

- `clock` (string): 12-hour (AM/PM) or 24-hour times in the output.
- `cycleMinutes` (integer): Length of one sleep cycle.
- `fallAsleepMinutes` (integer): Minutes it takes you to fall asleep.
- `mode` (string): wake: I must wake at "time"; bed: I go to bed at "time"; now: I go to bed now (server clock).
- `time` (string): "HH:MM" 24 h: the wake-up time (wake) or bedtime (bed). Default 07:00 / 23:00.

### `calc_split_bill` (~327 tokens)

Split a bill

Split a restaurant bill with tax/service and tip, in whole cents so the shares always add up exactly (left-over cents go to the largest remainders). simple: one bill split evenly between N people (1–100). items: list who had what; each item is split between the people who shared it (nobody listed = everyone), and tax and tip are shared in proportion. Tip can be on the subtotal or on subtotal + tax; each share can be rounded up to a step (e.g. 0.5 or 1). Returns a ready-to-send summary. Web version: https://s3eidat.github.io/split-bill/

Input parameters:

- `bill` (number|string): simple: the bill subtotal (before tax and tip).
- `currency` (string): Currency, e.g. "JOD" (written after) or "$" (written before).
- `items` (array): items: what was ordered.
- `mode` (string): Even split, or itemised.
- `people`: simple: how many people (default 2). items: the names, e.g. ["Sara", "Omar", "Lina"].
- `roundUpTo` (number): Round each share up to a multiple of this (e.g. 0.5, 1, 5). 0 = exact.
- `taxPercent` (number): Tax / service charge percent.
- `tipOnTax` (boolean): Calculate the tip on subtotal + tax.
- `tipPercent` (number): Tip percent (default 10).

### `calc_stats` (~286 tokens)

Descriptive statistics

Descriptive statistics for a list of numbers: count, sum, mean, median, mode(s), min, max, range, sample and population variance and SD, standard error, coefficient of variation, quartiles (inclusive = Excel QUARTILE.INC, exclusive = QUARTILE.EXC, or Tukey median-of-halves), IQR, 1.5×IQR outlier fences and outliers, a frequency table (values, or Sturges bins when there are more than 20 distinct values) and z-scores. Paste numbers separated by spaces, commas, semicolons, | or new lines; headers and text are skipped and reported. Commas can be separators, thousands marks or decimal commas. Up to 1,000,000 numbers. Web version: https://s3eidat.github.io/stats-calc/

Input parameters:

- `commas` (string): In text: commas separate values (sep), are thousands marks (thou: 1,234), or decimal commas (dec: 1,5).
- `data` (required): The numbers: a text blob (CSV column, list…) or an array of numbers.
- `frequency` (boolean): Include the frequency table.
- `quartileMethod` (string): Quartile method.
- `zScores` (boolean): Include a z-score for each value (first 1,000).

### `calc_unit_convert` (~318 tokens)

Unit converter

Convert between units in 14 categories, the same table as the website: length, mass, temperature, volume, area (incl. dunam), speed, time, data (kB/MB vs KiB/MiB, bits), pressure, energy, power, angle, fuel economy (L/100km, km/L, mpg US/UK) and cooking (tsp, tbsp, cups, metric spoons). Give value + from + to (symbols like "km", "°F", "GiB" or names like "miles"; ASCII forms like "m2", "um" work), or a query like "5 km to mi". Set all=true for the value in every unit of the category, or list=true to see every category and unit. Web version: https://s3eidat.github.io/unit-convert/

Input parameters:

- `all` (boolean): Also return the value in every unit of the category.
- `category` (string): Category, to pick the right unit when a symbol exists in two (e.g. "pt" in volume and cooking).
- `from` (string): Unit to convert from (symbol or name).
- `list` (boolean): Just list every category and its units.
- `query` (string): A whole question, e.g. "5 km to mi" or "72 f in c".
- `to` (string): Unit to convert to (symbol or name). Optional when all=true.
- `value` (number|string): The number to convert.

### `calc_zakat` (~367 tokens)

Zakat calculator

Zakat on wealth: 2.5 % of net zakatable wealth (cash, bank, investments, trade goods, money owed to you, gold and silver, minus debts due now) when it reaches the nisab: the value of 85 g of pure gold (default) or 595 g of silver. Gold weight is converted to pure gold by karat (24/22/21/18). You give today's gold/silver price per gram in your currency: nothing is fetched from the network. An estimate only; consult a scholar. Web version: https://s3eidat.github.io/zakat-calc/

Input parameters:

- `bank` (number|string): Bank balances.
- `cash` (number|string): Cash in hand.
- `currency` (string): Currency label for the summary (e.g. JOD).
- `debts` (number|string): Debts you must pay now (deducted).
- `goldGrams` (number|string): Gold you own, in grams.
- `goldKarat`: Karat of that gold (default 21).
- `goldPricePerGram` (number|string): Price of 1 g of pure (24k) gold. Needed for the gold nisab and to value gold.
- `investments` (number|string): Shares, funds and other investments.
- `nisabBasis` (string): Which metal sets the nisab.
- `receivables` (number|string): Money owed to you that you expect back.
- `silverGrams` (number|string): Silver you own, in grams.
- `silverPricePerGram` (number|string): Price of 1 g of silver. Needed for the silver nisab and to value silver.
- `tradeGoods` (number|string): Value of goods held for sale.

### `chmod_calc` (~223 tokens)

chmod calculator

Convert Unix file permissions between octal (755, 0644, 4755), symbolic (rwxr-xr-x, ls -l style -rwsr-xr-x) and chmod clauses (u=rwx,g=rx,o=; relative ones like g+w or +x apply to "base"). Returns all forms, a plain-English description per owner/group/others, setuid/setgid/sticky meaning, safety warnings, and ready chmod commands. Web version: https://s3eidat.github.io/chmod-calc/

Input parameters:

- `base` (string): Starting mode (octal) for relative clauses like "g+w". Default 000.
- `file` (string): File name for the example chmod commands (shell-quoted).
- `mode` (string, required): Octal ("755", "0644", "2775"), symbolic ("rwxr-x---", "drwxrwxrwt") or clauses ("u=rw,go=r", "+x").
- `recursive` (boolean): Add -R to the example commands.

### `cron_explain` (~262 tokens)

Cron explain

Explain a standard 5-field cron expression (minute hour day-of-month month day-of-week; names like MON/JAN, ranges, lists, steps, ? and the @hourly/@daily/@weekly/@monthly/@yearly/@reboot macros) in plain English and list the next run times in an IANA timezone. Follows Vixie cron: when both day fields are restricted a day matches either one. Quartz 6/7-field and L/W/# syntax are rejected with a clear message; per-field errors are reported. Web version: https://s3eidat.github.io/cron-explain/

Input parameters:

- `count` (integer): How many upcoming run times to list (0–100). Default 10.
- `expression` (string, required): The cron expression, e.g. "*/30 9-17 * * 1-5" or "@daily".
- `from` (string): Start searching after this instant (ISO 8601). Default: now.
- `hour12` (boolean): Describe times on a 12-hour clock (9:00 AM) instead of 24-hour (09:00).
- `timezone` (string): IANA timezone the cron daemon runs in. Default: the server's (UTC).

### `crypto_file_decrypt` (~211 tokens)

Decrypt a file (.s3enc)

Decrypt an .s3enc file made by the S3eidat File Encrypt website or crypto_file_encrypt, verify every chunk, and write the original file back under its stored (sanitised) name. A wrong password, damage, truncation or reordering is reported and nothing is written. Web version: https://s3eidat.github.io/file-encrypt/

Input parameters:

- `file` (string, required): The .s3enc file: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the decrypted file: a file path, or a folder ending in "/" (keeps the stored name). Default: the server output folder.
- `password` (string, required): The password. Normalised to Unicode NFC first, like the website.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `crypto_file_encrypt` (~341 tokens)

Encrypt a file (.s3enc)

Encrypt any file with a password into the website's .s3enc format: chunked AES-256-GCM, key from PBKDF2-SHA256 (600,000 rounds, random salt), original name/type/size stored encrypted inside, tamper/truncation/reorder-proof. Files made here open at https://s3eidat.github.io/file-encrypt/ and vice versa (crypto_file_decrypt). Whole file is processed in memory (size limit = server --max-mb). Web version: https://s3eidat.github.io/file-encrypt/

Input parameters:

- `chunkSize` (integer): Chunk size in bytes (website: 4 MiB).
- `file` (string, required): The file to encrypt: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `iterations` (integer): PBKDF2 rounds (website: 600,000).
- `mimeType` (string): MIME type to store. Default: guessed from the extension like a browser would ("" if unknown).
- `name` (string): File name to store inside (restored on decrypt). Default: the input file name.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `password` (string, required): The password. Normalised to Unicode NFC first, like the website.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `crypto_stego_hide` (~312 tokens)

Hide a message in an image

Hide a text message inside an image (LSB steganography in R, G, B; the picture looks the same) and save it as a lossless PNG, optionally encrypted with a password (AES-256-GCM, PBKDF2-SHA256 600,000). Same bit layout as the website, so the PNG reveals at https://s3eidat.github.io/stego-image/ or with crypto_stego_reveal. Capacity ≈ width×height×3/8 − 10 bytes (−44 more when encrypted). Transparency is filled with white. The result is read back and checked before returning. Sending it through apps that recompress images (JPEG, chat apps) destroys the message. Web version: https://s3eidat.github.io/stego-image/

Input parameters:

- `image` (string, required): The cover image (PNG, JPEG, WebP…): a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `message` (string, required): The text to hide (UTF-8).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `password` (string): Optional password to encrypt the message.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `crypto_stego_reveal` (~138 tokens)

Reveal a hidden message

Read a message hidden in a PNG by the S3eidat Stego Image website or crypto_stego_hide (decrypting it if a password was used). Reports when there is no message, e.g. because the image was recompressed (JPEG), resized or edited. Web version: https://s3eidat.github.io/stego-image/

Input parameters:

- `image` (string, required): The image with a hidden message (PNG): a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `password` (string): Password, if the message is encrypted.

### `crypto_text_decrypt` (~157 tokens)

Decrypt text (AES-256-GCM)

Decrypt an "S3E1.…" message made by the S3eidat Text Encrypt website or crypto_text_encrypt, with its password. Verifies integrity: a wrong password or any change to the text is reported, never garbage output. Accepts base64url and line breaks. Web version: https://s3eidat.github.io/text-encrypt/

Input parameters:

- `encrypted` (string): The encrypted text, starting with S3E1.
- `output` (string): Optional: also save the decrypted message to this file.
- `password` (string, required): The password. Normalised to Unicode NFC first, like the website.
- `path` (string): Or: a file containing it (e.g. encrypted.txt).

### `crypto_text_encrypt` (~208 tokens)

Encrypt text (AES-256-GCM)

Encrypt a message with a password: AES-256-GCM, key from PBKDF2-SHA256 (600,000 rounds, random 16-byte salt, 12-byte IV), output as one "S3E1.…" base64 line. Exactly the website's format, so the result can be decrypted at https://s3eidat.github.io/text-encrypt/ or with crypto_text_decrypt. Each run gives a different output. Web version: https://s3eidat.github.io/text-encrypt/

Input parameters:

- `iterations` (integer): PBKDF2 rounds (website: 600,000).
- `output` (string): Optional: also save the encrypted line to this file (website "Save" gives encrypted.txt).
- `password` (string, required): The password. Normalised to Unicode NFC first, like the website.
- `path` (string): Or: a UTF-8 text file to encrypt.
- `text` (string): The message to encrypt.

### `css_clamp` (~207 tokens)

Fluid CSS clamp()

Build a fluid typography/spacing value: CSS clamp() that grows linearly from a size at a small viewport to a size at a large viewport (sizes and viewports in px), expressed in rem or px. Also returns the computed size at sample viewport widths. Web version: https://s3eidat.github.io/css-units/

Input parameters:

- `maxSize` (number): Size in px at the large viewport. Default 32.
- `maxViewport` (number): Large viewport width in px. Default 1280.
- `minSize` (number): Size in px at the small viewport. Default 16.
- `minViewport` (number): Small viewport width in px. Default 320.
- `rootFontSize` (number): Root (html) font size in px, for rem. Default 16.
- `sampleViewports` (array): Viewport widths (px) to compute the resulting size at.
- `unit` (string): Output unit. Default rem.

### `css_format` (~239 tokens)

CSS beautify / minify

Beautify CSS (one declaration per line, one selector per line, blank line between top-level rules, nested @media blocks) or minify it. Strings, url(...) and escapes are kept intact; calc() spacing is preserved. Optional comment removal (/*! … */ kept). Give "text" or a file "path". Web version: https://s3eidat.github.io/html-css-format/

Input parameters:

- `indent`: Indentation: 2, 4, "tab" (or any number of spaces 0-8).
- `mode` (string): "beautify" (default) or "minify".
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a CSS file (UTF-8; use this for big inputs).
- `removeComments` (boolean): Drop comments (/*! … */ license comments are kept).
- `text` (string): The CSS as inline text.

### `css_units` (~248 tokens)

CSS unit converter

Convert a CSS length between px, rem, em, %, pt, pc, in, cm, mm, vw, vh, vmin and vmax, using a root font size, parent font size and viewport size (defaults 16px / 16px / 1440×900). Uses the CSS definition of 96px per inch. Returns every unit, rounded to 4 decimals by default. Web version: https://s3eidat.github.io/css-units/

Input parameters:

- `decimals` (integer): Decimal places to round to. Default 4.
- `parentFontSize` (number): Parent element font size in px, for em and %. Default 16.
- `rootFontSize` (number): Root (html) font size in px, for rem. Default 16.
- `unit` (string): Unit of "value". Default px.
- `value` (number, required): The length to convert, e.g. 24.
- `viewportHeight` (number): Viewport height in px, for vh/vmin/vmax. Default 900.
- `viewportWidth` (number): Viewport width in px, for vw/vmin/vmax. Default 1440.

### `csv_to_json` (~312 tokens)

CSV to JSON

Convert CSV/TSV to JSON with an RFC 4180 parser (quoted fields, "" escapes, line breaks inside quotes, CR/LF/CRLF, BOM). Detects the delimiter (comma, semicolon, tab, pipe), uses the first row as headers (blank → column_N, duplicates → name_2), and can type values (numbers, true/false, null; long digit strings like IDs stay strings). Output: array of objects or array of arrays, pretty-printed. Give "text" or a file "path". Web version: https://s3eidat.github.io/csv-json/

Input parameters:

- `delimiter` (string): Delimiter: "auto" (detect), ",", ";", "tab" or "|".
- `header` (boolean): First row is a header (default true).
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a CSV/TSV file (UTF-8; use this for big inputs).
- `shape` (string): "objects" (one object per row) or "arrays" (rows as arrays).
- `text` (string): The CSV as inline text.
- `types` (boolean): Turn numbers, true/false and empty/null into JSON types (default true).

### `curl_to_code` (~330 tokens)

cURL to code

Convert a curl command (bash/zsh quoting incl. $'…', line continuations, "Copy as cURL" from browsers) into code for JavaScript fetch, axios, Python requests, PHP cURL, Go net/http or Node.js http/https: every target the website supports. Understands -X, -H, -d/--data-raw/--data-binary/--data-urlencode, --json, -F forms and files, -u, -b, -A, -e, -G, -I, -k, -L, -m, --connect-timeout, -x, -T, --compressed, --oauth2-bearer. Also returns the parsed request (secrets masked unless revealSecrets) and notes on what could not be converted. Only parses text; never sends the request. Web version: https://s3eidat.github.io/curl-convert/

Input parameters:

- `command` (string, required): The curl command, e.g. "curl -X POST https://api.example.com -H 'Content-Type: application/json' -d '{"a":1}'".
- `language` (string): Target: fetch (browser/Node fetch), axios, python (requests), php (cURL), go (net/http), node (http/https), or "all".
- `output` (string): Optional: write the code to this file (single language only).
- `revealSecrets` (boolean): Show Authorization/Cookie/API-key header values and the basic-auth password in the parsed summary (the code always contains them).

### `doc_attendance_sheet` (~493 tokens)

Attendance sheet PDF

Make a printable attendance / sign-in sheet PDF: names down the side, one column per date for a month (skipping chosen weekdays, e.g. Fri+Sat or Sat+Sun), a run of N sessions from a start date, or N blank columns; tick boxes or wide signature cells; row numbers, a total column, extra empty rows, title, group and teacher. Same page maths as the website: rows that don't fit continue on more pages, and too many date columns are split across pages with the same names. Also returns a blank register CSV. English labels, Latin text only for now. Web version: https://s3eidat.github.io/attendance-sheet/

Input parameters:

- `cell` (string): box = tick boxes, sign = wide cells for signatures.
- `count` (integer): sessions/blank: number of columns.
- `extraRows` (integer): Empty rows after the names.
- `group` (string): Class / group, shown under the title.
- `mode` (string): month = every day of a month; sessions = N dates from a start date; blank = N unnamed columns.
- `month` (string): month mode: YYYY-MM (default this month).
- `names` (required): Names, one per line (leading "1." numbering and anything after a tab are removed), or a list.
- `numbers` (boolean): Row number column.
- `orientation` (string)
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `paper` (string)
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `rowHeight` (number): Row height in mm (default 8, or 13 for signature cells).
- `skip` (array): Weekdays to skip, 0 = Sunday … 6 = Saturday (default [0, 6] = weekends Sat+Sun; use [5, 6] for Fri+Sat).
- `start` (string): sessions mode: first date YYYY-MM-DD (default today).
- `teacher` (string): Teacher, shown under the title.
- `title` (string): Title (default "Attendance").
- `total` (boolean): Total column.

### `doc_business_cards` (~512 tokens)

Business cards PDF

Design business cards and get a print-ready PDF sheet: cards centred on A4 or Letter with crop marks (10 per sheet for 85 × 55 mm EU or 3.5 × 2 in US cards), plus a back side page mirrored for long-edge duplex printing. Four front templates (classic, band, centered, minimal), backs with your logo, a "scan to save my contact" vCard QR code, or blank; six colour themes or your own accent/paper/ink colours; optional logo and a vCard QR on the front. Also returns the vCard text. Print at 100% / actual size. Latin text only for now (the website also does an Arabic side). Web version: https://s3eidat.github.io/business-card/

Input parameters:

- `accent` (string): Override the accent colour.
- `address` (string)
- `back` (string): Back side: logo/company on the accent colour, a contact QR code, or none.
- `company` (string): Company.
- `email` (string)
- `gap` (number): Gap between cards in mm (0 = shared cut lines).
- `ink` (string): Override the text colour.
- `logo` (string): Optional logo image: a PNG/JPEG/WebP/GIF/SVG file path or base64. Drawn as-is (keep it small).
- `name` (string, required): Your name.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `paperColor` (string): Override the card background colour.
- `phone` (string)
- `qrFront` (boolean): Also put the contact QR code on the front.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `sheet` (string): Paper for the print sheet.
- `sides` (string): Which pages to include (both = front page then mirrored back page).
- `size` (string): eu = 85 × 55 mm, us = 3.5 × 2 in.
- `tagline` (string): Short line for the back.
- `template` (string): Front layout.
- `theme` (string): Colour preset (navy = navy & gold).
- `title` (string): Job title.
- `website` (string)

### `doc_calendar` (~397 tokens)

Calendar PDF

Make a printable calendar PDF: a month grid (one page per month, several months in a row if you like) or a whole year on one page, A4 or Letter, landscape or portrait. Week starts on Saturday (default, like the website), Sunday or Monday; optional Hijri (Umm al-Qura) dates; events (one-off or yearly, 7 colours) shown in the day cells, or as coloured days plus a legend in the year view; optional title. English names by default; other Latin-script locales (fr, de, es, tr…) use their own month/day names. Web version: https://s3eidat.github.io/calendar-maker/

Input parameters:

- `events` (array): Events to show.
- `hijri` (boolean): Show Hijri (Umm al-Qura) dates.
- `locale` (string): Language for month/day names (default en). Latin-script locales only.
- `month` (integer): Month 1-12 (month view; default: this month).
- `months` (integer): Month view: how many consecutive months (one page each).
- `orientation` (string)
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `paper` (string)
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `title` (string): Optional title above the month name, e.g. "Family calendar".
- `view` (string): month = month grid pages, year = 12 months on one page.
- `weekStart`: First day of the week: 6 = Saturday (default), 0 = Sunday, 1 = Monday.
- `year` (integer): Year (default: this year).

### `doc_invoice` (~445 tokens)

Invoice PDF

Make a clean A4 invoice PDF: your business (logo, name, address, email, phone, tax ID), client, invoice number and dates, line items with quantity, unit price, per-line discount % and tax %, subtotal, discount, tax per rate and total, notes, payment terms, and an optional PAID stamp. Same maths as the website: every line is rounded to the currency's minor unit (2 decimals, 3 for JOD/KWD/BHD/OMR/TND…, 0 for JPY…) with half-up rounding; amounts formatted en-US style ($1,234.50, JOD 10.124). Long item lists continue on more pages. Returns the PDF path and the computed totals. Latin text only for now. Web version: https://s3eidat.github.io/invoice-maker/

Input parameters:

- `accent` (string): Accent colour (hex).
- `currency` (string): Currency code.
- `date` (string): Issue date, YYYY-MM-DD (default today).
- `due` (string): Due date, YYYY-MM-DD (optional).
- `from` (object): Your business: name, email, phone, address, taxId.
- `items` (array, required): Line items: desc, qty, price, disc %, tax %.
- `logo` (string): Optional logo image: a PNG/JPEG/WebP/GIF/SVG file path or base64. Drawn as-is (keep it small).
- `notes` (string): Notes shown at the bottom.
- `number` (string): Invoice number.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `paid` (boolean): Mark as paid (shows "Amount paid" and a PAID stamp).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `terms` (string): Payment terms shown at the bottom.
- `to` (object): The client (bill to): name, email, address.

### `doc_labels` (~728 tokens)

Label sheets PDF

Print address or product labels on standard sticker sheets as PDF: A4 21/24/14/40/65-up (L7160, L7159, L7163, L7654, L7651 sizes) or Letter 30/10/80-up (5160, 5163, 5167 sizes), or custom geometry in mm. Text modes: "list" (one label per block, blank line between labels), "csv" (rows filled into a template like "{Name}\n{Street}\n{City} {Postcode}", header row or {1},{2}…), or "same" (one text × count). Copies per label, start at a later position to reuse a part-used sheet, alignment, font, size, bold first line, border, shrink-to-fit and printer offset nudges. Print at 100% / actual size. Up to 3000 labels. Latin text only for now. Web version: https://s3eidat.github.io/label-maker/

Input parameters:

- `align` (string)
- `bold` (boolean): Bold first line (e.g. the name).
- `border` (boolean): Draw a thin rounded border around each label.
- `copies` (integer): list/csv: copies of each label.
- `count` (integer): same: how many labels.
- `custom` (object): preset "custom": paper, cols, rows, w, h, top, left, gx, gy (mm).
- `fit` (boolean): Shrink text (in 0.5 pt steps, min 5 pt) until it fits the label.
- `font` (string)
- `fontSize` (number): Font size in pt (default 11).
- `header` (boolean): csv: the first row holds column names.
- `mode` (string): list = blocks separated by a blank line; csv = rows + template; same = one text repeated.
- `offsetX` (number): Printer nudge right (mm, negative = left).
- `offsetY` (number): Printer nudge down (mm, negative = up).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `padding` (number): Inner padding in mm.
- `path` (string): Or: a text/CSV file path to read it from.
- `preset` (string): Sheet: a4-21 (63.5×38.1), a4-24 (63.5×33.9), a4-14 (99.1×38.1), a4-40 (45.7×25.4), a4-65 (38.1×21.2), lt-30 (2⅝×1 in), lt-10 (4×2 in), lt-80 (1¾×½ in), or custom.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `startAt` (integer): Start at this label position on the first sheet (skips used labels).
- `template` (string): csv: template with {Column name} or {1}-style placeholders (empty = all columns, one per line).
- `text` (string): The labels text (list blocks, CSV/TSV, or the single text).
- `valign` (string)

### `doc_receipt` (~415 tokens)

Receipt PDF

Make a simple sales receipt as PDF: an 80 mm thermal-roll receipt (page height fits the content, monospace) or an A5 page. Shop header (name, address, phone, tax number), receipt number with prefix, date/time, customer, items (name × qty × price), discount (% or fixed amount), tax % after discount, total, payment method, amount paid and change, note and footer. Same maths as the website: amounts rounded half-up to 0, 2 or 3 decimals. Also returns the totals and a 32-column plain-text version. English labels, Latin text only for now. Web version: https://s3eidat.github.io/receipt-maker/

Input parameters:

- `customer` (string): Customer name or table (optional).
- `disc` (number): Discount: a percentage, or an amount when discType is "amt".
- `discType` (string): pct = percent of subtotal (default), amt = fixed amount.
- `format` (string): thermal = 80 mm roll (default), a5 = A5 page.
- `items` (array, required): Items: name, qty, price.
- `no` (integer): Receipt number.
- `note` (string): Note line above the footer.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `paid` (number): Amount the customer paid (shows change).
- `pay` (string): Payment method.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `shop` (object): Shop details: name, address, phone, taxId, currency, decimals, prefix, footer.
- `tax` (number): Tax rate % applied after the discount.
- `when` (string): Date and time, YYYY-MM-DDTHH:MM (default now).

### `doc_resume` (~311 tokens)

Resume / CV PDF

Turn structured CV fields into a clean A4 resume PDF: contact header, summary, experience, education, skills, projects and languages, in any section order, with three templates like the website: "classic" (centred header and accent rule), "modern" (coloured sidebar with contact, skills and languages) and "compact" (denser, headings in a left column). Description lines starting with "-", "•", "*" or "–" become bullet points; skills are comma-separated. Aims for one page; longer CVs continue on a second page. English headings, Latin text only for now. Web version: https://s3eidat.github.io/resume-builder/

Input parameters:

- `accent` (string): Accent colour (hex).
- `contact` (object)
- `education` (array)
- `experience` (array)
- `languages` (array)
- `order` (array): Section order; missing sections are appended in the default order.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `projects` (array)
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `skills`: Skills: comma-separated text or a list.
- `summary` (string): Two or three lines about you.
- `template` (string)

### `gitignore_generate` (~333 tokens)

Generate .gitignore

Build a .gitignore by combining the website's templates for languages, frameworks, mobile, game engines, tools, OSes and editors (node, python, java, android, ios, flutter, reactnative, unity, unreal, go, rust, cpp, dotnet, php, wordpress, rails, django, nextjs, vite, docker, terraform, macos, windows, linux, vscode, jetbrains, vim). Templates can be named by id, name or keyword (e.g. "javascript" → node). Duplicate patterns are removed, optional "### Name ###" section headers, plus your own custom lines at the end. Returns the text, or writes it to "output" (e.g. "./.gitignore"). Set "list" to see all templates. Web version: https://s3eidat.github.io/gitignore-gen/

Input parameters:

- `custom` (string): Extra lines to append in a "Custom" section.
- `dedupe` (boolean): Drop patterns that already appeared in an earlier section. Default true.
- `headers` (boolean): Add a generated-by header, section headers and template comments. Default true.
- `list` (boolean): Just list the available templates (id, name, group, keywords).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `templates` (array): Templates to combine, in order, e.g. ["node", "nextjs", "vscode", "macos"].

### `hash_compute` (~175 tokens)

Hash (MD5 / SHA)

Compute MD5, SHA-1, SHA-256 and SHA-512 of text or a file (path or base64), optionally an HMAC with a key, and check against an expected checksum (hex in any case/spacing, "SHA256 (file) = …" lines, or base64). Web version: https://s3eidat.github.io/hash-lab/

Input parameters:

- `expected` (string): A checksum to compare against; the result says which algorithm matched.
- `file` (string): Or: a file to hash: local path or base64.
- `format` (string): Output encoding.
- `hmacAlgorithm` (string)
- `hmacKey` (string): If set, also compute HMAC with this key.
- `text` (string): Text to hash (UTF-8).

### `html_format` (~271 tokens)

HTML beautify / minify

Beautify (indent block elements, keep inline runs on one line) or minify HTML with a forgiving tokenizer: implied end tags (<p>, <li>, <td>…), void elements, and <script>, <style>, <pre>, <textarea> contents kept byte-for-byte. Whitespace between attributes is normalised; attribute values are never changed. Optional comment removal (IE conditional comments kept). Text only: nothing is rendered or run. Give "text" or a file "path". Web version: https://s3eidat.github.io/html-css-format/

Input parameters:

- `indent`: Indentation: 2, 4, "tab" (or any number of spaces 0-8).
- `mode` (string): "beautify" (default) or "minify".
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a HTML file (UTF-8; use this for big inputs).
- `removeComments` (boolean): Drop comments (IE conditional comments are kept).
- `text` (string): The HTML as inline text.

### `http_status` (~225 tokens)

HTTP status codes

Look up HTTP status codes: by exact code (e.g. 418, also non-standard ones like 499 or 524), by code prefix ("50"), or by words ("too many", "redirect post"), optionally limited to a class (1xx–5xx). Each result has the name, what it means, when to use it, common causes and the defining spec. Non-standard nginx/Cloudflare codes are only searched when "includeNonStandard" is set. Web version: https://s3eidat.github.io/http-status/

Input parameters:

- `class` (string): Only this class: 1 informational, 2 success, 3 redirection, 4 client error, 5 server error.
- `includeNonStandard` (boolean): Also search non-standard codes (nginx 499, Cloudflare 52x…).
- `limit` (integer): Max results to return. Default 20.
- `query` (string): A code ("404"), code prefix ("5", "50") or search words. Empty = all codes (filtered by class).

### `id_generate` (~276 tokens)

Generate IDs (UUID / ULID / NanoID)

Generate 1–1000 unique IDs with a cryptographic RNG: UUID v4 (random), UUID v7 (time-ordered, RFC 9562, strictly increasing within a batch), ULID (26 Crockford Base32 chars, monotonic) or NanoID (custom length 2–128 and alphabet: URL-safe default, alphanumeric, hex, digits, no look-alikes, or your own). Options: uppercase, no dashes. Web version: https://s3eidat.github.io/uuid-forge/

Input parameters:

- `alphabet` (string): NanoID alphabet: a preset ("A-Za-z0-9_-", "A-Za-z0-9", "0-9a-f", "0-9", "nolook") or your own characters (2–256 distinct; duplicates ignored).
- `count` (integer): How many IDs (1–1000).
- `kind` (string): Which ID type.
- `length` (integer): NanoID length (2–128). 21 URL-safe chars ≈ UUID v4 collision safety.
- `noDashes` (boolean): UUIDs only: drop the dashes (32 hex chars).
- `uppercase` (boolean): Upper-case output (UUID hex digits, ULID letters). Default false = lower case, like the website.

### `id_inspect` (~97 tokens)

Inspect a UUID / ULID

Check whether a string is a valid UUID (any version; braces, urn:uuid: and missing dashes accepted) or ULID, and report its version, variant and canonical form. For UUID v1, v6, v7 and ULID also returns the embedded creation time. Web version: https://s3eidat.github.io/uuid-forge/

Input parameters:

- `id` (string, required): The UUID or ULID to inspect.

### `image_ascii_art` (~350 tokens)

Image to ASCII art

Turn an image into ASCII art: each character cell takes the average brightness of its area (cells are twice as tall as wide) and maps it onto a character ramp: standard " .:-=+*#%@", detailed (70 characters), blocks " ░▒▓█", simple, binary, or your own. Contrast, brightness and invert (for light text on dark backgrounds). Returns the text; format "png" also renders it to an image (optionally in the image's colours). Transparent areas count as white paper. Web version: https://s3eidat.github.io/ascii-art/

Input parameters:

- `brightness` (number): -100 … 100. Default 0.
- `color` (boolean): PNG only: colour each character with the image colour.
- `columns` (integer): Characters per line. Default 100.
- `contrast` (number): -100 … 100. Default 0.
- `customRamp` (string): Characters for ramp "custom", from no ink to most ink (at least 2).
- `format` (string): text (default) or png (also writes <name>-ascii.png).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `invert` (boolean): For light text on a dark background. Default false.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `ramp` (string): Character set, light → dark. Default standard.

### `image_ascii_banner` (~257 tokens)

Text to ASCII banner

Big banner letters from text, using the website's own bitmap fonts: block (█ 5×7), char (any fill character, e.g. #), shadow (█ with ░ shade), compact (half-block 5×7), small (█ 3×5), tiny (half-block 3×5). Letters A-Z, digits and common punctuation (unknown characters show as "?"); one banner per input line. Returns the text; format "png" also renders it to banner.png. Web version: https://s3eidat.github.io/ascii-art/

Input parameters:

- `fill` (string): Fill character(s) for style "char". Default "#".
- `format` (string): text (default) or png (also writes banner.png).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `style` (string): Letter style. Default block.
- `text` (string, required): Text to render (case-insensitive). New lines make separate banners.
- `theme` (string): PNG colours: dark (teal on near-black, default) or light.

### `image_compress` (~383 tokens)

Compress image

Make an image file smaller: re-encode at a quality (default 80) and optionally cap the longest side (maxSide), as JPEG, WebP, AVIF or PNG ("keep" = same format; GIF/BMP/TIFF become PNG). Or give targetBytes to find the highest quality that fits that size. With keepSmaller (default on) the original is kept when re-encoding would not make it smaller. Reports before/after sizes and % saved. Transparent areas become white in JPEG. Metadata (EXIF, GPS) is not copied. PNG is lossless (quality ignored). Web version: https://s3eidat.github.io/image-squeeze/

Input parameters:

- `format` (string): Output format. Default keep (same as the input).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `keepSmaller` (boolean): Keep the original bytes when the result would be larger (same format and size only). Default true.
- `maxSide` (integer): Scale down so the longest side is at most this many pixels (e.g. 1920).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF. Default 80 (website default).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `targetBytes` (integer): Aim for a file of at most this many bytes: searches the highest quality that fits (lossy formats only; overrides quality).

### `image_convert` (~338 tokens)

Convert image format

Convert an image to PNG, JPEG, WebP, AVIF, GIF or TIFF. Reads JPEG, PNG, WebP, AVIF/HEIF, GIF (first frame), TIFF, SVG, BMP and ICO. Transparent areas are filled with `background` when writing JPEG (or always with `flatten`). EXIF rotation is applied. SVGs are rasterised at their own size (width/height or viewBox; 1024×1024 if neither), scripts never run. Images larger than 16384 px a side or 100 MP are scaled down to fit. Web version: https://s3eidat.github.io/image-convert/

Input parameters:

- `background` (string): Colour used for transparent areas when writing JPEG or when flatten is on. Default #ffffff.
- `flatten` (boolean): Fill transparency with the background for every format, not only JPEG.
- `format` (string): Output format. Default png (as on the website).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 92, same as the website.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `image_crop` (~433 tokens)

Crop image

Crop an image to a pixel box (x, y, width, height) or to an aspect ratio (1:1, 4:5, 3:2, 16:9, 9:16, "W:H" or a number), taking the largest centred region (or aligned to an edge with `position`). Boxes are kept inside the image. Output JPEG/PNG/WebP/AVIF, name <name>-<W>x<H>.<ext>. Web version: https://s3eidat.github.io/image-resize/

Input parameters:

- `format` (string): Output format. "keep" = same as the input when it is JPEG/PNG/WebP (else PNG). Default keep.
- `height` (integer): Height of the crop box (pixels).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `position` (string): Where the ratio crop sits. Default center (the website default).
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 90, same as the website.
- `ratio` (string|number): Aspect ratio as "W:H" (e.g. "1:1", "4:5", "3:2", "16:9", "9:16"), a number (width/height), "orig" or "free".
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `width` (integer): Width of the crop box (pixels).
- `x` (integer): Left edge of the crop box (pixels). Use with y, width, height.
- `y` (integer): Top edge of the crop box (pixels).

### `image_exif_read` (~157 tokens)

Read photo metadata (EXIF)

Show the hidden metadata in a photo: camera make/model, lens, date taken, exposure, ISO, software, author/copyright, serial numbers, comments, PNG text chunks, and GPS coordinates (where the photo was taken). Lists every metadata block (EXIF, XMP, ICC, IPTC, embedded previews) with its size and flags privacy-sensitive fields. JPEG and PNG fully; WebP/AVIF/HEIC/TIFF EXIF via sharp. Web version: https://s3eidat.github.io/exif-cleaner/

Input parameters:

- `image` (string, required): The photo: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).

### `image_exif_strip` (~348 tokens)

Remove photo metadata (EXIF)

Remove EXIF, GPS location, XMP, IPTC, comments, PNG text chunks and embedded previews from a photo before sharing it. JPEG and PNG are cleaned losslessly (image data copied byte for byte, like the website); by default the rotation is kept as a tiny orientation-only EXIF and the ICC colour profile is kept. applyOrientation re-encodes JPEGs with the rotation baked into the pixels. WebP/AVIF/HEIC/TIFF are re-encoded without metadata. Output name <name>-clean.<ext>. Web version: https://s3eidat.github.io/exif-cleaner/

Input parameters:

- `applyOrientation` (boolean): Instead of keeping the Orientation tag, rotate the pixels (re-encodes JPEG at `quality`; PNG is unaffected). Default false.
- `image` (string, required): The photo: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `keepIcc` (boolean): Keep the ICC colour profile (no personal data; keeps colours right). Default true.
- `keepOrientation` (boolean): Keep only the Orientation tag so the photo still shows the right way up. Default true.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `quality` (integer): JPEG/WebP/AVIF quality when re-encoding is needed. Default 92.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `image_favicon_set` (~372 tokens)

Favicon set generator

Make a complete favicon set from a letter/emoji/short text or from an image: favicon.ico (16, 32, 48 px), favicon-16x16.png, favicon-32x32.png, apple-touch-icon.png (180, square, solid), android-chrome-192x192.png and -512x512.png, site.webmanifest and head-snippet.html with the <link> tags. Rounded square with background colour (or transparent), corner radius and padding in %. Writes everything into one folder. Web version: https://s3eidat.github.io/favicon-forge/

Input parameters:

- `background` (string): Background colour. Default #0e7c86.
- `color` (string): Text colour. Default #ffffff.
- `fit` (string): How an image fills the padded square. Default contain.
- `image` (string): Use this image (logo) instead of text: a local path or base64. Square, 512 px+ works best.
- `name` (string): App name for site.webmanifest. Default "My Website".
- `output` (string): Folder to write the files into. Default: a new "favicons" folder in the output folder.
- `padding` (number): Padding around the text/image in %. Default 14.
- `radius` (number): Corner radius in % of the size (50 = circle). Default 22.
- `shortName` (string): Short name for site.webmanifest. Default "Site".
- `text` (string): Letter(s) or emoji drawn on the icon (when no image is given). Default "S".
- `transparent` (boolean): Transparent background (the Apple icon still gets white). Default false.
- `weight` (string): Font weight for text. Default 900.

### `image_from_base64` (~194 tokens)

Base64 / data URI to image file

Decode Base64 back into a file: accepts a data URI, a CSS url("data:…") rule, an <img src="data:…"> tag, URL-encoded SVG data URIs, or raw Base64 (standard or URL-safe, line breaks allowed). Detects the real type from the bytes, warns when it differs from the declared one, and writes decoded.<ext>. Give the text inline or as a path to a text file. Web version: https://s3eidat.github.io/image-to-base64/

Input parameters:

- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `path` (string): Or: a text file containing it.
- `text` (string): The data URI / CSS / <img> tag / raw Base64.

### `image_palette` (~249 tokens)

Colour palette from image

Extract the main colours of an image with their share of the picture: k-means (default, deterministic) or median cut, 1-16 colours, sorted by share. Transparent pixels are ignored. Returns hex + rgb + % per colour, CSS custom properties (:root { --color-1 … }) or JSON, and optionally writes the website's swatch strip as palette.png. Same algorithm and sampling as the website, so the colours match. Web version: https://s3eidat.github.io/palette-from-image/

Input parameters:

- `count` (integer): Number of colours. Default 6.
- `format` (string): Export text format. Default css.
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `method` (string): kmeans (default) or median (median cut).
- `output` (string): Where to write palette.png (file path or folder ending in "/"). Implies swatchPng.
- `swatchPng` (boolean): Also write palette.png (160×200 swatch per colour with its hex code).

### `image_placeholder` (~586 tokens)

Placeholder image

Make a placeholder image of any size (up to 8000 px a side): solid background with centred text (default "W × H", "\n" for line breaks), auto-fitted font size or a fixed one, PNG / JPEG / WebP / SVG. Size presets for web, social media, IAB ads and devices. Optionally returns a data URI / <img> tag for inlining. Text uses Inter when installed, else a system sans-serif. Web version: https://s3eidat.github.io/placeholder-image/

Input parameters:

- `background` (string): Background colour (#rgb or #rrggbb). Default #1f2937.
- `color` (string): Text colour (#rgb or #rrggbb). Default #9ca3af.
- `dataUri` (boolean): Also return the image as a data URI and an <img> tag (for small images).
- `fontSize` (number): Font size in px; 0 = auto-fit (default).
- `fontWeight` (string): Font weight. Default 600.
- `format` (string): Output format. Default png.
- `height` (integer): Height in pixels. Default 630.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `preset` (string): Size preset (overrides width/height): open-graph-link-preview 1200×630, hero-16-9-full-hd 1920×1080, hd-16-9 1280×720, blog-image-4-3 800×600, thumbnail-3-2 600×400, avatar 256×256, instagram-square…
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `text` (string): Text to show. Empty = "W × H". Use "\n" (backslash n) or a real newline for a line break.
- `width` (integer): Width in pixels. Default 1200.

### `image_resize` (~590 tokens)

Resize image

Resize an image by pixels or percent, keeping the aspect ratio. Give width or height (the other side follows), or both: fit "cover" (default, as on the website) centre-crops to that ratio first so nothing is stretched, "contain" fits inside the box, "fill" stretches. Optional crop ratio (1:1, 4:5, 3:2, 16:9, 9:16, orig) or crop box before resizing, social-media presets, output JPEG/PNG/WebP/AVIF. Up to 16384 px a side. Output name: <name>-<W>x<H>.<ext>. Web version: https://s3eidat.github.io/image-resize/

Input parameters:

- `crop` (object): Crop box (x, y, width, height in pixels) applied before resizing; overrides ratio.
- `fit` (string): When both width and height are set: cover (crop to fill, default), contain (fit inside), fill (stretch).
- `format` (string): Output format. "keep" = same as the input when it is JPEG/PNG/WebP (else PNG). Default keep.
- `height` (integer): Target height in pixels.
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `percent` (number): Scale by percent instead (e.g. 50 halves both sides, 200 doubles).
- `preset` (string): Exact output size preset: instagram-post 1080×1080, instagram-portrait 1080×1350, story 1080×1920, youtube-thumbnail 1280×720, x-header 1500×500, facebook-cover 851×315, linkedin-banner 1584×396, ful…
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 90, same as the website.
- `ratio` (string|number): Aspect ratio as "W:H" (e.g. "1:1", "4:5", "3:2", "16:9", "9:16"), a number (width/height), "orig" or "free".
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `width` (integer): Target width in pixels.

### `image_rotate` (~387 tokens)

Rotate / flip image

Rotate an image clockwise by 90, 180, 270 or any angle (the canvas grows to fit; new corners get `background`), and/or flip it horizontally (mirror) or vertically. Flips apply after the rotation, as seen on screen. EXIF orientation is applied first (autoOrient, default on), so with angle 0 this simply "fixes" sideways phone photos. Output JPEG/PNG/WebP/AVIF ("keep" = same as input), name <name>-rotated.<ext>. Web version: https://s3eidat.github.io/photo-filters/

Input parameters:

- `angle` (number): Clockwise rotation in degrees (negative = counter-clockwise). Default 90.
- `autoOrient` (boolean): Apply the EXIF Orientation tag first (what browsers show). Default true.
- `background` (string): Fill for the corners uncovered by a non-right-angle rotation. Default transparent (white in JPEG).
- `flipHorizontal` (boolean): Mirror left-right (after rotating).
- `flipVertical` (boolean): Mirror top-bottom (after rotating).
- `format` (string): Output format. Default keep (JPEG/PNG/WebP stay, others become PNG).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 92, same as the website.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `image_svg_to_png` (~314 tokens)

SVG to PNG

Rasterise an SVG to a crisp PNG: scale (1×, 2×, 3×, 4×… default 2×), a target width or height (aspect kept), or an exact size (stretched). Units (px, pt, mm, cm, in) and viewBox-only SVGs are understood; transparent background or a solid colour. Scripts, event handlers and external references are removed first. Name <name>@2x.png. Web version: https://s3eidat.github.io/svg-to-png/

Input parameters:

- `background` (string): Background colour when transparent is false. Default #ffffff.
- `height` (integer): Height in px for modes height / exact.
- `mode` (string): How to size the PNG. Default scale.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `scale` (number): Scale factor for mode "scale". Default 2.
- `svg` (string): The SVG: a local path or base64 / data URI.
- `svgText` (string): Or: the SVG code itself.
- `transparent` (boolean): Keep the background transparent. Default true.
- `width` (integer): Width in px for modes width / exact.

### `image_to_base64` (~288 tokens)

Image to Base64 / data URI

Encode an image (or any file) as Base64: a data URI, bare Base64, a CSS background-image rule, an HTML <img> tag (with width/height), Markdown, or for SVG a URL-encoded data URI (usually ~30% smaller). Detects the type from the bytes and warns when the result is too big to inline (over 10 KB: slows pages; over 1 MB: use a normal file). Results longer than maxChars are written to a .txt file instead of being returned. Web version: https://s3eidat.github.io/image-to-base64/

Input parameters:

- `as` (string): What to return: dataUri (default), base64, css, html, markdown, or svgUri (SVG only).
- `image` (string, required): The image: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `maxChars` (integer): Longest text returned inline; longer results go to a file. Default 200000.
- `mimeType` (string): Override the detected MIME type (e.g. image/svg+xml).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).

### `image_watermark` (~495 tokens)

Watermark image

Add a text or logo watermark to a photo. Size is a % of the photo width, margin a % of the shorter side, so the result looks the same on any resolution. One of 9 positions or tiled across the whole image (brick pattern), with opacity, rotation, colour, weight and a soft shadow for text. Logo: any image (PNG with transparency works best). Output keeps the input format (JPEG/PNG/WebP) or as chosen; name <name>-watermarked.<ext>. Text uses the Inter font when installed, else a system sans-serif. Web version: https://s3eidat.github.io/watermark/

Input parameters:

- `color` (string): Text colour. Default #ffffff.
- `format` (string): Output format. Default keep.
- `image` (string, required): The photo: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `logo` (string): Use this image as the watermark instead of text: a local path or base64.
- `margin` (number): Margin from the edge in % of the shorter side; spacing between tiles when tiled. Default 4.
- `opacity` (number): Opacity in %. Default 60.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `position` (string): Where the watermark sits (ignored when tiled). Default bottom-right.
- `quality` (integer): Quality 1-100 for JPEG / WebP / AVIF (ignored for PNG). Default 92, same as the website.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `rotation` (number): Rotation in degrees (e.g. -30 for a diagonal tile). Default 0.
- `shadow` (boolean): Soft drop shadow behind text. Default true.
- `size` (number): Watermark width as % of the photo width. Default 28.
- `text` (string): Watermark text (ignored when a logo is given). Default "© Your Name".
- `tiled` (boolean): Repeat the watermark across the whole photo.
- `weight` (string): Font weight. Default 700.

### `ip_in_range` (~126 tokens)

Is this IP in that range?

Check whether an IPv4 or IPv6 address falls inside a range given as CIDR ("10.0.0.0/8", "2001:db8::/32"), a dash range ("192.168.1.10 - 192.168.1.60") or a single address. Web version: https://s3eidat.github.io/subnet-calc/

Input parameters:

- `ip` (string, required): The address to test.
- `range` (string, required): CIDR, "start - end" range, or single address (same family as "ip").

### `json_format` (~272 tokens)

JSON format / minify / validate

Validate, pretty-print (2 or 4 spaces, tab) or minify JSON, optionally sorting object keys (deeply). Invalid JSON gives a clear error with line and column and the lines around it. Also returns size, key count, depth and value count. Give "text" or a file "path"; "output" writes the result to a file. Uses the standard JSON parser (no comments or trailing commas). Web version: https://s3eidat.github.io/json-studio/

Input parameters:

- `indent`: Indentation: 2, 4, "tab" (or any number of spaces 0-8).
- `mode` (string): "format" pretty-prints, "minify" removes all whitespace, "validate" only checks (never throws on bad JSON).
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a JSON file (UTF-8; use this for big inputs).
- `sortKeys` (boolean): Sort object keys alphabetically at every level.
- `text` (string): The JSON as inline text.

### `json_query` (~276 tokens)

JSON query (JSONPath)

Pick values out of JSON with a JSONPath expression. Supported: $ (root, optional), .key, ['key'], [0], [-1], [*], .*, ..key (recursive), [start:end:step] slices, unions [0,2] / ['a','b'], and filters like [?(@.price < 10 && @.tags)] (==, !=, <, <=, >, >=, =~ /regex/i, &&, ||, !, .length). Returns each match with its path (the same path style the website's tree view copies, e.g. $.store.book[0].title). Give "text" or a file "path". Web version: https://s3eidat.github.io/json-studio/

Input parameters:

- `limit` (integer): Return at most this many matches (default 1000).
- `output` (string): Optional: write the matched values as a JSON array to this file.
- `path` (string): Or: a path to a JSON file (UTF-8; use this for big inputs).
- `query` (string, required): JSONPath expression, e.g. "$.store.book[*].author" or "$..book[?(@.price < 10)].title".
- `text` (string): The JSON as inline text.

### `json_to_csv` (~295 tokens)

JSON to CSV

Convert JSON to CSV. An array of objects becomes one row per object with nested objects/arrays flattened to dotted columns (address.city, tags.0); an array of arrays is written as-is. Fields are quoted only when needed (delimiter, quotes, line breaks, leading/trailing spaces); CRLF line ends. A formula guard (on by default) prefixes cells starting with = + - @ so spreadsheets don't run them. Give "text" or a file "path". Web version: https://s3eidat.github.io/csv-json/

Input parameters:

- `bom` (boolean): Start with a UTF-8 BOM so Excel reads non-English text correctly.
- `delimiter` (string): Delimiter: "auto" (comma), ",", ";", "tab" or "|".
- `header` (boolean): Include a header row (default true).
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a JSON file (UTF-8; use this for big inputs).
- `safe` (boolean): Formula guard: prefix cells like =SUM(A1) with ' (default true).
- `text` (string): The JSON (array or object) as inline text.

### `json_to_types` (~306 tokens)

JSON to types (TypeScript, Go, Python, Zod)

Generate type definitions from a JSON sample: TypeScript interfaces (or type aliases), Go structs with json tags (initialisms like ID/URL, pointers for optional/nullable, optional omitempty), Python dataclasses (snake_case fields with the original key noted) and Zod schemas. All items of an array are merged into one type (missing keys become optional, null makes a field nullable, int+float → number/float64, mixed values → unions); identical shapes share one name. These four are every language the website supports. Give "text" or a file "path". Web version: https://s3eidat.github.io/json-to-types/

Input parameters:

- `export` (boolean): TypeScript / Zod: add the export keyword.
- `goOmitEmpty` (boolean): Go: add ,omitempty to optional fields.
- `language` (string): Output language, or "all" for all four.
- `output` (string): Optional: write the code to this file (with language "all", the four outputs joined by headers).
- `path` (string): Or: a path to a JSON file (UTF-8; use this for big inputs).
- `rootName` (string): Name of the top-level type (turned into PascalCase).
- `text` (string): The JSON sample as inline text.
- `tsTypeAlias` (boolean): TypeScript: use "type X = {…}" instead of "interface X {…}".

### `json_to_yaml` (~234 tokens)

JSON to YAML

Convert JSON to YAML (js-yaml dump: no line wrapping, no anchors; strings that would read as numbers/booleans are quoted). Options: 2 or 4 space indent, sort keys, and write a top-level array as a multi-document YAML stream (--- per item). Invalid JSON gives line and column. Give "text" or a file "path". Web version: https://s3eidat.github.io/yaml-json/

Input parameters:

- `indent`: Indentation: 2 or 4 spaces.
- `multiDocument` (boolean): A top-level JSON array becomes one YAML document per item.
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a JSON file (UTF-8; use this for big inputs).
- `sortKeys` (boolean): Sort mapping keys alphabetically.
- `text` (string): The JSON as inline text.

### `jwt_decode` (~199 tokens)

JWT decode

Decode a JSON Web Token (a leading "Bearer " is fine): header, payload, iat/nbf/exp/auth_time as ISO dates with relative time, expired / not-yet-valid status, and named standard claims. If "secret" is given, verifies HS256/HS384/HS512 signatures (secret as text or Base64URL). RS/ES/PS tokens are decoded but not verified (needs a public key). Encrypted JWE tokens can't be read. Web version: https://s3eidat.github.io/jwt-inspector/

Input parameters:

- `now` (number): Unix time in seconds to judge expiry against. Default: now.
- `secret` (string): HMAC secret to verify an HS256/384/512 signature.
- `secretIsBase64` (boolean): The secret is Base64/Base64URL-encoded bytes, not text.
- `token` (string, required): The JWT (header.payload.signature).

### `markdown_table` (~353 tokens)

Markdown table

Make a GitHub-flavoured Markdown table from CSV, TSV, a JSON array (of objects or of arrays), an existing Markdown table (to re-align / re-pad it) or a "rows" array. Per-column alignment (left, center, right), columns padded to line up (optional), pipes escaped as \| and line breaks as <br>. CSV delimiter (comma, semicolon, tab) is detected from the first line. Give "text", a file "path" or "rows". Web version: https://s3eidat.github.io/markdown-table/

Input parameters:

- `align`: Column alignment: one value for all columns or one per column. Default: keep a Markdown input's alignment, else none.
- `format` (string): Input format; "auto" detects Markdown, then JSON, then CSV/TSV.
- `header` (boolean): First row is the header. When false, "Column 1", "Column 2"… headers are added.
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a CSV/TSV/JSON/Markdown file (UTF-8; use this for big inputs).
- `pretty` (boolean): Pad cells so the columns line up (default true).
- `rows` (array): Or: the table as an array of rows (first row = header unless header is false).
- `text` (string): The CSV / TSV / JSON / Markdown table as inline text.

### `markdown_table_parse` (~201 tokens)

Markdown table to JSON / CSV

Read a Markdown table (pipes optional at the ends, \| escapes, <br> as line breaks) back into data: JSON objects keyed by the header, JSON arrays, or CSV; also returns each column's alignment. Uses the website's Markdown import. Give "text" or a file "path". Web version: https://s3eidat.github.io/markdown-table/

Input parameters:

- `as` (string): "objects" (header → keys), "arrays" (header row first) or "csv".
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a Markdown file (UTF-8; use this for big inputs).
- `text` (string): The Markdown table as inline text.

### `meta_tags_generate` (~345 tokens)

Meta tags generator

Generate the <head> HTML for SEO and social sharing: <title>, meta description, canonical link, Open Graph (og:type, url, title, description, image + alt, site_name, locale) and X/Twitter card tags. All values are HTML-escaped. Also checks lengths (title 30–60, description 70–160 characters), URLs and the @handle, and shows how Google, Facebook and X would truncate the title and description. URLs without a scheme get https://. Optionally writes the tags to an .html file. Web version: https://s3eidat.github.io/meta-tags/

Input parameters:

- `card` (string): X card type. Default summary_large_image.
- `description` (string): Meta description (aim for 70–160 characters).
- `image` (string): Share image URL (1200×630 recommended).
- `imageAlt` (string): Alt text for the share image.
- `locale` (string): og:locale, e.g. en_US or ar_AR.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `siteName` (string): Site name (og:site_name).
- `title` (string): Page title (aim for 30–60 characters).
- `twitter` (string): X/Twitter handle: "@name", "name" or a profile URL.
- `type` (string): og:type, e.g. website, article, product, profile. Default website.
- `url` (string): Canonical page URL.

### `password_check` (~167 tokens)

Password strength check

Estimate how strong a password really is, the way attackers guess (zxcvbn-style): finds common passwords (1,282-entry list), dictionary words (also reversed, capitalised or l33t), keyboard walks, sequences, repeats, years and dates, then the cheapest way to guess the whole thing. Returns a 0–4 score, entropy bits, guesses, crack time for 4 attack scenarios, the pieces found, and advice. Offline only: no breach lookups, nothing stored or logged. Web version: https://s3eidat.github.io/password-check/

Input parameters:

- `password` (string, required): The password to check (only the first 256 characters are analysed in detail).
- `showPieces` (boolean): Include the matched pieces (they contain parts of the password).

### `password_generate` (~366 tokens)

Password & passphrase generator

Generate strong random passwords (8–128 chars; lower/upper/digits/symbols; skip look-alikes Il1|O0o; exclude your own characters; require every chosen set) or passphrases (3–12 words from the website's 2,381-word list, separator, capitalise, add a number). Returns 1–1000 results with exact entropy bits, a strength grade and the time to crack at 100 billion guesses/s. Always crypto random (OS CSPRNG, rejection sampling); nothing is stored or logged. Web version: https://s3eidat.github.io/pass-forge/

Input parameters:

- `addNumber` (boolean): passphrase: append a number 0–99 to one random word.
- `avoidLookalikes` (boolean): password: leave out I l 1 | O 0 o.
- `capitalize` (boolean): passphrase: capitalise each word.
- `count` (integer): How many to generate.
- `digits` (boolean): password: include 0–9.
- `exclude` (string): password: characters never to use.
- `length` (integer): password: number of characters.
- `lower` (boolean): password: include a–z.
- `mode` (string): Random characters or random words.
- `requireEachSet` (boolean): password: at least one character from every chosen set.
- `separator` (string): passphrase: between words ("" = none, words then capitalised).
- `symbols` (boolean): password: include symbols !#$%&*+-=?@^_~()[]{}<>.,:;/|
- `upper` (boolean): password: include A–Z.
- `words` (integer): passphrase: number of words.

### `pdf_compress` (~296 tokens)

Compress PDF

Shrink a PDF by re-rendering every page as a JPEG image (best for scans and photo-heavy files). Presets like the website: email (96 DPI, quality 55), balanced (144 DPI, 72), high (220 DPI, 85); or set dpi/quality yourself; optional grayscale. The result loses selectable text, links and form fields. Reports before/after size and a verdict ("bigger" means keep the original: the PDF was already efficient). Web version: https://s3eidat.github.io/pdf-compress/

Input parameters:

- `dpi` (integer): Override the preset resolution (36-300 DPI).
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `grayscale` (boolean): Convert pages to grayscale.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `password` (string): Password, if the PDF is protected.
- `preset` (string): Quality preset. Default "balanced".
- `quality` (integer): Override the preset JPEG quality (30-95).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `pdf_extract_pages` (~223 tokens)

Extract PDF pages

Make one new PDF from selected pages of a PDF, e.g. "1-3, 7, 10-" (order as written, each page once). The rest of the file is left out. To reorder, duplicate or delete pages use pdf_organize. Web version: https://s3eidat.github.io/pdf-split/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string, required): Pages to keep: "1-3, 7, 10-" ("5-" = to the end; also "odd", "even", "last").
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `pdf_form_fields` (~121 tokens)

List PDF form fields

List the fillable fields of a PDF form in reading order: name, readable label, type (text, checkbox, radio, dropdown, list, signature, button), page, current value, options, and whether it is required / read-only / multi-line. Use the names with pdf_form_fill. Web version: https://s3eidat.github.io/pdf-fill/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).

### `pdf_form_fill` (~287 tokens)

Fill a PDF form

Fill PDF form fields by name (get names from pdf_form_fields): text as strings, checkboxes as true/false, radio groups and dropdowns by option text, lists as arrays. Optionally flatten (bake the answers into the page, no longer editable). Only changed fields are redrawn. Text the standard font cannot draw (Arabic…) is kept and viewers are asked to draw it, but cannot be flattened. Web version: https://s3eidat.github.io/pdf-fill/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `flatten` (boolean): Flatten the form after filling (fields become plain page content).
- `ignoreUnknown` (boolean): Skip names that are not in the form instead of failing.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `values` (object, required): Field name -> value, e.g. {"name": "Sara", "agree": true, "plan": "pro", "langs": ["Arabic"]}.

### `pdf_from_images` (~305 tokens)

Images to PDF

Make a PDF from images (JPEG, PNG, WebP, GIF, TIFF, AVIF, SVG…), one image per page, in the order given. Page size A4, Letter, or "fit" (page = image size at 96 dpi); orientation auto/portrait/landscape; margin in mm; quality "original" (JPEG/PNG kept as-is), high (≤3000 px, JPEG 90), medium (≤2000 px, 75) or small (≤1400 px, 60). Photos are turned upright from their EXIF orientation. Web version: https://s3eidat.github.io/images-to-pdf/

Input parameters:

- `images` (array, required): Images in page order: path/base64 strings, or {file, rotate}.
- `margin` (number): Margin around each image in mm. Default 10.
- `orientation` (string): "auto" turns the page to match each image. Ignored for "fit".
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pageSize` (string): Page size. Default "a4".
- `quality` (string): Image quality / size trade-off. Default "high".
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `pdf_info` (~168 tokens)

PDF info

Quick facts about a PDF for planning the next step: page count, page sizes (points, mm, paper name such as "A4 portrait", grouped by size), rotated pages, encryption, PDF version, form field count, title/author, and which pages have no text layer (scans that would need OCR). Related web tool: https://s3eidat.github.io/pdf-metadata/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `password` (string): Password, for the text check on a protected PDF.
- `textCheck` (boolean): Check which pages have a text layer (reads up to 500 pages). Default true.

### `pdf_merge` (~184 tokens)

Merge PDFs

Combine several PDFs into one, in the order given. Each entry can be a file (path or base64) or {file, pages} to take only some pages ("1-3, 5, 8-"; "3-1" keeps reverse order; a page can repeat). Password-protected PDFs must be unlocked first. Web version: https://s3eidat.github.io/pdf-merge/

Input parameters:

- `files` (array, required): PDFs to merge, in order: a path/base64 string, or {file, pages}.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `pdf_metadata_read` (~134 tokens)

Read PDF metadata

Show what a PDF reveals about itself: Title, Author, Subject, Keywords, Creator, Producer, creation/modification dates (with time zone), custom info fields, XMP metadata (size, edit history, creator) and the document ID. Optionally returns the XMP XML. Web version: https://s3eidat.github.io/pdf-metadata/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `includeXmp` (boolean): Also return the decoded XMP XML.

### `pdf_metadata_write` (~453 tokens)

Edit or strip PDF metadata

Change PDF info fields (title, author, subject, keywords, creator, producer, dates, custom fields) or strip all metadata: info fields, XMP, page-level data and the document ID, and drop unreachable leftovers from earlier edits so no trace stays in the bytes. Untouched values keep their exact original form. Web version: https://s3eidat.github.io/pdf-metadata/

Input parameters:

- `author` (string): Author. "" removes it; omit to keep it.
- `creationDate` (string): Creation date as ISO 8601, e.g. "2026-03-14T09:30:00+03:00". "" removes it; omit to keep it.
- `creator` (string): Creator (the app that made it). "" removes it; omit to keep it.
- `custom` (object): Custom info fields to set; null removes one. E.g. {"Company": null}.
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `keywords` (string): Keywords. "" removes it; omit to keep it.
- `modDate` (string): Modification date as ISO 8601. "" removes it; omit to keep it.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `producer` (string): Producer (the PDF engine). "" removes it; omit to keep it.
- `removeDocumentId` (boolean): Remove the document ID from the trailer.
- `removeXmp` (boolean): Remove the XMP metadata stream (and page-level XMP/PieceInfo).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `strip` (boolean): Remove ALL metadata (other edits are ignored).
- `subject` (string): Subject. "" removes it; omit to keep it.
- `title` (string): Title. "" removes it; omit to keep it.

### `pdf_organize` (~287 tokens)

Organize PDF pages

Rebuild a PDF from a page list: reorder, delete (leave pages out), duplicate (list a page twice) and insert blank pages. "3, 1-2, blank, 5-" puts page 3 first, then 1-2, a blank page (same size as the page before it), then 5 to the end; page 4 is dropped. Optionally rotate pages of the result. Existing page rotation is kept. Web version: https://s3eidat.github.io/pdf-organizer/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string, required): New page order (1-based source pages): e.g. "3, 1-2, blank, 2, 5-". Pages not listed are removed; "blank" adds an empty page.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `rotate` (array): Optional rotations applied to pages of the new order.

### `pdf_page_numbers` (~551 tokens)

Add page numbers

Add page numbers to a PDF, plus an optional header and footer line. Format tokens: {n}, {total}, {date}, {filename} (e.g. "Page {n} of {total}", "{n} / {total}", "- {n} -"). Choose the corner/edge, start number, how many leading pages to skip (e.g. a cover), a page range, font, size, colour and margin. Numbers stay upright on rotated pages. Web version: https://s3eidat.github.io/pdf-page-numbers/

Input parameters:

- `color` (string): Colour as hex "#rrggbb". Default #333333.
- `date` (string): Text for {date}. Default: today in the server locale.
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `font` (string)
- `footer` (string): Optional footer text on numbered pages (tokens allowed).
- `footerAlign` (string): Footer alignment: l, c or r.
- `format` (string): Number format with {n}, {total}, {date}, {filename}. Default "Page {n} of {total}". Empty = no number (header/footer only).
- `header` (string): Optional header text on numbered pages (tokens allowed).
- `headerAlign` (string): Header alignment: l, c or r.
- `margin` (number): Distance from the page edge in points. Default 28.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string): Pages to number: 1-based list like "1-3, 5, 8-" ("5-" = to the end, "-3" = first three, "3-1" = reversed). Also "all", "odd", "even", "last". Empty = all pages.
- `position` (string): Where the number goes: t/b = top/bottom, l/c/r = left/centre/right. Default "bc".
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `size` (number): Text size in points. Default 10.
- `skip` (integer): Leave this many first pages without a number (e.g. 1 for a cover). Default 0.
- `start` (integer): Number of the first numbered page. Default 1.

### `pdf_rotate` (~261 tokens)

Rotate PDF pages

Rotate selected pages of a PDF by 90, 180 or 270 degrees clockwise (-90 = counter-clockwise), on top of any rotation they already have. Other pages, links and form fields are left as they are. Web version: https://s3eidat.github.io/pdf-organizer/

Input parameters:

- `angle` (required): Clockwise degrees: 90, 180, 270, or -90.
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string): Pages to rotate: 1-based list like "1-3, 5, 8-" ("5-" = to the end, "-3" = first three, "3-1" = reversed). Also "all", "odd", "even", "last". Empty = all pages.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.

### `pdf_sign_image` (~433 tokens)

Sign PDF with an image

Place a signature (or initials, stamp, logo) image on PDF pages at x/y/width in points, measured from the top-left of the page as it is shown (rotated pages are handled). A light paper background is removed by default so scanned signatures sit cleanly on the page. Optional text marks (name, date…) can be added too. This is a visual signature, not a cryptographic digital signature. To draw a signature by hand, use the web version: https://s3eidat.github.io/pdf-sign/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `height` (number): Height in points. Default: keeps the image aspect ratio.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string): Pages to sign: "last" (default), "1", "all", "1-3"…
- `removeBackground` (boolean): Make light (paper) pixels transparent and trim to the ink. Default true.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `signature` (string): Signature image: local path or base64 (PNG, JPEG, WebP…).
- `texts` (array): Optional text marks, e.g. the printed name or the date.
- `threshold` (integer): Brightness (0-255) above which pixels become transparent. Default 210.
- `width` (number): Width in points. Default 150 (about 5.3 cm).
- `x` (number): Left edge in points from the left of the page (72 pt = 1 inch). Default 72.
- `y` (number): Top edge in points from the TOP of the page. Default: 72 pt above the bottom margin.

### `pdf_split` (~287 tokens)

Split PDF

Split one PDF into several PDFs written to a folder: by page ranges (one file per range, e.g. "1-3, 4-6, 7-"), every N pages, or one file per page. Files are named like the website: <name>-pages-1-3.pdf, <name>-part-01.pdf, <name>-page-001.pdf. Use pdf_extract_pages to get a single PDF with chosen pages. Web version: https://s3eidat.github.io/pdf-split/

Input parameters:

- `every` (integer): For mode "every": pages per file (e.g. 2 makes 1-2, 3-4…).
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `mode` (string, required): "ranges": one PDF per range in `ranges`; "every": a new PDF every `every` pages; "single": one PDF per page.
- `output` (string): Folder to write the PDFs into (created if missing). Default: a new folder in the server output folder.
- `ranges` (string): For mode "ranges": comma-separated ranges, each becomes one PDF, e.g. "1-3, 4-6, 7-".

### `pdf_to_images` (~324 tokens)

PDF to images

Render PDF pages to PNG, JPEG or WebP images in a folder (one file per page, named <name>-p001.png…). Choose the DPI (72 = screen size, 150 = default, 300 = print), JPEG/WebP quality, a page range, and a transparent background for PNG/WebP. Very large pages are capped at 16384 px a side / 16.7 megapixels, like the website. Web version: https://s3eidat.github.io/pdf-to-images/

Input parameters:

- `dpi` (number): Resolution in dots per inch. Default 150.
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `format` (string): Image format. Default "png".
- `output` (string): Folder to write the images into (created if missing). Default: a new folder in the server output folder.
- `pages` (string): Pages to render: 1-based list like "1-3, 5, 8-" ("5-" = to the end, "-3" = first three, "3-1" = reversed). Also "all", "odd", "even", "last". Empty = all pages.
- `password` (string): Password, if the PDF is protected.
- `quality` (integer): JPEG/WebP quality 1-100. Default 90.
- `transparent` (boolean): Keep the page background transparent (PNG/WebP only).

### `pdf_to_text` (~369 tokens)

PDF to text

Extract the text of a PDF with lines and paragraphs rebuilt (right-to-left Arabic/Hebrew lines in reading order), as plain text or Markdown, with optional page separators and reflow (join lines, mend hyphenated words). Returns per-page word counts and flags pages with no text layer (scans: this tool does no OCR). Supports page ranges and passwords. Give "output" to write a .txt/.md file instead of returning the text inline. Web version: https://s3eidat.github.io/pdf-to-text/

Input parameters:

- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `format` (string): "text" or "markdown" (## Page N headings, reflowed paragraphs).
- `maxChars` (integer): Cut the inline text after this many characters (the file output is never cut).
- `output` (string): Write the text to this file (or folder ending in "/") instead of returning it inline.
- `pages` (string): Pages to read: 1-based list like "1-3, 5, 8-" ("5-" = to the end, "-3" = first three, "3-1" = reversed). Also "all", "odd", "even", "last". Empty = all pages.
- `password` (string): Password, if the PDF is protected.
- `perPage` (boolean): Also return each page's text separately.
- `reflow` (boolean): Join the lines of each paragraph and mend words split by a hyphen.
- `separators` (boolean): Put a "——— Page N ———" line before each page. Default true.

### `pdf_watermark` (~479 tokens)

Watermark PDF

Stamp a text or image watermark on PDF pages: centred or tiled across the page, with opacity, angle, size, colour and a page range. It reads upright on rotated pages. Text the standard PDF fonts cannot draw (Arabic, CJK…) is stamped as an image. Defaults match the website: "CONFIDENTIAL", Helvetica Bold 72 pt, #d64545, 25% opacity, 45°. Web version: https://s3eidat.github.io/pdf-watermark/

Input parameters:

- `angle` (number): Rotation in degrees, counter-clockwise as shown. Default 45.
- `color` (string): Colour as hex "#rrggbb". Default #d64545.
- `file` (string, required): The PDF: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).
- `font` (string): Font for text.
- `gap` (number): Space between tiles in points (tile mode). Default 80.
- `image` (string): Image watermark instead of text: a local path or base64 (PNG, JPEG, WebP, SVG…).
- `mode` (string): "center": one stamp in the middle; "tile": repeated across the page.
- `opacity` (number): Opacity in % (1-100). Default 25.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `pages` (string): Pages to stamp: 1-based list like "1-3, 5, 8-" ("5-" = to the end, "-3" = first three, "3-1" = reversed). Also "all", "odd", "even", "last". Empty = all pages.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `scale` (number): Image width as % of the page width. Default 40.
- `size` (number): Text size in points. Default 72.
- `text` (string): Watermark text (default "CONFIDENTIAL"). Ignored when "image" is given.

### `prayer_times` (~589 tokens)

Prayer times

Islamic prayer times (Fajr, Sunrise, Dhuhr, Asr, Maghrib, Isha) for any coordinates + IANA time zone, or a known city, for one day, several days or a whole month, plus the Hijri (Umm al-Qura) date and the next prayer with a countdown. Same astronomy as the website (adhan.js): 13 methods (Jordan Awqaf, MWL, Umm al-Qura, Egyptian, ISNA, Karachi, Dubai, Kuwait, Qatar, Turkey, Singapore, Tehran, Moonsighting), Shafi'i or Hanafi Asr, and the recommended high-latitude rule beyond 48° (overridable). Times are local HH:MM (24 h) in the given zone, plus UTC ISO. Coordinates are rounded to 4 decimals like the site. Web version: https://s3eidat.github.io/prayer-times/

Input parameters:

- `asr` (string): Asr school: "shafi" (standard: Shafi'i, Maliki, Hanbali) or "hanafi". Default shafi (hanafi for Karachi-method cities).
- `city` (string): A known city (sets coordinates, time zone and its usual method): amman, irbid, zarqa, aqaba, mecca, medina, riyadh, jeddah, jerusalem, gaza, damascus, beirut, baghdad, cairo, alexandria, dubai, abudh…
- `date` (string): First day, YYYY-MM-DD in the place's calendar. Default: today there.
- `days` (integer): How many consecutive days to return.
- `highLatitudeRule` (string): "auto" = website behaviour (recommended rule when |latitude| > 48°).
- `latitude` (number): Latitude in degrees (−90..90). Use with longitude and timezone.
- `longitude` (number): Longitude in degrees (−180..180).
- `method` (string): Calculation method. Default: the city's usual method, else "mwl".
- `month` (string): Or a whole month timetable, YYYY-MM (overrides date/days).
- `now` (string): Reference instant (ISO 8601) for "today" and the next prayer. Default: the current time.
- `timezone` (string): IANA time zone of the place, e.g. "Asia/Amman" (required with coordinates; overrides the city's).

### `qibla_direction` (~300 tokens)

Qibla direction

Qibla direction (great-circle bearing from true north to the Kaaba in Makkah) and distance from any coordinates or a known city, with the compass point, a "face north, then turn right/left N°" instruction, and (if you give a device heading) how far to turn. Bearings are from TRUE north; a magnetic compass can differ by a few degrees. Web version: https://s3eidat.github.io/qibla-finder/

Input parameters:

- `city` (string): Or a known city: amman, irbid, zarqa, aqaba, mecca, medina, riyadh, jeddah, jerusalem, gaza, damascus, beirut, baghdad, cairo, alexandria, dubai, abudhabi, doha, kuwait, manama, muscat, istanbul, cas…
- `heading` (number): Optional: the direction you are facing now (degrees from north) to get a turn instruction.
- `latitude` (number): Latitude in degrees (−90..90).
- `longitude` (number): Longitude in degrees (−180..180).

### `qr_generate` (~788 tokens)

QR code generator

Make a QR code as SVG or PNG for a link, plain text, Wi-Fi login, contact card (vCard 3.0), email, SMS, phone call or map location. Same encoder as the website (qrcode.js: versions 1-40, error correction L/M/Q/H, smallest version that fits, best mask), UTF-8 so Arabic/emoji work. Options: size in px, quiet-zone margin, colours, square/rounded/dots modules, and an optional centre logo (forces level H). Returns the file path, the exact encoded text, version, module count and contrast warnings. Max about 2.9 KB of data at level L. Web version: https://s3eidat.github.io/qr-studio/

Input parameters:

- `address` (string): vcard: address.
- `background` (string): Background colour, hex (default #ffffff).
- `body` (string): email: message body.
- `company` (string): vcard: company.
- `ecc` (string): Error correction: L 7%, M 15% (default), Q 25%, H 30%. A logo forces H.
- `email` (string): vcard: email address.
- `firstName` (string): vcard: first name.
- `foreground` (string): Module colour, hex (default #0d0f12).
- `format` (string): Output format.
- `hidden` (boolean): wifi: the network is hidden.
- `jobTitle` (string): vcard: job title.
- `label` (string): geo: optional place label (?q=).
- `lastName` (string): vcard: last name.
- `latitude` (number|string): geo: latitude, -90..90.
- `logo` (string): Optional centre logo image (path or base64, max 5 MB). Covers ~22% of the code; error correction becomes H.
- `longitude` (number|string): geo: longitude, -180..180.
- `margin` (integer): Quiet zone in modules (default 4; under 2 may not scan).
- `message` (string): sms: message text.
- `mode` (string): Encoding mode. "byte" (UTF-8, what the website uses), "auto" (numeric/alphanumeric when the text allows, smaller codes), or force one.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `password` (string): wifi: password (ignored for open networks).
- `phone` (string): vcard/sms/tel: phone number.
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `security` (string): wifi: WPA (WPA/WPA2/WPA3, default), WEP, or nopass (open).
- `shape` (string): Module shape. Rounded/dots also round the three finder squares.
- `size` (integer): Image width/height in px (default 1024).
- `ssid` (string): wifi: network name.
- `subject` (string): email: subject.
- `text` (string): text: any text (encoded exactly as given).
- `to` (string): email: recipient address.
- `type` (string): What the code holds. Default: "url" if url is given, else "text".
- `url` (string): url: web address; "https://" is added when no scheme is given.
- `version` (integer): QR version 1-40 (size), or 0 = smallest that fits (default).
- `website` (string): vcard: website.

### `qr_read` (~190 tokens)

QR code reader

Read (decode) a QR code from an image file: photo, screenshot or scan (PNG, JPEG, WebP, GIF, TIFF, AVIF, SVG). Uses jsQR like the website, trying several sizes and inverted (light-on-dark) codes. Returns the text plus what it is (Link, Wi-Fi, Contact, Email, SMS, Phone, Location, Event or Text) with parsed fields, and safety notes for links (http, hidden @ user part, punycode lookalikes, bare IPs, odd ports). Links are never opened. Reads one code per image. Web version (with camera): https://s3eidat.github.io/qr-scanner/

Input parameters:

- `image` (string, required): The image containing a QR code: a local file path (absolute, or relative to the server's --root) or base64 data (raw or a data: URI).

### `qr_wifi` (~440 tokens)

Wi-Fi QR code and card

Make a Wi-Fi QR code that phones join by scanning (WPA/WPA2/WPA3, WEP or open; hidden networks), as PNG or SVG, or a printable PDF card like the website's: coloured header with the Wi-Fi symbol, "Scan to join", the QR code, network name and (optionally) the password, on an A6 card, an A4 poster, or A4 sheets of 4 or 9 cards to cut. Special characters (; , : " \) are escaped. The PDF card uses English labels and Latin text only for now. Web version: https://s3eidat.github.io/wifi-card/

Input parameters:

- `format` (string): pdf = printable card sheet (default); png/svg = just the QR code.
- `hidden` (boolean): The network is hidden (not broadcast).
- `layout` (string): PDF: a6 = one A6 card; a4 = one A4 poster; a4x4 = A4 sheet of 4 cards (default); a4x9 = A4 sheet of 9 small cards.
- `margin` (integer): PNG/SVG: quiet zone in modules.
- `output` (string): Where to write the result: a file path, or a folder ending in "/". Default: the server output folder (a temp folder unless --out-dir is set).
- `password` (string): Wi-Fi password (ignored for open networks).
- `returnBase64` (boolean): Also return the output as base64 in the result (only for small files). Default false.
- `security` (string): WPA (WPA/WPA2/WPA3, default), WEP, or nopass (open network).
- `showPassword` (boolean): PDF: print the password under the code.
- `size` (integer): PNG/SVG: image size in px.
- `ssid` (string, required): Network name (SSID).
- `theme` (string): PDF: card colour; "saver" is an ink-saving outline.
- `title` (string): PDF: heading on the card (default "Wi-Fi").

### `random_dice` (~300 tokens)

Dice roller, coin flip, random numbers

Roll dice with standard notation (2d6+3, d20, d%, 4d6dl1 / "4d6 drop lowest", 2d20kh1 advantage, 2d20kl1, 5d10dh2; up to 100 dice per term, 2–1000 sides, 20 terms), flip coins (counts + streaks), or draw random whole numbers in a range (optionally unique and sorted, up to 10,000). Crypto random with rejection sampling (no modulo bias); optional seed for reproducible results. Web version: https://s3eidat.github.io/dice-roller/

Input parameters:

- `count` (integer): numbers: how many numbers.
- `flips` (integer): coin: how many coins to flip.
- `max` (integer): numbers: largest value (inclusive).
- `min` (integer): numbers: smallest value (inclusive).
- `mode` (string): What to do.
- `notation` (string): dice: the dice notation, e.g. "3d8+2d6+4".
- `rolls` (integer): dice: how many times to roll the expression.
- `seed` (string): Optional seed for a reproducible result (same seed + same input = same output). Omit for true crypto randomness.
- `sort` (boolean): numbers: sort ascending.
- `unique` (boolean): numbers: no repeats.

### `random_pick` (~201 tokens)

Wheel picker (random pick)

Pick a random winner (or several, without repeats, like spinning with "remove winner" on) from a list of names, or shuffle / sort the whole list. Fair: crypto random with rejection sampling. Entries are trimmed, cut to 100 characters, max 500; at least 2 needed. Optional seed for a reproducible draw. Web version: https://s3eidat.github.io/wheel-picker/

Input parameters:

- `count` (integer): How many winners to pick (each winner is removed before the next spin).
- `items` (array): The entries, one per array item.
- `mode` (string): "pick" winners, "shuffle" the list, or "sort" it A→Z.
- `seed` (string): Optional seed for a reproducible result (same seed + same input = same output). Omit for true crypto randomness.
- `text` (string): Or: the entries as text, one per line.

### `random_teams` (~299 tokens)

Team maker

Split a list of people into fair random teams: choose the number of teams or people per team. Add a skill level ("Ali, 5" / "Sara: 3") and teams are balanced by total skill (people without one count as the average). Team names: numbers, letters, colours, animals or your own. Crypto-random shuffle; optional seed for a reproducible split. Max 2000 people, 100 teams. Web version: https://s3eidat.github.io/team-maker/

Input parameters:

- `balance` (boolean): Balance teams by skill when skills are given.
- `customNames` (array): naming=custom: team names in order (missing ones fall back to "Team N").
- `mode` (string): "teams": make `num` teams; "per": `num` people per team.
- `naming` (string): Team names: Team 1…, Team A…, colours, animals, or customNames.
- `num` (integer): Number of teams (min 2) or people per team (min 1), see mode.
- `people` (array): People, one per item, optionally "Name, skill" (skill 0–100).
- `seed` (string): Optional seed for a reproducible result (same seed + same input = same output). Omit for true crypto randomness.
- `text` (string): Or: people as text, one per line.

### `regex_test` (~231 tokens)

Regex test

Run a JavaScript regular expression against text: every match with its index, length, numbered and named capture groups, plus an optional replace preview ($1, $<name>, $&, $`, $', $$). Flags g i m s u y (and d, v). Runs in an isolated worker with a timeout (default 1.5 s) so catastrophic backtracking is reported instead of hanging. Lists up to 5000 matches. Web version: https://s3eidat.github.io/regex-playground/

Input parameters:

- `flags` (string): Regex flags, default "g".
- `limit` (integer): Max matches to include in the result (count is still total). Default 500.
- `pattern` (string, required): The regex source, without slashes, e.g. "(\\d+)-(?<w>[a-z]+)".
- `replace` (string): Replacement string for a replace preview (JavaScript String.replace syntax).
- `text` (string, required): The text to search.
- `timeoutMs` (integer): Kill the regex after this many ms. Default 1500.

### `secret_santa_draw` (~241 tokens)

Secret Santa draw

Draw Secret Santa (gift exchange) pairs: everyone gives to exactly one other person and receives from one, never themselves. Exclusions (couples, housemates…) block a pair both ways. Checks exactly whether a draw is possible and explains why not (and which exclusion to drop). Crypto random and uniform; optional seed. Up to 200 people. Nothing is emailed: hand each giver only their own line. Optional budget, date and message are echoed for slips. Web version: https://s3eidat.github.io/secret-santa/

Input parameters:

- `budget` (string): Optional gift budget, e.g. "20 JD".
- `date` (string): Optional exchange date, YYYY-MM-DD.
- `exclusions` (array): Pairs of names who must not draw each other, e.g. [["Omar","Sara"]].
- `message` (string): Optional note for everyone.
- `names` (array, required): Participants (an item may also hold several names separated by commas or new lines).
- `seed` (string): Optional seed for a reproducible result (same seed + same input = same output). Omit for true crypto randomness.

### `sql_format` (~349 tokens)

SQL format / minify

Format SQL (one clause per line, indented sub-queries, CASE blocks, JOIN … ON with AND/OR, CREATE TABLE column lists) or minify it to one line per statement. Options: keyword case (UPPER, lower, keep), indent (2, 4, tab), trailing or leading commas, keep/drop comments when minifying. Dialect-neutral tokenizer: understands -- and /* */ comments, '' and E'\'' strings, "x", `x` and [x] identifiers, $$ dollar quotes, ::casts, JSON operators, :name/$1/? parameters. Only re-spaces; never runs anything. Give "text" or a file "path". Web version: https://s3eidat.github.io/sql-format/

Input parameters:

- `commas` (string): Put list commas at line ends (trailing) or starts (leading).
- `indent`: Indentation: 2, 4 or "tab".
- `keepComments` (boolean): Minify only: keep comments (as /* */). Optimizer hints /*+ */ and /*! */ are always kept.
- `keywordCase` (string): Keyword and built-in function case.
- `mode` (string): "format" (default) or "minify".
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a .sql file (UTF-8; use this for big inputs).
- `text` (string): The SQL as inline text.

### `subnet_calc` (~322 tokens)

Subnet calculator (IPv4 / IPv6)

IPv4: from "192.168.1.0/26", "10.0.0.5 255.255.255.0" or a wildcard mask, get network, broadcast, first/last host, usable and total addresses, netmask, wildcard, class, address type (private, CGNAT, loopback, documentation…), integer/hex/binary forms; optionally split into N equal subnets or allocate VLSM blocks by host counts ("Sales:50, Ops:20"). /31 and /32 follow RFC 3021. IPv6: compressed (RFC 5952) and expanded forms, network, first/last address, address count, number of /64s, reverse DNS name and type. Web version: https://s3eidat.github.io/subnet-calc/

Input parameters:

- `address` (string, required): IPv4 or IPv6 address, optionally with /prefix (or an IPv4 dotted mask after a space or slash).
- `prefix` (integer): Prefix length to use when "address" has none (default /24 for IPv4, /128 for IPv6), or to override it.
- `split` (integer): IPv4: split the network into at least this many equal subnets (rounded up to a power of two; first 4096 listed).
- `vlsm` (string): IPv4: VLSM host requirements, e.g. "50, 20, 10" or "Sales:50, Ops:20". Largest first, each block aligned.

### `text_arabic` (~505 tokens)

Arabic text tools

Arabic text utilities. mode "clean": remove tashkeel (harakat and Quranic marks, optionally keeping shadda), remove tatweel (kashida), normalise letters (alef with hamza/madda/wasla → bare alef; alef maqsura and Farsi ya → ya; ta marbuta → ha; hamza on waw/ya → waw/ya), switch Latin , ; ? to Arabic punctuation, and convert digits (Arabic-Indic ↔ Western). mode "arabizi": turn Arabizi / Franco-Arabic chat text (mar7aba, 3arabi, 5ala9, el bait) into Arabic script. Returns the result with letter/word/character counts. Give "text" or a text file "path". Web version: https://s3eidat.github.io/arabic-tools/

Input parameters:

- `arabicPunctuation` (boolean): clean: Latin comma, semicolon and question mark → Arabic ones.
- `digits` (string): clean: keep digits, convert Arabic-Indic/Persian digits to 0-9 ("western"), or 0-9 to Arabic-Indic ("arabic").
- `keepShadda` (boolean): clean: when removing tashkeel, keep the shadda.
- `mode` (string): "clean" = clean & normalise Arabic text (default); "arabizi" = Arabizi (Latin letters + numbers) → Arabic script.
- `normalizeAlef` (boolean): clean: alef with hamza above/below, madda or wasla → bare alef.
- `normalizeHamza` (boolean): clean: hamza on waw → waw, hamza on ya → ya.
- `normalizeYa` (boolean): clean: alef maqsura and Farsi ya → Arabic ya.
- `output` (string): Optional: write the result to this file path (or folder ending in "/") instead of returning it.
- `path` (string): Or: a path to a UTF-8 text file.
- `removeTashkeel` (boolean): clean: remove tashkeel / harakat (default true).
- `removeTatweel` (boolean): clean: remove tatweel / kashida (default true).
- `taMarbutaToHa` (boolean): clean: ta marbuta → ha.
- `text` (string): The text to transform.

### `text_case` (~100 tokens)

Case convert

Convert text case: upper, lower, title (smart: keeps small words lower and iPhone/NASA as typed), sentence, camel, pascal, snake, kebab, constant, alternate, inverse. Works line by line and handles Unicode (Arabic, accents, ß). Web version: https://s3eidat.github.io/case-convert/

Input parameters:

- `mode` (string, required): Target case.
- `text` (string, required): Text to convert.

### `text_citation` (~222 tokens)

Citation generator

Format references from structured fields in APA 7, MLA 9, Chicago author-date (17th), Harvard (Cite Them Right) or IEEE, for books, book chapters, journal articles, web pages, newspaper/magazine articles, videos and reports. Handles author-count rules (et al.), initials, organisations as authors, editions, page ranges (MLA 127-53), DOIs, URLs and access dates, and title case for MLA/Chicago/IEEE. Returns each citation as plain text and HTML (italics as <i>), the in-text citation, missing-field hints, and the whole list as a bibliography sorted for the style (numbered for IEEE). Web version: https://s3eidat.github.io/citation-gen/

Input parameters:

- `autoCase` (boolean): Apply title case where the style wants it (MLA, Chicago, IEEE book titles). Default true.
- `sources` (array, required): One or more sources.
- `style` (string, required): Citation style: apa, mla, chicago, harvard or ieee.

### `text_clean` (~441 tokens)

Text cleaner

Clean up text line by line with a fixed pipeline (same order as the website): strip HTML tags and decode entities → remove emojis → trim each line → collapse repeated spaces → remove empty lines → remove duplicate lines (optionally ignoring case) → sort (A–Z, Z–A, natural, by length) → reverse → shuffle (seedable) → add line numbers. Returns the cleaned text plus counts, or writes it to a file when "output" is given. Give "text" or a text file "path". Web version: https://s3eidat.github.io/text-cleaner/

Input parameters:

- `collapseSpaces` (boolean): Collapse runs of spaces/tabs into one space (default true).
- `ignoreCase` (boolean): When removing duplicates, treat lines that differ only in case as duplicates (default false).
- `numberLines` (boolean): Prefix each line with its number ("1. ", padded) (default false).
- `output` (string): Optional: write the cleaned text to this file path (or folder ending in "/") instead of returning it.
- `path` (string): Or: a path to a UTF-8 text file.
- `removeDuplicates` (boolean): Remove duplicate lines, keeping the first (default false).
- `removeEmoji` (boolean): Remove emojis (©, ® and ™ are kept) (default false).
- `removeEmptyLines` (boolean): Remove empty (whitespace-only) lines (default true).
- `reverse` (boolean): Reverse the line order (default false).
- `seed` (integer): Seed for a reproducible shuffle (default: random).
- `shuffle` (boolean): Shuffle the lines (default false).
- `sort` (string): Sort lines: none (default), az, za, natural (item 2 before item 10), length (shortest first).
- `stripHtml` (boolean): Strip HTML tags (drops script/style/comments, block ends become line breaks) and decode entities (default false).
- `text` (string): The text to clean.
- `trim` (boolean): Trim spaces at the start and end of each line (default true).

### `text_diff` (~264 tokens)

Diff two texts

Compare two texts line by line (Myers diff) and return a unified diff (3 lines of context, like `diff -u`), counts of added/removed/unchanged lines, and change blocks where each removed line is paired with the added line that replaced it and the changed words are marked [-old-] / {+new+}. Can ignore whitespace and case. Works with any language (Arabic included). Up to 50,000 lines per side. Web version: https://s3eidat.github.io/diff-view/

Input parameters:

- `changed` (string): The changed text ("after").
- `changedPath` (string): Or: path to the changed text file.
- `ignoreCase` (boolean): Treat lines that differ only in letter case as equal.
- `ignoreWhitespace` (boolean): Treat lines that differ only in spacing as equal.
- `nameA` (string): Label for the "---" header (default "original").
- `nameB` (string): Label for the "+++" header (default "changed").
- `original` (string): The original text ("before").
- `originalPath` (string): Or: path to the original text file.
- `wordDiff` (boolean): Mark the changed words inside paired lines (default true).

### `text_escape` (~446 tokens)

Escape / unescape text

Escape or unescape a string for a target: JSON (string body), JavaScript (incl. template literals), HTML, XML, URL (encodeURIComponent, optional form +), SQL (doubled quotes, optional MySQL backslashes and wrapping quotes), CSV field (RFC 4180; comma, semicolon or tab), regex, POSIX shell single quotes, C/C++, Java/C#, and Unicode escapes (\uXXXX, \u{X}, \UXXXXXXXX, &#xX;, U+XXXX). Options per target as on the website. Set "allTargets" to get the escaped form for every target at once. Web version: https://s3eidat.github.io/text-escape/

Input parameters:

- `allTargets` (boolean): escape only: also return the text escaped for every target.
- `alwaysQuote` (boolean): csv: always quote the field.
- `ascii` (boolean): json/js/html/c/java: also escape non-ASCII characters (c: as UTF-8 octal).
- `delimiter` (string): csv: field delimiter (comma, semicolon or tab).
- `direction` (string): escape (default) or unescape.
- `every` (boolean): unicode: escape every character, not only non-ASCII.
- `form` (boolean): url: form style, + for spaces.
- `mysql` (boolean): sql: escape backslashes too (MySQL).
- `named` (boolean): html (with ascii): prefer named entities such as &copy;.
- `target` (string, required): Format: json, js, html, xml, url, sql, csv, regex, shell, c, java, unicode.
- `text` (string, required): The text to escape, or the escaped text to unescape.
- `unicodeFormat` (string): unicode: u4 = \uXXXX (JS, JSON, Java), ubrace = \u{X} (ES6, Rust, Swift), u8 = \UXXXXXXXX (Python, C), html = &#xX;, uplus = U+XXXX.
- `wrap` (boolean): sql: wrap in single quotes (unescape: strip them).

### `text_fancy` (~226 tokens)

Fancy text (Unicode styles)

Restyle text with Unicode look-alike characters for bios and posts (28 styles): Bold, Italic, Bold italic, Script, Bold script, Fraktur, Bold fraktur, Double-struck, Sans-serif, Sans bold, Sans italic, Sans bold italic, Monospace, Circled, Circled dark, Squared, Squared dark, Parenthesized, Fullwidth, Small caps, Superscript, Upside down, Strikethrough, Underline, Double underline, Slashed, Overline, Wide spaced. Only Latin letters and digits change (other scripts such as Arabic and emoji pass through); some styles cover only capitals or only some symbols. Give one "style", or none to get every style. Up to 20,000 characters. Web version: https://s3eidat.github.io/fancy-text/

Input parameters:

- `style` (string): One style name (exact, e.g. "Bold", "Script", "Upside down"). Omit to get all styles.
- `text` (string, required): The text to restyle.

### `text_layout_fix` (~241 tokens)

Keyboard layout fixer (EN ⇄ AR)

Fix text typed with the wrong keyboard layout between US English (QWERTY) and Arabic (101): "hgsghl ugd;l" becomes the Arabic greeting, and Arabic gibberish typed on English keys becomes "hello". Direction "auto" detects it; in mixed text only the words that look mistyped are converted (using small English/Arabic letter-pair models), so words that are already right stay as they are. Handles the shift layer (harakat, hamza forms), lam-alef keys and Caps Lock (all-caps Latin input is treated as lowercase). Web version: https://s3eidat.github.io/layout-fixer/

Input parameters:

- `capsLock` (boolean): Caps Lock was on: treat capital Latin letters as lowercase (detected automatically when all letters are capitals).
- `direction` (string): "auto" (default) detects; "ar" = typed on English keys, convert to Arabic; "en" = typed on Arabic keys, convert to English.
- `path` (string): Or: a path to a UTF-8 text file.
- `text` (string): The mistyped text.

### `text_lorem` (~254 tokens)

Lorem ipsum generator

Generate placeholder text: classic Lorem ipsum, readable English filler, or Arabic filler. Choose paragraphs (max 100), sentences (max 500) or words (max 10000); optionally start with the classic opener and wrap paragraphs in <p> tags. Give a seed for repeatable output (the same seed gives the same text). Writes a .txt/.html file instead when "output" is given. Web version: https://s3eidat.github.io/lorem-gen/

Input parameters:

- `count` (integer): How many paragraphs / sentences / words (clamped to the unit limit).
- `html` (boolean): Wrap each paragraph in <p>…</p>.
- `opener` (boolean): Start with the classic opening line ("Lorem ipsum dolor sit amet…", "The quick brown fox…", or the Arabic one). Default true.
- `output` (string): Optional: write the text to this file path (or folder ending in "/") instead of returning it.
- `seed` (integer): Seed for repeatable output (default: random).
- `style` (string): Word list: lorem (Latin), english, or arabic.
- `unit` (string): What "count" counts.

### `text_morse` (~204 tokens)

Morse code translator

Translate text to International Morse code and back. Encoding: letters separated by spaces, words by " / "; accents are folded (é → E) and characters without a code are skipped and counted. Decoding accepts . and - plus look-alikes (• · – — _), with words split by /, | or 2+ spaces; unknown codes become #. Encoding also returns the playing time at a given speed (PARIS timing: dot = 1200/WPM ms). No audio. Web version: https://s3eidat.github.io/morse-code/

Input parameters:

- `mode` (string): "encode" text → Morse, "decode" Morse → text, or "auto" (default): decode if the input only has Morse symbols, spaces, / and |.
- `text` (string, required): Text to encode, or Morse code to decode.
- `wpm` (number): Speed in words per minute for the duration estimate (default 18).

### `text_number_to_words` (~337 tokens)

Number to words (English & Arabic)

Spell a number in words in English and Arabic: English cardinal (with decimals, optional British "and"), ordinal (twenty-first), cheque wording for an amount in a currency (cents in words or as 25/100, optional "only"), Arabic cardinal, and Arabic tafqeet for amounts with correct gender/number agreement of the currency noun (optional "faqat … la ghayr" wrapper and the modern 100 spelling). Currencies: JOD, USD, SAR, AED, KWD, EGP, GBP (or none). Accepts Arabic-Indic digits and thousands separators. Up to 999 trillion (15 digits). Web version: https://s3eidat.github.io/number-words/

Input parameters:

- `british` (boolean): British English "and": one hundred and five.
- `currency` (string): Currency for cheque / tafqeet wording: none (default), JOD, USD, SAR, AED, KWD, EGP, GBP.
- `modernHundred` (boolean): Arabic: use the modern spelling of "hundred" (without the extra alif).
- `number` (string|number, required): The number or amount, e.g. "1500.250", "1,234,567.89", -12.05 (Arabic-Indic digits work too).
- `only` (boolean): Add "only" (English) and the Arabic "faqat … la ghayr" wrapper to amounts.
- `subStyle` (string): Cheque sub-units in words (twenty-five cents) or as a fraction (25/100).

### `text_readability` (~165 tokens)

Readability score

Score how easy an English text is to read: Flesch Reading Ease, Flesch-Kincaid Grade, Gunning Fog, SMOG, Coleman-Liau and Automated Readability Index (same formulas, sentence splitter and syllable estimate as the website), plus a verdict, average grade level, and Hemingway-style hints: long sentences (over 20 / 30 words), passive voice and adverbs. The formulas are built for English; for Arabic text the result says so (arabicWarning). Give "text" or a text file "path". Web version: https://s3eidat.github.io/readability/

Input parameters:

- `path` (string): Or: a path to a UTF-8 text file.
- `text` (string): The text to score.

### `text_slugify` (~269 tokens)

Slugify

Turn titles into clean URL slugs, one slug per non-empty line (bulk). Folds accents (é → e, ß → ss), transliterates Arabic to Latin (the article al- becomes its own word) or keeps Arabic letters, converts Arabic-Indic digits, drops tashkeel, turns & into "and", can remove stop words (English and Arabic) and cap the length at a word boundary. Web version: https://s3eidat.github.io/slugify/

Input parameters:

- `arabic` (string): "latin" transliterates Arabic letters (default); "keep" keeps them.
- `foldAccents` (boolean): Transliterate accents: é → e, ß → ss, æ → ae (default true).
- `lowercase` (boolean): Lowercase the slug (default true).
- `maxLength` (integer): Maximum slug length in characters, cut at a word boundary (0 = no limit).
- `removeStopWords` (boolean): Remove stop words in English and Arabic such as the, of, and (kept if nothing else is left).
- `separator` (string): Word separator: dash (default), underscore or dot.
- `text` (string, required): Title(s) to slugify. Each non-empty line becomes one slug.

### `text_social_count` (~305 tokens)

Social media character counter

Check a post against platform limits the way the platforms count: X/Twitter weighted length (links = 23, emoji = 2, CJK = 2; limit 280), Threads 500, Bluesky 300, Instagram 2,200 (+ 30 hashtags), LinkedIn 3,000, Facebook 63,206, TikTok 4,000, YouTube title 100 / description 5,000, Pinterest 500, Google title ~60, meta description ~160. Characters are counted as user-perceived graphemes (one emoji = 1). Also: words, hashtags, mentions, links, emoji, and SMS encoding (GSM-7 vs Unicode) with the number of SMS parts and the characters that force Unicode. Give "text" or a text file "path". Web version: https://s3eidat.github.io/social-counter/

Input parameters:

- `gsmLookalikes` (boolean): Also return the text with curly quotes, dashes, ellipses, odd spaces etc. replaced by GSM-7 look-alikes (cheaper SMS).
- `path` (string): Or: a path to a UTF-8 text file.
- `platforms` (array): Only these meters: x, threads, bsky, ig, li, fb, tt, yt, ytd, pin, gt (Google title), gd (meta description). Default: all.
- `text` (string): The post text.

### `text_word_count` (~157 tokens)

Word count

Count words, characters (with and without spaces), sentences, paragraphs, lines and unique words; estimate reading (238 wpm) and speaking (150 wpm) time; list the most used keywords with density. Works for English and Arabic (tashkeel ignored). Give "text" or a text file "path". Web version: https://s3eidat.github.io/word-count/

Input parameters:

- `includeStopWords` (boolean): Count common words like "the"/"في" as keywords.
- `keywords` (integer): How many top keywords to return (0 = none).
- `path` (string): Or: a path to a UTF-8 text file.
- `text` (string): The text to analyse.

### `time_convert` (~315 tokens)

Timestamp convert

Convert a Unix timestamp (seconds, ms, µs or ns — auto-detected from the number of digits, or set "unit") or a date string to ISO 8601 (UTC and in a timezone), RFC 7231 / UTC string, local time in any IANA timezone with its offset, relative time ("3 hours ago"), day of year, ISO week, and Unix seconds/ms. A wall-clock time without an offset (e.g. "2026-10-26T14:30") is read in "timezone". Also shows the same instant in extra "zones" (world clock). No value = now. Date arithmetic is not done here. Web version: https://s3eidat.github.io/timestamp-convert/

Input parameters:

- `now` (number): Reference "now" in Unix ms for the relative time. Default: the current time.
- `timezone` (string): IANA timezone for the local view and for wall-clock input. Default: the server's (UTC).
- `unit` (string): Unit of a numeric timestamp. Default: auto-detect.
- `value` (string|number): A Unix timestamp (e.g. 1700000000 or "1700000000123"), an ISO/RFC date string, or a wall-clock "YYYY-MM-DDTHH:MM[:SS]". Default: now.
- `zones` (array): Extra IANA timezones to show the same instant in, e.g. ["UTC","Asia/Tokyo"].

### `time_world_clock` (~315 tokens)

World clock & meeting planner

Current (or any given) time in a list of time zones or cities: local time, date, weekday, UTC offset, difference from a home zone, day/night and working-hours flags. Plus the website's meeting planner: the 24 hours of a day in the home zone, each zone's local hour and band (work 9–17, awake 7–22, night), and the hours when everyone is in working hours. Zones: IANA ids ("Asia/Tokyo") or city names ("Mecca", "New York", "Tokyo"). Uses Node's ICU time-zone data; no network. Web version: https://s3eidat.github.io/world-clock/

Input parameters:

- `at` (string): The instant to show (ISO 8601, e.g. "2026-01-15T12:00:00Z"). Default: now.
- `homeZone` (string): Zone the differences and the planner day are measured from. Default: the first of zones.
- `hour12` (boolean): 12-hour clock (AM/PM) instead of 24-hour.
- `planner` (boolean): Include the 24-hour meeting planner.
- `plannerDate` (string): Planner day (YYYY-MM-DD in the home zone). Default: the date of "at" there.
- `zones` (array, required): Time zones or cities, e.g. ["Asia/Amman", "London", "New York"]. The first is the home zone unless homeZone is set.

### `url_decode` (~130 tokens)

URL decode

Decode percent-encoded text (decodeURIComponent, or decodeURI with mode "full"). Optionally turn "+" into spaces (form encoding). Errors on malformed %-sequences. Web version: https://s3eidat.github.io/url-toolkit/

Input parameters:

- `mode` (string): "component" = encodeURIComponent (for one query value or path segment; escapes / ? & = #). "full" = encodeURI (a whole URL; keeps those).
- `plusAsSpace` (boolean): Treat "+" as a space (application/x-www-form-urlencoded).
- `text` (string, required): Percent-encoded text.

### `url_encode` (~104 tokens)

URL encode

Percent-encode text for URLs, exactly like JavaScript encodeURIComponent ("component", default) or encodeURI ("full"). UTF-8 based. Web version: https://s3eidat.github.io/url-toolkit/

Input parameters:

- `mode` (string): "component" = encodeURIComponent (for one query value or path segment; escapes / ? & = #). "full" = encodeURI (a whole URL; keeps those).
- `text` (string, required): Text to encode.

### `url_parse` (~144 tokens)

URL parse

Split a URL into protocol, user, host, port, path, query, fragment and origin (with decoded forms), list its query parameters in order (duplicates and bare flags kept, + as space) and flag tracking parameters (utm_*, fbclid, gclid, msclkid, mc_cid, _ga, _hsenc…). Optionally returns the URL with tracking removed. A missing scheme means https://. Passwords are never echoed. Web version: https://s3eidat.github.io/url-toolkit/

Input parameters:

- `stripTracking` (boolean): Also return "cleanUrl" with tracking parameters removed.
- `url` (string, required): The URL to parse.

### `useragent_parse` (~244 tokens)

User agent parse

Parse browser user-agent strings into browser + version, engine (Blink, WebKit, Gecko, Trident, EdgeHTML, Presto), OS + version, device type (desktop, mobile, tablet, TV, console, bot, HTTP client), vendor and model. Recognises ~50 crawlers and AI bots (Googlebot, Bingbot, GPTBot, ClaudeBot, PerplexityBot…) and HTTP clients (curl, python-requests, Go, okhttp, Postman…). Give one "userAgent", a list, or a text/log file (one per line, or the last quoted field of each access-log line); up to 5000 per call, with a count by type. Web version: https://s3eidat.github.io/ua-parser/

Input parameters:

- `accessLog` (boolean): Read "file" as an access log: take the last quoted field of each line.
- `file` (string): Or: a text file (path or base64) with one user agent per line, or an access log.
- `userAgent` (string): One user-agent string.
- `userAgents` (array): Several user-agent strings.

### `xml_format` (~289 tokens)

XML format / minify / validate / to JSON

Validate XML (well-formedness and namespaces, with line and column for errors), pretty-print it (2, 4 spaces or tab; mixed content, CDATA and xml:space="preserve" kept exactly as written), minify it, or convert it to JSON (attributes as "@name", repeated elements as arrays, text as "#text"). Optionally removes comments. Never loads external DTDs or entities. Give "text" or a file "path". Web version: https://s3eidat.github.io/xml-format/

Input parameters:

- `indent`: Indentation: 2, 4, "tab" (or any number of spaces 0-8).
- `mode` (string): "format" pretty-prints, "minify" strips layout whitespace, "json" converts to JSON, "validate" only checks (never throws on bad XML).
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a XML file (UTF-8; use this for big inputs).
- `removeComments` (boolean): Drop <!-- comments --> (format and minify).
- `text` (string): The XML as inline text.

### `xml_query` (~258 tokens)

XML XPath query

Run an XPath 1.0 expression on XML: node-sets (elements, attributes, text…), numbers (count(), sum()), strings and booleans. Full XPath 1.0: all axes, predicates, operators and the core function library. Namespace prefixes declared anywhere in the document can be used as-is; a default namespace on the root gets the prefix "d" (e.g. //d:book), as on the website. Each matched node comes back as XML text plus its type, name and XPath location. Web version: https://s3eidat.github.io/xml-format/

Input parameters:

- `limit` (integer): Return at most this many nodes (default 1000).
- `namespaces` (object): Extra or overriding prefix → namespace URI bindings, e.g. {"atom":"http://www.w3.org/2005/Atom"}.
- `path` (string): Or: a path to a XML file (UTF-8; use this for big inputs).
- `text` (string): The XML as inline text.
- `xpath` (string, required): XPath 1.0 expression, e.g. "//book[price > 30]/title", "count(//item)", "//d:entry/@id".

### `yaml_to_json` (~234 tokens)

YAML to JSON

Convert YAML to JSON (YAML 1.2 core schema plus anchors/aliases, << merge keys, timestamps, multi-document files). Safe: no code tags (!!js/function, !!python… are rejected), alias bombs and recursive aliases are stopped. Several documents become a JSON array. Errors give line and column. Give "text" or a file "path". Web version: https://s3eidat.github.io/yaml-json/

Input parameters:

- `alwaysArray` (boolean): Always output an array of documents, even for one document.
- `indent`: Indentation: 2 or 4 spaces.
- `output` (string): Optional: also write the result to this file path (or folder ending in "/"). The result text is then left out of the reply. Results over 1,000,000 characters are always written to a file.
- `path` (string): Or: a path to a YAML file (UTF-8; use this for big inputs).
- `sortKeys` (boolean): Sort object keys alphabetically at every level.
- `text` (string): The YAML as inline text.

## Diagnostics

Captured diagnostic sections: Provenance, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp#diagnostics

## Score history

- 2026-11-04: 62
- 2026-11-03: 62
- 2026-11-02: 62
- 2026-11-01: 62
- 2026-10-31: 62
- 2026-10-30: 47

## Common questions

### What is the S3eidat Tools MCP server?

S3eidat Tools is an MCP server listed in the public MCP registry as io.github.s3eidat/s3eidat-tools-mcp. Free, private PDF, image, text, developer, calculator and QR tools. Runs locally; no uploads. This page covers its npm package (s3eidat-tools-mcp).

### Is the S3eidat Tools MCP server safe to use?

S3eidat Tools scores 62 out of 100 on VerifyMCP. We recorded 4 known advisories against it as of 4 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the S3eidat Tools MCP server expose?

S3eidat Tools exposes 162 tools: ai_chart, ai_chunk_text, ai_create_pptx, ai_create_xlsx, ai_csv_profile, and 157 more. Their descriptions and schemas cost roughly 49,341 tokens of context every time the server is loaded.

### Is the S3eidat Tools MCP server still maintained?

S3eidat Tools is still listed as active in the MCP registry. We last reached this channel on 4 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the S3eidat Tools MCP server under?

S3eidat Tools declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/s3eidat-tools-mcp
- Socket report: https://socket.dev/npm/package/s3eidat-tools-mcp
- Repository: https://github.com/s3eidat/s3eidat-tools-mcp
- Website: https://s3eidat.github.io/s3eidat-tools-mcp/
- Changelog RSS feed: https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp.json
- HTML version of this page: https://verifymcp.io/servers/s3eidat-s3eidat-tools-mcp/s3eidat-tools-mcp