The full catalog

Compares two .env files (parsed with the exact same logic .env File Parser/Validator uses) and reports added, removed, and changed keys. Values are shown in the diff only when neither file's key name looks like a secret — a heuristic on the key name itself (matching *_SECRET/*_KEY/*_TOKEN/*_PASSWORD/*_CREDENTIAL, case-insensitive) redacts those values even though the file is the person's own, since a diff report is easy to paste somewhere it shouldn't go.

Parses a .env file (quoted values, comments, and the "export KEY=value" prefix variant) into JSON. Duplicate keys are flagged as a warning in the result rather than silently letting the last occurrence win unnoticed.

Checks whether a 12-digit Aadhaar number passes its real checksum digit via the public Verhoeff algorithm (the same checksum scheme UIDAI numbers use). Format/checksum-only — does not verify the number is real, active, or belongs to anyone, and nothing is transmitted anywhere. This validates one number a person explicitly typed in; it is not a document-scanning or auto-redaction tool.

Adds a new column with a real, cryptographically random UUID (crypto.randomUUID(), RFC 4122 version 4 — never Math.random()) generated fresh for every row.

Encrypts/decrypts text or a file with AES-256-GCM (authenticated encryption — tampering makes decryption fail loudly, not silently) using a key derived from your password via PBKDF2-HMAC-SHA256 at 600,000 iterations (OWASP's current recommendation for this KDF). Not Argon2id: Web Crypto API has no native Argon2id, and a third-party WASM implementation would be a worse tradeoff than PBKDF2's native, browser-audited one for the single most security-critical part of this app. There is no password recovery — a forgotten password means permanently losing access to the encrypted data.

Computes exact age in years/months/days via real calendar-day arithmetic (in UTC, to sidestep timezone/DST edge cases) — leap-day (Feb 29) birthdates work correctly since the "days in the previous month" step is computed from the real calendar, not assumed to always be 30.

Removes an image's background using MODNet (Xenova/modnet, Apache-2.0 licensed — chosen over briaai/RMBG-1.4/2.0, whose licenses restrict free use to non-commercial purposes) via transformers.js, with automatic WebGPU acceleration and a WASM fallback. The model itself (~26 MB) is downloaded from Hugging Face on first use and cached in this browser afterward — the one external-network exception in this app, documented in ARCHITECTURE.md. Your image is never uploaded anywhere, at any point; only the model file comes from outside this browser tab.

Checks whether two text files are anagrams of each other via character-frequency comparison — the clearer, more standard implementation to verify against than sorted-string equality, even though both produce the same result. Whitespace is ignored; case is folded.

Renders a short, looping animated WebP preview clip from a video segment, via ffmpeg's libwebp encoder with infinite looping (-loop 0).

Appends the rows of several spreadsheets (same expected schema) one after another, in upload order — the same real SCHEMA_MISMATCH detection (a header mismatch names exactly which file differs, rather than silently mixing up columns) Merge Multiple CSVs already established, framed here specifically as ordered row-appending rather than a general merge.

Splits a JSON array into consecutive chunks of a fixed size (multi-output, one file per chunk) — the same slicing mechanic as JSON Array Paginator, framed around a fixed chunk size rather than a page count.

Reports the minimum and maximum numeric value of a given key across a JSON array — a lighter-weight, single-purpose alternative to CSV Statistics Summary's full stats (mean, median, quartiles, etc.) when only the range is needed.

Returns just the first N and last N elements of a large JSON array — a quick look without processing the whole thing. Distinct from Random Row Sampler's random selection and Every Nth Element's positional stride: this always shows the very start and very end, the two ends most useful for a quick shape check.

Converts a JSON array of objects to CSV using only an explicitly chosen subset of keys as columns, in the given order — distinct from a plain JSON↔CSV converter, which includes every key it finds.

Renders text as ASCII art banner via the figlet package's real, bundled FIGfont glyph data (the same font files the classic `figlet` CLI ships) — not hand-invented glyph shapes.

Formats a CSV/spreadsheet file as a monospace, box-drawn plain-text table (+---+---+ borders) — for terminal output, code comments, or plain-text emails, distinct from Markdown Table Formatter's Markdown-specific pipe syntax.

Crops a rectangular region (in source-pixel coordinates) out of an image and draws it to a new canvas at that exact size — the crop rect is validated against the source image's actual bounds first.

Read-only: reports an image's exact pixel dimensions and reduced aspect ratio (via GCD), plus the closest common standard name (16:9, 4:3, 1:1, 3:2, 21:9, etc.) it matches within a small tolerance.

Resizes a video to a target aspect ratio, either by cropping (losing edge content) or padding with letterbox/pillarbox bars (keeping everything, adding bars) — the choice is yours, not silently picked for you.

Extracts every file embedded in a PDF's /Names /EmbeddedFiles name tree (pdf-lib's own API only supports adding attachments, not reading existing ones, so this reads the low-level object structure directly) — each attachment downloads as its own file. Covers the common flat name-tree case; a PDF using a deeply nested (/Kids-balanced) name tree may not surface every attachment.

Re-encodes audio at a target bitrate via ffmpeg's -b:a flag.

Crossfades the end of one track into the start of another via ffmpeg's real acrossfade filter (confirmed present in this app's bundled ffmpeg core) — one continuous output where the two tracks overlap and blend for crossfadeDurationSec.

Fades an audio file in and/or out via ffmpeg's afade filter — the fade-out start time is computed from the file's real, probed duration, not assumed.

Transcodes audio to MP3, WAV, AAC, OGG, or FLAC, using the right encoder for each target.

Joins several audio files into one via stream copy (the ffmpeg concat demuxer, the same technique as Video Merger) — works best when every input shares the same codec.

Plays an audio file backwards via ffmpeg's areverse filter.

Shifts a video's audio track earlier or later relative to its video track, via ffmpeg's real -itsoffset option applied to a second read of the same file's audio stream (the standard, documented technique for this — a per-stream timestamp filter alone can't shift one stream's timing independently of the other the way -itsoffset does at the input level). Positive offsetMs delays the audio; negative advances it.

Reports how many audio tracks a video file contains (and each one's codec/language, when present) — read-only, no output video is produced. Reuses the same technique Duration probing already established: ffmpeg.wasm exposes no ffprobe-style API, so this runs ffmpeg -i <file> with no output (which always logs each stream's header before erroring over the missing output) and parses the real 'Stream #0:N: Audio: ...' log lines rather than guessing. Useful before Audio Track Selector.

Keeps only one audio track from a video that has several (e.g. multiple language dubs), via ffmpeg's -map option (-map 0:v -map 0:a:N) — the video stream and every other audio track pass through untouched except the unselected audio tracks, which are dropped.

Cuts a clip out of an audio file by stream-copying (no re-encode) — fast, at the cost of landing on the nearest keyframe rather than an exact sample.

Auto-detects each page's real content bounding box by rendering it (reusing PDF to JPG/PNG's real render() pipeline) and scanning the rendered pixels for the actual non-blank region, then sets each page's crop box to that region plus a margin — distinct from PDF Crop Pages, whose margin is a person-specified, uniform region rather than a per-page detected one. A page with no detectable content (fully blank) is left uncropped, not collapsed to nothing.

Trims only the silence at the very start and end of an audio file — distinct from Silence Remover (mid-content) and Silence Detector (info-only). Implemented via the standard reverse/trim-start/reverse-again recipe, since silenceremove only reliably trims from a stream's start.

Scans a PDF for PAN/Aadhaar/GSTIN numbers (India), US SSNs, and credit card numbers, and redacts every confirmed match for real — not by drawing a box over the text (which leaves it selectable/extractable underneath), but by rasterizing each matched page to an image and redacting the pixels, so the underlying text genuinely no longer exists on that page. Pages with no match keep their original, fully-searchable vector content; only matched pages become image-only. PAN/Aadhaar/GSTIN/credit-card detection reuse this app's own real checksum-validated detectors (Verhoeff for Aadhaar, Luhn for cards) — SSN detection is format-only (no checksum exists for SSNs), a meaningfully weaker, higher-false-positive signal than the others. This tool reduces risk; it cannot guarantee every sensitive number is found, and does not replace manually reviewing a highly sensitive document before sharing it.

Reports the simple arithmetic mean RGB across every non-transparent pixel — distinct from Dominant Color Extractor's mode-based approach (the most common color bucket). Both answer a useful but different question: the mean is what a single-color swatch representing the whole image would look like on average; the mode is the single color that actually appears most.

Converts to or from AVIF. Decoding AVIF has broad browser support; encoding to AVIF is newer and less universal — this tool verifies the browser actually produced an AVIF blob (some silently fall back to PNG instead of erroring) and reports a clear error rather than shipping a mislabeled file.

Reads barcodes and QR codes from an uploaded image — QR Code, Data Matrix, PDF417, Code 128, and many other symbologies (EAN/UPC, Aztec, Codabar, ITF, DataBar, MaxiCode, and more), via zxing-wasm (an actively-maintained WebAssembly build of the zxing-cpp reference decoder), entirely in this browser tab. An image with no detectable code is reported as a normal result, not an error.

Generates a real, scannable EAN-13, CODE128, or UPC-A barcode (correct check-digit calculation and encoding per symbology) via the jsbarcode package, rendered directly to canvas — jsbarcode's own format string maps 1:1 to this tool's symbology choice.

Encodes or decodes a file as Base32 (RFC 4648) or hex — binary-safe: it operates on raw bytes, not on text assumed to be UTF-8.

Converts between a base-10 integer and its base-36 (0-9, a-z) representation — a distinct, fixed base from Number Base Converter's arbitrary 2-36 input, specifically for the common "compact alphanumeric ID" use case (e.g. shortened URL IDs, order/ticket codes). Uses BigInt throughout, so it works correctly for numbers far larger than what a 32-bit or even double-precision integer can represent exactly.

Encodes any file to Base64 text, or decodes Base64 text back to its original bytes — binary-safe in both directions via chunked byte processing, not a direct btoa() on file text (which throws or corrupts on anything outside Latin1).

Adjusts brightness, contrast, saturation, and gamma via ffmpeg's eq filter — a long-established, standard filter (unlike drawtext/rubberband, its availability was never in question).

Fades multiple audio files in and/or out, reusing Audio Fade In/Out's exact afade approach — each file's fade-out start time is computed from that file's own real, probed duration, not assumed to match the others.

Auto-trims leading/trailing silence from multiple audio files in one run, reusing Auto-Trim Leading/Trailing Silence's exact reverse/trim-start/reverse-again technique — one output per input.

Converts multiple images to or from AVIF in one run, reusing AVIF Converter's exact encode-support feature-detection — canvas.toBlob() can silently substitute PNG instead of erroring when AVIF encoding isn't actually supported, so each file's result blob type is verified for real, not trusted.

Applies the same brightness/contrast adjustment to multiple images in one run, via the canvas context's native filter string (brightness()/contrast()) — the exact same technique Brightness/Contrast Adjuster uses on a single file.

Changes multiple videos' container format, reusing Container Converter's exact stream-copy-first, re-encode-only-if-needed logic — one output file per input, each independently trying a fast copy before falling back to a real transcode.

Center-crops multiple images to the same named aspect ratio, reusing Crop to Aspect Preset's exact largest-centered-region technique — one output file per input.

Strips the video stream and keeps only the audio track from multiple videos in one run, reusing Extract Audio Track's exact -vn/-acodec copy approach — one .m4a output file per input.

Converts several images to PNG, JPEG, or WebP in one pass — the exact same canvas.toBlob() technique Generic Format Converter uses, applied across every selected file.

Converts multiple images to grayscale in one run, reusing Grayscale Converter's exact canvas-filter technique (grayscale(100%)) — one output file per input.

Renames keys throughout an entire nested JSON structure — every object at every depth, not just the top level — given an old-name → new-name map applied wherever a matching key is found.

Stamps a logo image onto multiple images at reduced opacity. The FIRST file you select is used as the logo; every other file is watermarked with it — reorder your file list before running if the logo isn't first. This is a real, image-based watermark, distinct from Watermark Creator's text-only scope.

Normalizes multiple audio files' loudness in one run with ffmpeg's real EBU R128 loudnorm filter — the exact same technique Volume Booster/Normalizer's "normalize" mode uses, applied across N files, one output per input.

Applies CSS Unit Converter's exact same single-value px↔rem conversion logic to every matching value found throughout a whole CSS file, not just one number at a time — every standalone px or rem length token is converted and rewritten in place, everything else in the file untouched.

Generates one QR code per line of a text/CSV file, reusing Dynamic QR Code Generator's exact real encoder — multi-output, one PNG per non-empty line.

Renames each input file to include its own real pixel dimensions (e.g. photo.jpg → photo-1920x1080.jpg) — a metadata/organization tool, not a pixel transform: every file's original bytes are downloaded unchanged, only the file name changes.

Resizes multiple images to the same target dimensions in one run, reusing Image Resizer's exact fit-within-box logic — one output file per input.

Rotates multiple images by the same 90/180/270°, reusing Flip & Rotate's exact rotation technique (just the rotate half, no flip) — one output file per input.

Slugifies every value in a spreadsheet column into a new column — reuses slug-generator's diacritic-stripping logic (Cluster C) and sheetFormat.ts's row iteration (Cluster B) rather than re-deriving either.

Applies Social Media Size Presets' exact same preset dimensions and cover-fit crop logic across multiple images in one run — one output file per input. Always uses cover-fit (crop) rather than letterboxed padding, the more commonly used default for feed posts; use the single-file Social Media Size Presets tool if you need pad mode.

Draws the same text at the same (x, y) position, size, and color onto multiple images, reusing Text Overlay's exact drawing technique — one output file per input.

Crops multiple videos to the same fixed rectangle, reusing Video Crop's exact crop-filter technique — one output file per input.

Rotates multiple videos by the same 90/180/270°, reusing Video Rotate's exact transpose-filter technique — one output file per input, each processed in its own ffmpeg run.

Converts multiple videos to animated GIFs in one run, reusing Video to GIF's exact two-pass palette technique (palettegen/paletteuse) for every file — one GIF per input, each rendered from its own clip-specific optimized palette.

Burns the same text watermark into multiple videos, reusing Video Text Watermark's exact drawtext approach (confirmed available in this app's bundled ffmpeg core, Batch 6) — one output file per input.

Applies Vintage Filter's exact same sepia + film-grain + vignette composition to multiple images in one run, at the same intensity — one output file per input.

Stamps a sequential, zero-padded Bates number (prefix + running count) in the bottom-right corner of every page — the legal-document convention for uniquely identifying each page across a production, distinct from ordinary reader-facing page numbering.

Re-encodes a video at a target video bitrate via ffmpeg's -b:v flag.

Converts every pixel to pure black or pure white based on a luminance threshold — a binary two-color result, distinct from Grayscale Converter (Batch 1-3 era), which preserves the full continuous gray range.

Detects and removes letterbox/pillarbox black bars in two passes: first ffmpeg's cropdetect filter (run against a null output) reports the real detected crop region from its own log output, then a second real pass crops to exactly that region.

Reports every black stretch in a video via ffmpeg's blackdetect filter, parsed straight out of its log output — an info tool only, it does not modify the video.

Reports which pages look blank — no real text and no painted image, via the exact same detection Remove Blank Pages uses — without modifying the document at all, for reviewing before deciding whether to actually remove anything.

Inserts one or more blank pages after a given page number (0 to insert before the first page), sized to match the document's existing pages — via pdf-lib's insertPage.

Blurs an image via the canvas context's native filter string (blur(Xpx)).

Computes Body Mass Index (weight in kg / (height in m)²) and the standard WHO category band it falls in — purely a calculation and category lookup, not personalized health advice. No recommendation language beyond the category name itself.

Reorders and lays out pages 2-up for saddle-stitch print-and-fold booklet printing, using the standard imposition formula (verified against real printing references, not guessed): for an N-page booklet's sheet i, front = [N-2i, 1+2i], back = [2+2i, N-1-2i]. Page count is padded to a multiple of 4 with blank pages if needed, since every saddle-stitched booklet requires that.

For a boolean-valued key, reports how many elements have it true, false, or present-but-not-actually-a-boolean (e.g. the string "true" or a number) — a boolean-specific sibling to Key Existence Check, which reports presence/absence rather than the value's truth.

Creates a boomerang-style clip: the video plays forward, then immediately plays itself backward (via the same reverse/areverse filters Video Reverse uses), joined with the concat demuxer (the same technique Video Merger/Video Looper use) into one seamless forward-then-back loop.

Adds a solid border and a drop shadow around an image via the canvas context's native shadowBlur/shadowColor/shadowOffsetX/shadowOffsetY — the canvas is padded so the shadow has room to render instead of being clipped at the edge.

Rounds an image's corners using one of four common named presets (subtle, medium, pill, circle) — distinct from Round Corners' fully custom pixel-radius input, for the common case where a specific named look matters more than an exact number.

Computes each channel's real pixel-value distribution (256 buckets, red/green/blue plus overall luminance) from the image's actual pixel data via getImageData, rendered as a real bar chart on canvas — not an illustrative or approximated chart.

Adjusts brightness and contrast via the canvas context's native filter string (brightness()/contrast()) before drawImage — the platform's own implementation, not hand-rolled per-pixel math.

Records your screen, a window, or a tab directly to a downloadable video file via getDisplayMedia + MediaRecorder — nothing is uploaded.

Converts between "- item" / "* item" bullet-list syntax and "1. item" numbered-list syntax. Only lines that actually match one of these two list-marker shapes are converted; every other line (including blank lines and lines with a different, unrecognized marker) passes through unchanged.

A classic Caesar shift cipher — explicitly a puzzle/educational tool, not security. It provides no real confidentiality (a 26-letter shift cipher is trivially broken by hand); it is not related to, and should not be confused with, this app's actual cryptographic tools (Hash Generator, HMAC Generator, Password Generator).

Checks whether a card number passes the Luhn checksum algorithm — a real mod-10 digit-doubling checksum, the same one card networks use to catch typos. Format validation only: passing Luhn means the number is checksum-valid, not that it is a real, active, or chargeable card. This tool is not a payment processor and never implies more than a format check.

Composes two already-verified techniques rather than inventing a third: Edge/Outline Detector's real Sobel edge mask is drawn as black outlines over Posterize Effect's real per-channel level quantization — the combination that produces the flat-color, black-outlined cartoon look.

Converts text between camelCase, snake_case, kebab-case, and Title Case — word-boundary-aware on the source too, so it correctly splits existing camelCase/snake_case/kebab-case input into words instead of only handling space-separated text.

Reads each cell's fill/background color via SheetJS's style API (cellStyles: true on read). This tool's own type definitions type a cell's style as `any` — SheetJS doesn't publish a strict schema for it, and real-world style-reading coverage genuinely varies by how the source workbook was authored (some files simply don't carry recoverable style data). Cells with no detected fill are reported as such, not silently skipped.

Converts audio to mono (1) or stereo (2) via ffmpeg's -ac flag.

Counts how often each individual character appears in a text file — per-character, distinct from Word Frequency Counter, which counts whole words instead.

Crops an image to a full circle (inscribed within the shorter dimension) rather than a rounded rectangle — Round Corners keeps the image's rectangular shape with softened corners, this discards everything outside the circle entirely, the common "avatar" treatment. Exports as PNG so the area outside the circle is genuinely transparent.

Binarizes an image to pure black and white via real Otsu's method — the classic 1979 algorithm that picks the threshold maximizing between-class variance across a 256-bin grayscale histogram, computed from cumulative counts and intensity sums rather than a fixed or guessed cutoff. Genuinely adapts to each image's own brightness distribution — a scanned document with uneven lighting gets a different, better threshold than a high-contrast photo, unlike Threshold B&W's fixed manual cutoff.

Removes impulsive noise (clicks and pops, e.g. from a vinyl-sourced recording) via ffmpeg's adeclick filter — confirmed present in this app's bundled ffmpeg core via a real captured ffmpeg.exec(['-filters']) run, not assumed.

Syntax-highlights a code snippet via highlight.js and renders it two ways: to a PNG (canvas) and to a PDF (pdf-lib, reusing this app's shared PDF output helper) — both share the same token-color walk over highlight.js's real HTML output, not a hand-rolled approximation of its grammar.

Tiles multiple images into one collage — "grid" arranges them in a configurable-column grid, each scaled to fit its cell; "strip" lays them out in one row, each scaled to a common height.

Simulates how an image looks under protanopia, deuteranopia, or tritanopia by applying the real Machado, Oliveira & Fernandes (2009) full-severity confusion-line projection matrices to each pixel — not a generic desaturation approximation.

Extracts a representative color palette from an image via real median-cut quantization over its pixel data — recursively splitting the color-space box with the greatest range along its longest axis and averaging each final bucket — not a shortcut like sampling N random pixels, which produces a misleading palette on any image with uneven color distribution.

Parses a color given as hex, rgb()/rgba(), or hsl()/hsla(), and outputs its equivalent in all three formats.

Actually applies a reduced color palette to the image — derives it via the same real median-cut algorithm Color Palette Extractor uses, then remaps every pixel to its nearest palette entry (real squared-RGB-distance nearest search). Distinct from palette extraction, which only reports the colors without changing the image.

Replaces every pixel within tolerancePercent of a target color with a replacement color — a real per-pixel Euclidean color-distance check, not an exact-match-only comparison (which would miss the JPEG/scaling noise around almost every real-world "solid" color region).

Rasterizes every page (the same pdf.js-based approach PDF to JPG/PNG uses), applies a grayscale canvas filter, then reassembles the pages into a new PDF (the same approach Image to PDF uses) — a raster round-trip, not a native content-stream color transform. This is not lossless for text-heavy documents: text becomes a grayscale image rather than staying real, selectable text.

Hashes one column's values (concatenated in row order, newline-separated) with the exact same real SHA-256 implementation (Web Crypto's crypto.subtle.digest) Hash Generator uses — useful for verifying two exports of "the same" column actually match, without diffing the whole file.

Merges several spreadsheet columns into one, joined by a separator, preserving the input's own format (CSV, TSV, or XLSX) — the inverse of Column Splitter.

Renames spreadsheet columns via a simple old-name → new-name map, applied only to the header row.

Reorders a spreadsheet's columns to the given order, preserving the input's own format (CSV, TSV, or XLSX). Columns not named in newOrder are kept, appended after the named ones, rather than silently dropped.

Splits one spreadsheet column into several by a delimiter, preserving the input's own format (CSV, TSV, or XLSX).

Reports min, max, mean, median, and count for every numeric column in a spreadsheet — median is the real sorted-array midpoint (averaging the two center values on an even count), not the mean mislabeled as median.

Reports the most likely type per column (number/date/boolean/string), with a confidence percentage — a genuinely mixed column reports its majority type at a correspondingly lower confidence, rather than forcing one guess that hides how mixed it actually is.

Counts how many times each distinct value appears in one column, sorted from most to least frequent.

Reports the minimum, maximum, and average character length of values in one column — useful for spotting truncation or outlier entries before a fixed-width export.

Finds and replaces a literal substring within one specific column's values only — scoped to a single column, distinct from Find & Replace (Regex)'s whole-document, regex-capable scope. A plain literal substring match, not a pattern.

Merges multiple PDFs into one and prepends a simple table-of-contents page listing each source file's name and the page number it starts on.

Changes a video's container format. Tries a fast stream copy (-c copy) first — no re-encode, no quality loss — and only falls back to re-encoding when the source codecs genuinely aren't compatible with the target container (e.g. H.264/AAC into WebM, which needs VP9/Opus). The output report says explicitly which path was used, rather than silently re-encoding or silently failing.

Reports which pages and which individual indirect objects account for the most bytes in the file — via pdf-lib's own real, low-level PDFObject.sizeInBytes() (the same serialization-size calculation pdf-lib uses internally when saving), not a file-size guess. Useful before deciding whether Compress PDF is even worth running, and for spotting which specific page or embedded object is disproportionately large.

Parses a Cookie: header (a plain list of name=value pairs) or a Set-Cookie: header (one name=value plus real attributes — Path, Domain, Expires, Max-Age, Secure, HttpOnly, SameSite) into structured JSON. Which shape it is gets auto-detected from whether any recognized Set-Cookie attribute keyword is present.

Parses a standard 5-field cron expression and computes real upcoming run times by simulating minute-by-minute, honoring the standard (and easy to get wrong) rule that day-of-month and day-of-week are OR-ed together when both are restricted, not AND-ed — not a regex that guesses at the next date.

Center-crops an image to the largest region matching a common named aspect ratio (1:1, 4:3, 16:9, or 3:2) — distinct from Image Cropper's exact pixel-coordinate input, for the common case where a standard ratio matters more than an exact region.

Joins two or more audio files with a real overlapping crossfade between each consecutive pair, via ffmpeg's acrossfade filter — distinct from Audio Joiner's hard-cut concatenation. For more than two inputs, acrossfade is chained: file 1 crossfades into file 2, that result crossfades into file 3, and so on, so every consecutive pair gets a real transition rather than only the first two files.

Scans a CSS/SCSS file for color literals (hex, rgb()/rgba(), hsl()/hsla(), and standard CSS named colors) and outputs the deduplicated, distinct palette found.

Builds a syntactically valid CSS linear-gradient()/radial-gradient() from structured stop data.

Strips comments and collapses redundant whitespace in CSS via a small tokenizing pass, not a blind regex — it tracks whether it's inside a string literal or a url() value and leaves those completely untouched, since whitespace and "/* */"-looking sequences can be meaningful there.

Scores a CSS selector's real specificity using the standard (inline, ID, class/attribute/pseudo-class, element/pseudo-element) weighting the CSS spec itself defines — ID selectors (#id), class/attribute/pseudo-class selectors (.class, [attr], :hover), and element/pseudo-element selectors (div, ::before) are each counted separately, matching how browsers actually resolve competing rules.

Converts a CSS length between px, rem, em, and pt through px as the common unit — rem/em both depend on the base font size you provide, not a silently hardcoded 16px.

Converts between CSV and fixed-width text, bidirectionally, using an explicit per-column width array (required for the fixed-width side, since fixed-width has no field delimiter to infer boundaries from). Values are right-padded with spaces to width, or truncated if longer.

Converts a CSV file to JSON, or a JSON array of row objects to CSV, entirely in-browser via SheetJS.

Converts between CSV and JSON Lines (one JSON object per line, a.k.a. NDJSON) — distinct from CSV ↔ JSON Converter, which produces/reads a single JSON array rather than one object per line.

Converts a CSV file to a real .xlsx workbook, or an XLSX workbook to CSV, via SheetJS.

Reports column count, a per-column inferred type (number, boolean, date, string, mixed, or empty), and each column's empty-cell count — a quick structural sanity check before running other data tools on the same file.

Converts a CSV file directly into a Markdown table, reusing the exact same cell-escaping rules as JSON Array to Markdown Table.

Generates SQL INSERT statements from spreadsheet rows, with real value escaping — not a naive template-string join, which is a genuine correctness/injection-shaped bug even for a client-side tool generating text a person pastes elsewhere. Escaping targets MySQL-compatible syntax (backslash as an escape character); ANSI-only engines (PostgreSQL, SQLite) can drop the extra backslash-doubling if their string literals don't use it.

Builds a runnable curl command from a method, URL, headers, and optional body — every value is correctly single-quote-escaped for POSIX shells (a naive template-string join breaks the moment a header or body value contains a quote, backtick, or $).

Converts between 15 currencies using a static, bundled rate table — no live exchange-rate API call, since this app never makes network requests. Rates are a fixed snapshot as of 2026-08-01, not live, and every conversion result says so explicitly rather than implying real-time accuracy.

Draws text following an arc centered on the image, radius given in pixels — each character is individually translated and rotated to sit tangent to the circle (real per-character positioning along the curve), not straight text placed over a curved background graphic.

A positionable vignette, distinct from Vignette Effect's fixed-center version — centerX/centerY (0-1, fraction of width/height) place the bright spot anywhere in the frame, and radius (fraction of the image's diagonal) controls how far it spreads. Same real multiply-blended radial-gradient technique as Vignette Effect, just with the center and spread exposed as parameters instead of fixed.

Reformats recognizably-dated cells to a consistent target format (YYYY/MM/DD tokens) across a whole sheet — genuinely ambiguous dates (like "01/02/03") are left untouched rather than silently guessed at.

Computes the exact elapsed time between two dates via the platform Date object's own millisecond difference — correct across DST transitions and leap years by construction, since no calendar math is hand-rolled.

A debugging/inspection tool, not an end-user editing tool: decodes every non-image stream in the PDF (content streams, most commonly FlateDecode-compressed) via pdf-lib's own decodePDFRawStream() and dumps the result as human-readable text, one section per object — for people who need to see the raw PDF operators actually inside a file's structure. Image streams are skipped (their decoded bytes are pixel data, not readable text) and each section is capped at 5,000 characters to keep the output usable.

Draws a decorative frame around an image in one of three named styles: simple (a single solid border), double (two thin concentric border lines with a gap between them), or polaroid (a thick white mat with an extra-tall bottom margin, in the style of a Polaroid print). Distinct from Border & Shadow Maker (Batch 4), which adds a drop shadow rather than a decorative frame style.

Removes real PDF encryption via qpdf.wasm, given the correct password (either the user or owner password works). A wrong password is reported as a specific, named error rather than a generic failure; a file that was never encrypted at all is a separate, distinctly-named case, checked before qpdf is ever invoked — real QPDF behavior, verified empirically, is that "decrypting" an already-unencrypted file silently succeeds as a no-op, which this tool deliberately treats as a distinct, honestly-reported case instead.

Deinterlaces interlaced video via ffmpeg's yadif filter, a long-established, widely-available deinterlacer.

Strips accents/diacritics from text (e.g. "café" → "cafe") via the exact same NFD-normalize-and-strip-combining-marks technique URL Slug Generator uses internally, exposed here as its own standalone text tool — for when the goal is plain de-accented text, not a URL slug.

Reports whether a PDF already has one or more digital signature fields (signed elsewhere — e.g. Adobe Acrobat or DocuSign) and what identity/date/reason info is present in each signature's own dictionary. Read-only reporting on signatures that already exist — genuinely distinct from, and much lower-stakes than, actually creating one, which pdf-lib itself has no API for and which this suite's PKCS#12 tools deliberately left out of scope. The raw signature bytes (/Contents) are never included in the report — they're cryptographic material, not useful as text, and reading them isn't the same as verifying them (this tool does not attempt cryptographic verification of the signature's validity).

Stamps a fixed label (e.g. APPROVED, DRAFT, CONFIDENTIAL, or any custom text) once per page, in a chosen position and color — simpler than Bates Numbering, which stamps a running sequence rather than one fixed label.

Finds the single most common color via the same real median-cut bucketing Color Palette Extractor uses, then reports the largest bucket by pixel count (the statistical mode) rather than every bucket — lighter-weight than the full palette, and a genuinely different question from Average Color Info's simple mean across every pixel (a scene that's half deep blue and half bright yellow averages to a muddy green that appears nowhere in the image; the dominant color correctly reports blue or yellow instead).

Maps each pixel's weighted-RGB luminance (0.299R + 0.587G + 0.114B, not a naive channel average) onto a linear gradient between shadowColor (darkest) and highlightColor (lightest), producing the classic two-tone poster look.

Detects columns whose values are identical across every row — a different problem from Duplicate Row Remover, which looks for duplicate rows, not duplicate columns.

Finds and marks every line that duplicates an earlier line, without removing anything — reports each line number, its text, and which earlier line number it first duplicated. Complements Line Sorter's dedupe mode (which actually removes duplicates); this tool only reports.

Removes pages that are textually identical to an earlier page — each page's extracted text (via pdf.js, the same extraction pdf-to-text uses) is the duplicate signal. This catches textually-identical pages; two pages that look visually identical but were produced by different encodings (e.g. a scanned image repeated at a different resolution) won't be caught, since there's no text to compare.

Drops rows that are an exact full-row match of an earlier row, preserving the input's own format (CSV, TSV, or XLSX) and the first occurrence's position. Partial/fuzzy duplicate matching is a different, more subjective problem than this pass covers.

Generates a QR code via the qrcode package's real encoder (Reed-Solomon error correction, proper version/mask selection) — not a lookup against a third-party image API, which this app's zero-network-request design rules out anyway.

Normalizes audio to an explicit EBU R128 integrated-loudness target (in LUFS, default -23 LUFS — the EBU R128 broadcast standard target) via ffmpeg's loudnorm filter with I=targetLufs set explicitly. More precise than Volume Booster/Normalizer's (Batch 3) 'normalize' mode, which runs loudnorm with its own default target rather than a caller-chosen one.

Detects edges via a real Sobel operator (two 3x3 convolution kernels, horizontal and vertical gradient) applied to the grayscale image over getImageData — not a fake "increase contrast" approximation. Pixels whose combined gradient magnitude exceeds the threshold are drawn white on black.

Applies a real 3x3 emboss convolution kernel over the grayscale image — the same convolution-over-getImageData category as the Sobel-based Edge/Outline Detector — producing a raised, engraved-metal look with a mid-gray base and directional highlights/shadows.

Strips emoji from text via real Unicode detection — each grapheme cluster (Intl.Segmenter, so a multi-codepoint emoji like a flag or a skin-tone-modified emoji is treated as one unit) is tested against the Extended_Pictographic Unicode property, not a hand-maintained partial code-point range list that would miss newer emoji.

Fills blank or missing cells in one column with a given default value — distinct from Empty Row Stripper, which removes whole rows rather than filling individual cells.

Drops any column that's empty in every row, preserving the input's own format (CSV, TSV, or XLSX).

Drops rows where every cell is empty or whitespace-only, preserving the input's own format (CSV, TSV, or XLSX). A row with even one non-blank cell is kept.

Detects and strips a UTF-8 byte-order mark if present, and flags likely mojibake (the common pattern of UTF-8 bytes that were mistakenly re-decoded as Latin-1/Windows-1252) as a warning — it reports the problem rather than silently guessing at a fix, since an automatic "fix" for mojibake can itself corrupt already-correct text.

Applies real, standard PDF encryption (AES-256, via qpdf.wasm — pdf-lib itself has no encryption API at all) with two genuinely distinct passwords: the USER password is required to open the document; the OWNER password is required to change permissions or remove protection later, and can be set alone (with no user password) so anyone can read the file but only the owner-password holder can alter its permissions. At least one password must be set. Permissions (printing, modification, text/image extraction) are real qpdf encryption permissions embedded in the file itself, not a cosmetic setting — verified against qpdf's own current CLI documentation before this tool was built, not guessed.

Keeps every Nth element of a JSON array (1st, then (1+N)th, (1+2N)th, ...) — deterministic sampling by position, distinct from Random Row Sampler's uniform-random-without-replacement selection.

Removes all EXIF metadata (camera make/model, timestamps, and — most privacy-sensitive — embedded GPS location) by re-encoding the image through canvas. This works because it's structural, not a best-effort scrub: createImageBitmap() decodes only the pixel grid, and canvas has no EXIF-preserving code path at all — there is no metadata left to carry through by the time drawImage()/toBlob() run, confirmed against the canvas spec rather than assumed.

Reads a JPEG's EXIF metadata by parsing the file's own APP1/TIFF-structured header bytes directly — a fixed, documented binary format, not free-form text, so a small hand-written parser is genuinely correct here rather than a risky shortcut. Every tag found is reported (by name where this tool recognizes it, by numeric ID otherwise) rather than silently dropping anything unrecognized.

Finds every email address in a text file via real email-pattern matching, output as a deduplicated, order-preserved list.

Finds every http(s):// URL in a text file via real URL-pattern matching, output as a deduplicated, order-preserved list.

Strips the video stream and keeps only the audio track, via ffmpeg's -vn flag — no video re-encode, the audio stream is copied as-is.

Pulls every embedded raster image out of a PDF as its own file — distinct from PDF to Image, which rasterizes whole pages regardless of what's on them. Walks the document's own /XObject /Subtype /Image dictionaries directly (pdf-lib exposes no image-listing API) and finds each one's real /Filter. JPEG-filtered images (DCTDecode) are extracted as-is — their stream bytes already are a complete JPEG file, no re-encoding needed. Images using other filters (e.g. Flate-compressed raw bitmaps) are listed in the manifest but not extracted, since rebuilding a standalone file from raw decoded pixel data needs additional color/bit-depth handling out of scope for this pass.

Extracts every #-style Markdown heading (# through ######) into a flat outline list, with its nesting level and any code-span/emphasis markers stripped from the text — unambiguous, since Markdown heading syntax is an explicit character count, unlike a PDF outline generator's font-size-based guess.

Extracts text for only the given page range (e.g. "1-3,5,7-9", parsed with the same page-range logic PDF Split by Page Range uses) via pdf.js's real getTextContent() — the same renderer PDF to Text uses, just scoped to fewer pages. Not OCR, so a scanned/image-only page in range legitimately extracts as empty.

Generates fake test data (names, emails, addresses, phone numbers) using crypto.getRandomValues() for the underlying randomness, the same discipline as any password/token generator.

Canvas-resizes a source image to the standard favicon/touch-icon size set (16, 32, 48, 180, 192, 512px) and returns each size as its own PNG file — no zip bundling, the same multiple-outputs-from-one-run pattern pdf-to-image and pdf-split-range already use.

Formats a byte count as a human-readable size, in either decimal (1000-based: KB, MB, GB — the SI convention) or binary (1024-based: KiB, MiB, GiB — the convention operating systems and RAM sizes actually use) — these produce genuinely different numbers for the same byte count, not just different labels.

Iteratively adjusts JPEG quality via real binary search (not a single fixed guess) to approach a target file size, bounded to a fixed maximum of 8 attempts — a real, terminating search, not an open-ended loop. Reports the actual quality and file size it converged on, and whether the target was met, since binary search on quality can't always hit an exact byte count (some images simply can't compress that small without a black/blank result, and this tool won't silently claim otherwise).

Overlays per-pixel random luminance noise (film grain) onto an image, via Math.random() — a visual-texture effect, not a security context, so the cryptographically-strong RNG used elsewhere in this app (passwords, sampling) is not required here.

Runs a regex find-and-replace directly on plain text, or across every cell if the input is a recognizable spreadsheet (CSV/TSV/XLSX, via the same shared reader every Cluster B sheet tool uses) — an invalid pattern surfaces the real SyntaxError message.

Diffs two JSON files whose roots are flat objects — key-by-key, one level deep — distinct from JSON Diff Viewer, which walks arbitrarily nested structures. A value that is itself an object/array is compared by JSON-serialized equality, not recursed into further.

Converts interactive form fields into static page content via pdf-lib's real PDFForm.flatten() API — each field's current appearance becomes part of the page's content stream, and the fields themselves are removed, so the result reads identically across every PDF viewer/printer but is no longer fillable.

Flips an image horizontally/vertically and/or rotates it by 90/180/270° — flip is applied in the image's own local coordinate space before rotation, a fixed, documented order, since flipping and rotating don't commute (flip-then-rotate and rotate-then-flip generally produce different results).

Reports, per font referenced in the PDF, whether it's actually embedded (its FontDescriptor has a real FontFile/FontFile2/FontFile3 stream) or relies on the viewer's own system font — read-only. Distinct from Font Info Viewer, which just lists font names; this specifically flags the portability risk of a non-embedded font rendering differently (or not matching) on a machine that lacks it.

Lists every font referenced anywhere in the PDF's object graph (base name, subtype, and encoding) by scanning for /Type /Font dictionaries directly — read-only, pdf-lib exposes no dedicated font-listing API.

Reads every interactive form field's name, type, and current value via pdf-lib's PDFForm API, output as JSON. A PDF with no form fields is reported as a normal, named outcome rather than treated as a failure.

Lists every interactive form field's name and type only — distinct from Form Data Extractor, which reads each field's current value. A PDF with no form fields is reported as a normal result, not an error.

Renames interactive form fields by their current name, via pdf-lib's real low-level PDFAcroField.setPartialName() API (there is no high-level rename method). Renames only a field's own name segment — for a field nested under a hierarchical parent field, the parent's part of the fully-qualified name is unaffected. Field names not found in the document are reported as skipped, not a hard failure, so a partially-matching rename map still applies what it can.

Removes every cell formula (the "f" property SheetJS attaches to a computed cell) across every sheet in a workbook, keeping only each cell's already-computed value ("v") — useful before sharing a workbook without exposing its formula logic.

Changes a video's frame rate via ffmpeg's -r output option.

Freezes the frame at an exact timestamp and holds it for a chosen duration, spliced into the video via the same concat-demuxer technique Video Merger/Looper use. Video only — audio is dropped, since correctly splicing audio around an inserted freeze segment is a separate problem this tool does not attempt.

Converts between units of length, weight, volume, or temperature. Temperature uses real affine conversion (its own scale-to-Celsius offset and factor per unit) rather than a single multiplicative ratio table — the same ratio-table approach that works for length/weight/volume would get temperature wrong (0°C is not 32°F × some ratio).

Replaces every value in the columns you pick with a fixed placeholder — you choose which column(s), this does not scan for or detect sensitive data automatically. This is not the same tool as (and makes no claim to match) an automatic PII/sensitive-number detector: it catches nothing on its own beyond the exact columns you name.

Converts an image between PNG, JPEG, and WebP via canvas.toBlob() — all three are well-supported encode targets. Quality is optional and only meaningful for the lossy formats (JPEG/WebP); PNG ignores it since it is always lossless.

Converts an animated GIF to MP4 — the reverse of Video to GIF. Pads to even width/height via the scale filter first (H.264's yuv420p pixel format requires even dimensions, and GIFs commonly have odd ones) before encoding.

Adds a multi-color linear-gradient border frame around an image — distinct from Border/Shadow's solid-color version. The image is composited on top of a larger, gradient-filled canvas, so the center pixels are untouched original data, not re-drawn over a gradient.

Converts an image to grayscale via the canvas context's native filter string (grayscale(100%)).

Groups a JSON array of objects by one key and reports the average of a numeric value key within each distinct group.

Checks whether an Indian GSTIN matches its real 15-character structure — 2-digit state code, 10-character PAN, 1-digit entity code, a literal "Z", and 1 checksum character. Format-only, the same honesty framing as PAN Format Validator: does not verify the GSTIN is real, active, or belongs to a registered business, and nothing is transmitted anywhere.

Classic newspaper-print-style halftone: the image is divided into a grid of dotSizePx cells, each cell's real average luminance is computed, and a black dot sized proportionally to that darkness (bigger dot = darker region) is drawn centered in the cell on a white background.

Computes a file's checksum. SHA-1/256/512 go through the real Web Crypto API (crypto.subtle.digest) — MD5 isn't available there at all, so it's a from-scratch, spec-verified implementation. MD5 is a legacy checksum only: broken for any security purpose (collision-findable in seconds), never used here to imply integrity against a malicious actor.

Computes a file's hash via Hash Generator's exact hashing logic (including its from-scratch MD5 fallback, since Web Crypto doesn't expose MD5) and reports whether it matches an expected value — a case-insensitive, whitespace-trimmed string comparison, not a re-implementation of the hashing itself.

Rewrites a spreadsheet's header row to a consistent case, reusing Case Transformer's (Batch 1) exact word-splitting and conversion logic rather than a second copy of it — only the header row changes, every data row's values are untouched.

Rebuilds a spreadsheet using the correct header row — auto-detected as the first non-empty row, or a row you specify — dropping anything before it. Preserves the input's own format.

Stamps custom header and/or footer text onto every page, supporting {page}, {total}, and {date} tokens — leave either field blank to add only a header or only a footer.

Extends Color Picker & Hex/RGB/HSL Converter with CMYK — parses hex, rgb()/rgba(), hsl()/hsla(), or cmyk() input (reusing that tool's exact parsing/formatting for the first three) and outputs the equivalent in all four formats, via the real, standard RGB↔CMYK conversion formula.

Extracts the text under a PDF's existing highlight annotations as a list, one entry per highlight — reading existing highlights, not creating new ones. Each highlight's real /QuadPoints (read via pdf-lib's low-level object API) are turned into a bounding box, then intersected against pdf.js's real per-page text-run positions (the same position-mapping technique pdf-redact-by-search-term and pii-redactor already established) to recover the actual covered text.

Generates an HMAC of a file's content via the real Web Crypto API (crypto.subtle) — the secret key is never logged or echoed in any output, including error messages.

Encodes or decodes HTML entities via the browser's own DOM, not a hand-rolled entity table — correctly covers both named entities (&amp;) and numeric ones (&#39;).

Conservatively minifies HTML: collapses runs of whitespace between tags to a single space and strips HTML comments — deliberately scoped down from a full aggressive minifier. A small tokenizing state machine (not a blind find-and-replace regex over the whole file) tracks tag boundaries so the content of <script>, <style>, <pre>, and <textarea> is always copied through byte-for-byte untouched, since whitespace is meaningful there and a naive pass could corrupt it.

Converts an HTML <table> to an XLSX workbook, or an XLSX workbook to an HTML table — SheetJS has native support for both directions.

Extracts every <table> in an HTML file (not just the first, unlike HTML Table to XLSX) via DOMParser, outputting one JSON array of row objects per table.

Strips HTML tags down to plain text via a real DOMParser parse, not a regex over the raw markup — the same reasoning SVG Optimizer already established for not regex-manipulating markup: a hand-rolled tag-stripping regex breaks on malformed/nested markup and doesn't correctly handle <script>/<style> content (which should be dropped, not kept as "text"), while a real parser handles both correctly by construction.

Converts an HTML file to Markdown via turndown, which walks the real parsed DOM tree (the browser's own HTML parser) rather than converting Markdown-to-HTML's parser backwards — the two directions are different enough problems that this app uses a separate, purpose-built library for each.

Parses raw HTTP header text (one "Name: value" pair per line, as copied from a browser devtools panel or curl -v output) into structured JSON. Repeated header names (e.g. multiple Set-Cookie lines) are collected into an array, not overwritten.

Looks up an HTTP status code against a static reference table (RFC 9110 plus common widely-used extensions like 418 and 429) — pass a code for one entry, or omit it to get the full table.

Validates an IBAN via the real ISO 7064 mod-97-10 checksum algorithm: move the first four characters to the end, convert letters to numbers (A=10 ... Z=35), then compute the numeric value mod 97 (processed in safe chunks, since the full number is far larger than a 64-bit integer) — a valid IBAN always leaves remainder 1. Format validation only: this does not confirm the account actually exists.

Tiles multiple images into a labeled grid — reuses Collage Maker's grid-cell-fit approach, with an explicit column count and an optional filename caption drawn under each cell (using the browser's own canvas text rendering, which — unlike this app's ffmpeg-based tools — always has a real system font available, so no bundled font file is needed here).

Compares two same-dimension images pixel-by-pixel via getImageData, highlighting every differing pixel in solid magenta over a dimmed grayscale copy of the first image. Images of different dimensions are a named error, not silently cropped or scaled to fit.

Resizes an image to the given width/height. With "maintain aspect ratio" on, the source aspect ratio is preserved by fitting within the requested box (like CSS object-fit: contain) rather than stretching the image to fill it exactly.

Wraps a JPG or PNG image in a single-page PDF, sized to the image (1 image pixel = 1 PDF point).

Checks whether an Indian postal PIN code is structurally valid — 6 digits, with the first digit identifying one of the 9 real postal regions (1-9; 0 is not an assigned region). This is a structural check only, not a live postal-database lookup — it does not confirm the PIN code is currently in use or resolve it to an actual place name.

Rasterizes every page (the same pdf.js-based pipeline Color to Grayscale uses), applies a full color inversion (the same canvas invert(100%) technique Negative/Invert uses), then reassembles the pages into a new PDF — a raster round-trip, not a native content-stream color transform. Not lossless for text-heavy documents: text becomes an inverted image rather than staying real, selectable text.

Computes network address, broadcast address, subnet mask, and usable host range from an IPv4 CIDR via real 32-bit bitwise math, not string manipulation on the octets.

Converts between JSON and XML using the browser's native DOMParser/XMLSerializer, with a documented, explicit array convention (see Guidelines).

Groups a JSON array of objects by one key's value, output as {groupValue: [matching objects]}.

Splits a large JSON array into multiple files of at most pageSize elements each.

Sorts a JSON array of objects by one key — numeric values compare numerically, everything else compares as a string, rather than coercing everything to a string and getting "10" sorted before "2".

Renders a JSON array of flat objects as a Markdown table. Elements with mismatched keys are handled, not crashed on — the table's columns are the union of every key across every element, with blank cells for whichever elements are missing a given key.

Recursively sorts every object's keys alphabetically, leaving array order and all values untouched — useful before hashing or diffing two JSON structures that should be considered equivalent regardless of key order.

Structurally diffs two JSON files key-by-key (added/removed/changed keys, at any nesting depth) — not a text-line diff, which would flag two JSON files as different for pure formatting reasons even when their actual data is identical.

Flattens nested JSON into dot-notation keys (e.g. "a.b.c"), or reverses that back into nested JSON. Arrays use a numeric-index convention ("a.0.b" for a[0].b) in both directions.

Pretty-prints or minifies a JSON file via real JSON.parse()/JSON.stringify() — a syntax error surfaces the parser's own message (line/column context included), not a generic "invalid JSON".

Finds every occurrence of a given key anywhere in a nested JSON structure and reports the path to each — distinct from JS Object Path Getter, which takes one already-known path rather than searching for occurrences of a key name.

Infers a JSON Schema (draft-07) from a JSON sample — the inverse of JSON Schema Validator (Cluster B). Best-effort from one sample, not a schema guarantee: a field this sample happened to always show as a string could genuinely be a number elsewhere.

Validates a JSON file against a JSON Schema (draft-07) document via Ajv — Zod validates against its own schema objects, not arbitrary JSON Schema documents, so this needed a real JSON Schema validator instead.

Infers a Python @dataclass from a JSON sample's shape — nested objects become their own named dataclasses, arrays infer an element type (List[...] of a union type when an array's elements aren't uniform). Same best-effort-from-one-sample honesty as JSON to TypeScript Interface: this is inference from one sample, not a schema guarantee — a field that's always a string here but sometimes a number elsewhere won't be caught.

Infers a TypeScript interface from a JSON sample's shape — nested objects become their own named interfaces, arrays infer an element type (or a union, if the array's elements aren't all the same shape). This is best-effort inference from one sample, not a schema guarantee: a field that's always a string in this sample but sometimes a number elsewhere won't be caught.

Runs a real JSONPath query (jsonpath-plus) against a JSON file, returning every match with its value and absolute path — evaluated in "safe" mode, which uses a minimal scripting engine instead of eval()/Function() for any filter expressions in the query.

Decodes a JWT's header and payload — decoded, not verified. No signing key is ever provided or asked for, so the signature is never checked; this only shows what the token claims, not whether it can be trusted.

Real radial-segment reflection: for every output pixel, its angle around the image center is folded into one base wedge (2π/segments wide, alternating wedges mirrored) and sampled from there — genuine polar-coordinate symmetry math, not a repeated-tile approximation.

Reports what fraction of array elements have a given key present with a non-null value, present but explicitly null, or absent entirely — three genuinely distinct states, not collapsed into a single "missing" count the way a naive check would.

Counts how many times each distinct value for a given key occurs across a JSON array of objects — a real value-frequency tally, sorted by count descending.

Adds letterbox/pillarbox bars to reach a target aspect ratio, via ffmpeg's pad filter — the deliberate opposite of Black Bar Auto-Crop, which removes bars instead of adding them.

Normalizes the row-separator line endings in a CSV file to LF or CRLF — CSV-aware, unlike the general Whitespace Normalizer (Cluster C): a quote-tracking scan leaves newlines that appear *inside* a quoted multi-line field value completely untouched, since those are real field content, not row separators.

Prefixes every line of a text file with a sequential, consistently zero-padded number.

Sorts and/or deduplicates the lines of a text file.

Reports whether a PDF is linearized ("web optimized" / "fast web view") — read-only, checks for the special linearization parameter dictionary (its /Linearized key) the PDF spec requires as the very first object of a linearized file.

Computes the standard reducing-balance EMI: P × r × (1+r)^n / ((1+r)^n − 1), where r is the monthly interest rate and n is the tenure in months — a 0% rate falls back to a plain principal/n split, since the standard formula is undefined at r=0.

Formats a number per a real locale via the platform's own Intl.NumberFormat — thousand separators, decimal marks, and digit grouping all follow that locale's real rules (e.g. "1.234,56" in de-DE vs "1,234.56" in en-US), not a hand-rolled comma-insertion regex that only happens to work for English.

Finds the longest and shortest non-empty line in a text file, by character count, with their line numbers — simple, and genuinely distinct from every existing line-based tool in this suite.

Generates classical Lorem Ipsum placeholder text — no file input needed.

Reports an image's mean, minimum, and maximum luminance (ITU-R BT.601 luma: 0.299R + 0.587G + 0.114B, the same real formula Brightness Histogram uses) — a lighter-weight summary than that tool's full 256-bucket distribution, for when only the range and average matter.

Draws opaque black rectangles over person-specified regions of a PDF, at coordinates you provide. This is deliberately a manual blackout tool only — it does not scan for or detect sensitive numbers (SSNs, card numbers, etc.) automatically, and is not a substitute for an automatic sensitive-data redactor. Also important: this draws a visual box on top of the page: it does not remove the underlying text content stream, so text under the black box can still be selected/copied/extracted by anyone who knows to try. Treat this as a blackout for casual viewing, not a guarantee the covered content is gone from the file.

Adds or removes a uniform whitespace margin around every page's content, by resizing the page and translating its content to compensate — a different technique from PDF Crop, which changes the visible crop box without moving the content underneath it.

Finds every GitHub-Flavored-Markdown table in a file and rewrites it with evenly-padded, aligned pipe columns and a correctly-dashed separator row (preserving each column's :--- / :---: / ---: alignment marker) — text outside tables passes through untouched.

Converts a Markdown file to HTML via marked, a real CommonMark-based parser — not a hand-rolled regex pass, which is a well-known correctness trap even for "simple" Markdown (nested emphasis, code fences, reference-style links all break it quickly).

Merges several spreadsheet files (same expected schema) into one — a header mismatch across files is a named error listing exactly which file differs, not a silently-wrong merge that mixes up columns.

Merges multiple PDFs into one, adding a top-level bookmark per source file (named after that file) with the source's own existing outline entries nested underneath it — built via pdf-lib's low-level object API the same way pdf-outline-viewer reads outlines and pdf-annotation-sticky-note writes annotations, since pdf-lib has no high-level outline-writing API. Every bookmark in a source's nested group points to that source's first page (the same scope limit pdf-outline-viewer already states for reading: resolving each original entry's exact destination page is out of scope), not its own original target page.

Removes PNG ancillary text/metadata chunks (tEXt, zTXt, iTXt, and eXIf) directly from the file's own chunk structure — genuinely different from EXIF Stripper, which works by re-encoding a JPEG through canvas. PNG's metadata lives in named, length-prefixed chunks rather than a single embedded blob, so this parses and rewrites the chunk stream instead.

Records audio-only from the microphone directly to a downloadable file via getUserMedia + MediaRecorder — nothing is uploaded.

Emits the built-in extension↔MIME-type reference table in the direction you choose, as a downloadable JSON file — no file input needed.

Decodes International Morse code back to text (space-separated letters, "/" between words) — a malformed/unrecognized token is reported as a named error listing exactly which token failed, not silently skipped or guessed at.

Compresses a video to MP4 (H.264) entirely in-browser via ffmpeg.wasm, using a quality preset instead of raw encoder flags.

Mixes multiple audio files into one via ffmpeg's real amix filter, with each input's own volume weight applied first (via a per-input volume filter) so tracks can be balanced against each other rather than mixed at uniform loudness.

Silences only the audio within a given [startSec, endSec) window, keeping audio elsewhere untouched — distinct from Video Mute, which silences the whole clip. Video is stream-copied (not re-encoded) since only the audio filter's `volume` is time-gated via ffmpeg's real enable='between(t,start,end)' expression.

Strips the audio track from a video via stream copy — the video itself is never re-encoded.

Finds the nearest CSS named color (the full 147-keyword CSS Color Module extended set) to a given hex/rgb() color, via real CIE76 distance in Lab color space — perceptually meaningful, unlike naive RGB Euclidean distance, which can call two visually-different colors "close" just because their raw channel numbers happen to be near each other.

Inverts an image's colors via the canvas context's native filter string (invert(100%)).

Converts a JSON array of (possibly nested) objects into a flat CSV. Distinct from JSON Flattener (Batch 4, JSON↔JSON): nested objects become dot-notation columns exactly the same way, but arrays are joined into one cell with arrayJoinSeparator rather than exploded into a.0/a.1-style columns — a documented convention chosen specifically because CSV has no natural way to represent a variable-length nested list as columns.

Reports, per column, the real percentage of rows that are null, missing entirely, or whitespace-only — a quick data-quality read before deeper analysis.

Converts a number between bases 2–36 — the input is validated against the claimed base before conversion, since parseInt silently truncates at the first invalid digit instead of erroring.

Strips currency symbols and thousand separators from numeric-looking cells and converts them to real numbers, preserving the input's own format.

Generates a number sequence from start to end by step. step's sign must match the direction implied by start/end — a positive step with start > end (or vice versa) is a named error, not silently returned as an empty or backwards result.

Spells out an integer in English, up to the billions, with real number-naming rules: "and" before a trailing sub-100 remainder ("one thousand and five"), hyphenated compound tens ("twenty-three"), and a leading "negative" for negative numbers.

Flags every row where a given column's numeric value falls outside an [min, max] range, or is non-numeric.

Looks up a single value from a JSON file via a lodash.get-style path — dot notation (a.b.c) and bracket notation (a[0].b, a['key with spaces']) both work, mixed freely. Distinct from JSONPath Query Tester, which runs a full JSONPath query language and can return many matches; this is a single, simple path lookup.

The real, classic oil-painting algorithm: for every pixel, every neighbor within radiusPx is bucketed into one of 20 luminance-intensity levels, the most-populated level (the local intensity mode, not an average) is found, and the output pixel becomes the average RGB of only that mode bucket. This is genuinely different from a blur — it's a mode filter, which is what produces the blocky, painterly brushstroke look rather than a fog.

Re-saves a PDF with object-stream compaction explicitly enabled (pdf-lib's useObjectStreams), a real size-reduction technique — reports the real before/after byte sizes. This does NOT produce true PDF linearization ("Fast Web View"): that requires a specific object-ordering algorithm pdf-lib does not implement, and Linearization Checker will still correctly report the output as not linearized.

Reads a PDF's existing table-of-contents (outline/bookmark) tree by walking the document's own low-level object structure (pdf-lib exposes no dedicated outline API, so this reads the /Outlines dictionary directly) — a PDF with no outline is reported as a normal result (hasOutline: false), not an error. Only each entry's title and nesting are reported; resolving each entry's exact destination page is out of scope for this pass.

Reports each page's exact width/height (in points) and aspect ratio, read-only — useful before N-up or Page Size Changer, which both assume consistent dimensions. Distinct from Page Orientation Detector's coarser portrait/landscape/square-only classification: this reports the real ratio value itself. Like Orientation Detector, dimensions are adjusted for each page's own /Rotate value, since a 90°/270°-rotated page's visual aspect ratio is swapped from its raw MediaBox dimensions.

Reports each of several PDFs' page count side by side and flags any mismatch — a quick multi-file sanity check (e.g. "did every scanned chapter come out the same length as its source?").

Reads a PDF's custom page-labeling scheme (e.g. front matter numbered "i, ii, iii" before the body starts at "1") — a distinct concept from a page's physical position in the document, stored in the catalog's own /PageLabels number tree, read here via pdf-lib's low-level object API since there's no high-level accessor for it. A PDF with no custom labels (using plain physical page numbers throughout) is reported as a normal result, not an error. Covers the common flat /Nums case; a very large document using a nested /Kids number tree may not surface every range.

Stamps a reader-facing page number (e.g. "Page 3 of 12") onto every page, in a configurable corner — distinct from Bates Numbering, which is a legal-audit stamp, not ordinary pagination.

Reports portrait/landscape/square per page from each page's real MediaBox dimensions, adjusted for its own /Rotate value (a 90°/270°-rotated page's visual orientation is swapped from its raw box dimensions) — useful before N-up or Page Size Changer, both of which assume a consistent orientation.

Detects pages whose /Rotate value differs from the document's majority rotation (common after a mixed-orientation scan) and sets those pages to match — reports exactly which pages were changed and what they were changed from/to, not a silent rewrite.

Resizes every page to a standard target size. "scale" stretches each page's content to exactly fill the new dimensions (aspect ratio may change); "crop-or-pad" keeps content at its original size and re-centers it within the new page boundary — spilling off the edge (cropped) if the target is smaller, or surrounded by blank margin (padded) if it's larger.

Extracts a color palette via the exact same real median-cut quantization Color Palette Extractor uses, then exports it as a visual swatch strip image — distinct from that tool's JSON data output.

Maps every color in an ordered "from" list to the corresponding entry in a "to" list (exact matches only, one whole palette swapped for another in one pass) — distinct from Color Replace's single-color-with-tolerance approach, which handles one color at a time with fuzzy matching for JPEG/scaling noise.

Checks whether a text file's content reads the same forwards and backwards. With ignoreSpacesAndPunctuation on, whitespace/punctuation are stripped and case is folded first (so "A man, a plan, a canal: Panama" correctly checks as a palindrome); off, the comparison is exact, character-for-character.

Checks whether an Indian PAN (Permanent Account Number) matches its real structural pattern — 5 letters, 4 digits, 1 letter. Format-only, the same honesty framing as Luhn Validator/IBAN Validator: this does not verify a real PAN exists, is active, or belongs to anyone. Nothing is transmitted anywhere — the check runs entirely in this browser tab.

Tiles a single portrait photo into a print-ready grid of passport-size copies on an A4 sheet. Photo size and grid dimensions are fully configurable, since passport photo requirements vary by country rather than following one universal spec.

Generates a random password via crypto.getRandomValues() — never Math.random(), which is not a cryptographically secure source and must not be used to generate anything security-sensitive. Reports the resulting entropy in bits alongside the password.

Estimates real entropy (character-set size × length, in bits — the standard information-theoretic measure, not a fake "strong/weak" label with no basis) plus named pattern checks (sequential runs like "abc"/"123", and repeated-character runs like "aaa"). The password itself never appears in this tool's output, in any error message, or in a console log — only its measured characteristics do.

Reports whether an .xlsx workbook is encrypted, purely by inspecting its own file-header bytes — read-only, never attempts to open it. A normal (unencrypted) .xlsx is a plain ZIP archive (starts with the "PK" signature); Excel's standard/agile password encryption instead wraps the whole file in an OLE2 Compound File container (the D0 CF 11 E0 A1 B1 1A E1 signature), which is what this checks for.

Stamps a PDF page with the identity information (subject, issuer, validity) read out of a .p12/.pfx certificate — NOT a cryptographic signature. A real PAdES/PKCS#7 signature needs a correctly-built CMS SignedData structure and exact PDF /ByteRange handling that a generic client-side tool can't honestly claim to always get right; this instead visibly stamps the certificate's real identity onto the page, with that exact limitation printed on the stamp itself, so the caveat travels with the document once downloaded rather than living only on this page.

Re-encodes a PDF's embedded JPEG images at a lower quality to reduce file size — scoped deliberately to DCTDecode (JPEG) image streams only, since decoding arbitrary PDF image encodings (indexed color, CMYK, various bit depths) correctly is a much larger problem than this tool takes on. A mostly-text PDF, or one whose images are already highly compressed, may shrink very little or not at all — this tool never claims a guaranteed reduction.

Crops every page of a PDF inward by a fixed margin, in points (1/72 inch).

Removes the given pages (e.g. "1-3,5,7-9") from a PDF.

Pulls the given pages (e.g. "1-3,5,7-9") out of a PDF into one new, consolidated document, in that order.

Combines multiple PDF files into one, in the order they were added.

Reads a PDF's document info dictionary (title, author, subject, keywords, creator, producer, creation/modification dates) plus page count and each page's dimensions, via pdf-lib — read-only, outputs a JSON summary.

Lays multiple source pages out on each output sheet as a grid (2, 4, 6, or 9 per sheet), each source page embedded and scaled to fit its cell.

Rearranges a PDF's pages into a new order that you specify.

Rotates the given pages of a PDF by 90, 180, or 270 degrees, relative to each page's current orientation.

Splits a PDF into multiple documents, one per comma-separated page range (e.g. "1-3,5,7-9" produces three separate files) — for pulling one consolidated document out of a range instead, see PDF Extract Pages.

Extracts each PDF's text (pdf-to-text's own pdf.js-based extraction) and runs a real line-level LCS diff between them (the same algorithm Diff Checker uses) — a purely textual comparison, so identical-looking pages that differ only in images, fonts, or exact layout won't be flagged.

Stamps a semi-transparent text watermark across every page via pdf-lib's drawText, diagonal (45°) by default — the same watermark text, opacity, and rotation applied uniformly to every page.

Rasterizes every page of a PDF to a JPG or PNG image, entirely in-browser via pdf.js.

Extracts every page's text via pdf.js's real getTextContent() (the same renderer/parser pdf-to-image uses), concatenated with page-break markers — not OCR, so a scanned/image-only PDF will legitimately extract as empty.

Rotates specific pages by independently-specified angles — distinct from PDF Rotate Pages, which applies one uniform angle across a page range. Each entry names its own 1-indexed page and its own 90/180/270 rotation.

Reports word and character counts per page, reusing pdf-to-text's exact text-extraction technique — distinct from PDF to Text, which returns the whole document's text as one file rather than a per-page breakdown.

For a categorical key, reports each distinct value's share of the array as a percentage — the same grouping Column Value Frequency does for spreadsheets, expressed as percentages of the whole rather than raw counts, for a JSON array of objects.

Three genuinely distinct percentage calculations — "X% of Y", "X is what percent of Y", and "percent change from X to Y" — each its own real formula, not one formula reused incorrectly for all three.

Straightens a photographed-at-an-angle rectangle (a document, a whiteboard, a sign) via a real projective (homography) transform from 4 person-specified corners — not an affine approximation. Uses the standard unit-square-to-quadrilateral projective mapping (the same closed-form 8-parameter solution from Heckbert's "Fundamentals of Texture Mapping and Image Warping", the standard reference for this exact problem), then resamples every output pixel by inverse-mapping it back into the source image with bilinear interpolation — genuinely per-pixel perspective-correct, not a 2-triangle affine texture-mapping shortcut (which visibly distorts near the seam under real perspective).

Reformats a phone number's digits into a chosen display style — formatting/display only, NOT validation. This does not check whether the number is a real, dialable, or correctly-lengthed number for its claimed country; it just re-punctuates whatever digits it's given into the chosen visual pattern.

Shifts pitch by semitones while keeping tempo roughly constant, via the asetrate+atempo trick — asetrate alone would change pitch AND speed together (it's just resampling), so this compensates the speed back with atempo afterward. This is a real, well-known but genuinely approximate technique, not phase-vocoder-quality pitch shifting: confirmed via a real captured ffmpeg.exec(['-filters']) run against this project's actual bundled @ffmpeg/core (5.1.4) that rubberband is not compiled in — its build configuration line has no --enable-librubberband, and "rubberband" doesn't appear anywhere in the printed filter list — which is what true high-quality pitch shifting would need.

Pixelates an image by drawing it at a much smaller resolution, then scaling that back up with imageSmoothingEnabled = false — nearest-neighbor upscaling is what actually produces the blocky mosaic look, not a blur.

Reads a .p12/.pfx certificate container and reports each certificate's subject, issuer, serial number, and validity dates, plus whether a matching private key is present in the file — via node-forge, a real, browser-compatible ASN.1/PKCS#12 parser, not a placeholder. The private key material itself is never included in the output, even encoded, even though it came from the person's own file — this tool's job is showing what's in the container, not extracting the key for reuse elsewhere.

Quantizes each of the R, G, and B channels independently to levels evenly-spaced steps, producing the flat-banded "poster" look. Real per-channel level quantization over getImageData, not a blur-then-threshold approximation.

Real primality test via trial division up to √n — sufficient for reasonable input sizes; a much larger, cryptographic-scale input would need Miller-Rabin instead, but that's out of scope for a general-purpose checker like this one.

A lighter, single-score version of Readability Score Calculator (Batch 6) — just the real Flesch Reading Ease formula, not the fuller Flesch-Kincaid grade-level breakdown. Reuses that tool's exact word/sentence/syllable counting logic (same real formula source), just reports one number instead of both.

Reports the row count and column count of a spreadsheet, with no other processing — a fast sanity check before running something heavier.

Re-serializes a CSV with every field that needs quoting wrapped consistently in one target quote character — parsed via the same real CSV parser this app's other spreadsheet tools use (which already handles double- or single-quoted fields on read), then written back out with standard CSV escaping (doubling the target quote character inside a quoted field) for the chosen quote character specifically, since the standard writer this app otherwise reuses only supports the RFC 4180 double-quote convention.

Shuffles a JSON array (the document root, or the array at a given top-level key) with a real, unbiased Fisher-Yates shuffle, backed by crypto.getRandomValues() for its randomness — not the well-known biased anti-pattern of sorting by a random comparator (Array.sort(() => Math.random() - 0.5)), which systematically favors some permutations over others.

Picks sampleSize rows at random, without replacement, via crypto.getRandomValues() — the same randomness discipline Password Generator uses, not Math.random().

Scores a text file using the real, named Flesch-Kincaid formulas (Reading Ease and Grade Level) — not an invented ad-hoc heuristic.

Finds literal occurrences of a search term (via pdf.js's own text extraction, mapped back to each match's real page position) and blackouts them. This is explicitly literal-text search, not pattern-based sensitive-data detection — the same distinction Manual Redaction (Batch 4) draws. Matches are found per pdf.js text run; a term split across two separate runs (e.g. by an unusual line break mid-word) may not be caught. Important limitation shared with Manual Redaction: this draws a visual box on top of the page — it does not remove the underlying text content stream, so the covered text can still be selected, copied, or extracted by anyone who reads the PDF's content stream directly rather than rendering it. Treat this as a blackout for casual viewing, not a guarantee the covered content is gone from the file — for that, see the Automatic PII Redactor, which rasterizes matched pages so the text is genuinely removed.

Checks whether extractable text still exists underneath what looks like a solid-fill redaction rectangle, by cross-referencing pdf.js's real text positions against solid-fill regions read from the page's own operator list — a genuine audit companion to Manual Redaction, Redact by Search Term, and the PII Redactor, not a duplicate of any of them. Answers, for real, the empirical question those tools' own descriptions leave open: did the redaction actually remove the underlying text, or just visually cover it? A named, narrow scope limit: this only tracks fill color changes through explicit save/transform/restore operators in the page's operator list, not pdf.js's own internal 4-op save+transform+constructPath+restore merge optimization (which applies to a different, narrow repeated-shape case, not typical single-rectangle redaction boxes) — and it cannot detect a page that was flattened to a single image (there is no text layer left to find, so nothing is flagged, which is the correct, safe outcome, not a false pass).

A reference table of common regular expressions (email, URL, IPv4, hex color, US phone number, ISO date, etc.) — each pattern is actually executed against its own example string every time this tool runs, and the real match is what's shown, not a hardcoded claim that could silently drift out of sync with the pattern.

Breaks a regular expression down into its real components — anchors, character classes, quantifiers, groups, alternation, escapes — with a plain-English explanation for each, via an actual left-to-right token scanner rather than a canned list of "common patterns". Constructs this scanner does not recognize are reported explicitly, not silently guessed at.

Tests a regular expression against sample text via a real RegExp, returning every match with its index and capture groups — an invalid pattern surfaces the real SyntaxError message rather than a generic "bad regex".

Strips every page's /Annots array (comments, sticky notes, highlights, and other markup annotations) while leaving the page's own drawn content untouched — general annotation cleanup, distinct from Remove Metadata (document properties) and Remove Hyperlinks (link annotations specifically, which this tool would also remove as a side effect since a link is itself an annotation).

Removes only the selected annotation types (highlight, sticky note, stamp, and/or link) — more granular than Remove All Annotations, which removes every annotation regardless of kind. Annotation type is matched against each annotation's real /Subtype value.

Removes pages with genuinely no meaningful content — no real text (via pdf.js text extraction) AND no painted image (via pdf.js's own operator list, checking for image-paint operators). A page with only a header/footer still has real text, so it's correctly kept, not treated as blank just because there's very little on it.

Removes one or more named columns from a spreadsheet, preserving its original format (CSV, TSV, or XLSX).

Drops array elements that are a deep-equality match (by canonical JSON representation, with object keys sorted so key order doesn't affect the comparison) of an earlier element, keeping the first occurrence — distinct from Duplicate Row Remover's spreadsheet-row scope, this operates on a JSON array of arbitrarily nested values.

Removes interactive form fields that have no value at all — a text field with no text, or a dropdown/option list with nothing selected. Distinct from Flatten Form, which converts *filled* fields into static page content; this instead cleans up unused form structure via pdf-lib's real PDFForm.removeField() API. Checkboxes and radio groups always have a determinate checked/unchecked state, so they're never considered empty.

Removes blank pages only from the very end of the document (the common case after a bad scan or print run) — stops at the first non-blank page counting backward, so a genuinely blank page in the middle is correctly left alone. For a whole-document blank-page sweep, see Remove Blank Pages.

Attempts to open a possibly-corrupted PDF and re-save it — a genuine best-effort tool, not a guarantee. First tries pdf-lib's normal strict load; if that fails, retries with pdf-lib's real tolerant-parsing options (throwOnInvalidObject: false, capNumbers: true, ignoreEncryption: true), which skip invalid objects and clamp malformed numbers instead of throwing. Re-saving with useObjectStreams rewrites the file's cross-reference structure from scratch, which itself fixes a common class of corruption (a broken/stale xref table) even when nothing else was wrong. A PDF too damaged for even tolerant parsing to open is a named, expected outcome (error.code: UNRECOVERABLE), not a crash.

Flags immediately-repeated words ("the the") — a real, common proofreading check, case-insensitive and tolerant of the whitespace/punctuation between repeats — distinct from a generic whole-document dedupe.

Scales an image proportionally by a percentage of its original size — distinct framing from Image Resizer's absolute-pixel-dimension approach, for when "half size" or "200%" is the actual intent rather than a specific target width/height.

Scales a video proportionally by a percentage of its original size, via ffmpeg's scale filter — distinct framing from Video Resolution Changer's absolute-dimension approach. Dimensions are rounded down to the nearest even number (trunc(dim/2)*2), a real, well-known ffmpeg requirement: most video codecs (including libx264) reject odd width/height.

Resizes a video's resolution via ffmpeg's scale filter.

Splits an image into three separate grayscale images, one per R/G/B channel — each output shows that channel's real intensity value as gray, not a tinted color image.

Read-only: reports whether a PDF contains embedded rich media — video/audio (/Subtype /Screen or /Sound annotations, or /RichMedia annotations), or 3D content (/Subtype /3D annotations) — by scanning the document's own object graph directly, since pdf-lib has no dedicated rich-media API. Does not extract or play the media, only reports its presence and count.

Converts between Arabic (1-3999) and Roman numerals using real subtractive-notation rules (IV, IX, XL, XC, CD, CM) — not a purely additive lookup, which would render 4 as "IIII" instead of "IV".

Rotates an image by any angle, not just 90/180/270° — the output canvas is resized to the real bounding box of the rotated rectangle (via the standard |w·cos θ| + |h·sin θ| / |w·sin θ| + |h·cos θ| formula) so no corner is clipped, with the newly-exposed area left transparent.

Rounds an image's corners using the canvas context's native roundRect() clip path, then draws the image through it — output is PNG, since rounded corners need real transparency.

Keeps only the rows where a given column matches a condition (equals, contains, greater-than, less-than), preserving the input's own format (CSV, TSV, or XLSX). greater-than/less-than compare numerically; rows whose cell isn't a number are excluded from a numeric comparison rather than sorted arbitrarily.

Adds a sequential row-number column, starting from a given number, as the first column.

Resamples audio to a target sample rate via ffmpeg's -ar flag.

Adjusts color saturation via the canvas context's native filter string (saturate()), the same technique as Brightness/Contrast Adjuster.

Classifies every page as text-native, likely-scanned, or blank via pdf.js's real getTextContent()/getOperatorList() (the same page-inspection pdf-remove-blank-pages uses): a page with a painted image but no extractable text is reported as likely-scanned, a page with neither is reported as blank — reported per page, not just one yes/no for the whole document.

Splits a video into separate files at each detected scene change. First runs ffmpeg's select filter with a real scene-change score expression (select='gt(scene,sceneThreshold)') paired with showinfo to log each cut's pts_time, then re-encodes one output segment per interval between cuts.

Draws a translucent highlight over every occurrence of a literal search term — complementary to Redact by Search Term, which draws an opaque blackout instead. Reuses the exact same pdf.js text-position-mapping approach that tool uses to locate matches.

Inverts only the pixels within tolerancePercent of a target color (the same real Euclidean color-distance check Color Replace uses), leaving every other pixel untouched — distinct from Negative Inverter, which inverts the whole image.

Compares two Semantic Versioning 2.0.0 version strings using the real precedence rules from semver.org §11: major.minor.patch compared numerically first, then a version WITH a pre-release tag is always lower-precedence than the same version without one, then pre-release identifiers are compared left-to-right (numeric identifiers compared numerically and always lower than alphanumeric ones, alphanumeric compared lexically ASCII, a longer identifier set wins if all shared identifiers are equal). Build metadata (+...) never affects precedence.

Converts prose to Sentence case (capitalize the first letter of each sentence) or real Title Case (capitalize every major word, keeping minor words — articles, short prepositions, coordinating conjunctions — lowercase unless they're the first or last word). Distinct from Case Transformer, which targets programming-identifier cases like camelCase/snake_case, not prose styling.

Applies a sepia tone via the canvas context's native filter string (sepia(100%)).

Corrects uneven lighting/shadows via real illumination-estimation: a large box-blur of the grayscale luminance channel (a separable, sliding-window blur — O(width×height), not a naive per-pixel convolution) estimates the slowly-varying background lighting, then each pixel is divided by its own local background estimate and rescaled to a target midtone — a multiplicative correction, not additive subtraction, since real shadows dim proportionally rather than by a fixed amount. strength blends between the original and fully-corrected result.

Flattens each object in a JSON array by exactly one level of nesting — nested object properties become top-level dot-prefixed keys, but any nesting below that stays untouched as-is. Distinct from JSON Flattener, which recurses fully to arbitrary depth.

Read-only: lists every sheet's name plus its row and column count, without opening or modifying any sheet's data. .xlsx only — a CSV/TSV file has exactly one implicit, unnamed sheet.

Combines every sheet within one workbook into a single output sheet, stacking each sheet's rows in order and recording each row's source sheet name in a "_sheet" column — most useful for a multi-sheet XLSX file; a single-sheet CSV/TSV input passes through unchanged.

Renames one or more sheets within an .xlsx workbook. .xlsx only — a CSV/TSV file has exactly one implicit sheet with no stored name to rename, so this tool requires a real multi-sheet-capable format.

Splits one multi-sheet XLSX workbook into N single-sheet .xlsx files, one per sheet, named after each sheet — the reverse of Sheet Merger.

Checks a URL's domain and path shape against known URL-shortener patterns (bit.ly, tinyurl.com, t.co, goo.gl, is.gd, ow.ly, buff.ly, rebrand.ly). This is a format-only check — it does NOT resolve or follow the link to see where it actually goes, since this app makes no network calls at all; a URL matching a shortener's format is not proof of where it leads, only that it looks like one.

Computes a real line-level diff via the classic Longest Common Subsequence dynamic-programming algorithm — not a naive line-by-line equality check, which falls apart the moment one line is inserted or removed and shifts everything after it out of alignment.

Reports every silent stretch in an audio file via ffmpeg's silencedetect filter, parsed straight out of its log output — an info tool only, it does not modify the audio. Use Silence Remover to actually strip the detected silence.

Adds real silence before and/or after an audio file — leading silence via ffmpeg's adelay filter (which genuinely shifts every channel's start later, rather than just changing a duration number) and trailing silence via apad (which appends real silent samples, not just a metadata duration change).

Strips silent stretches from an audio file via ffmpeg's silenceremove filter — silence is any stretch at least minSilenceSec long, quieter than thresholdDb.

A basic single-level pivot: groups rows by one column and aggregates another (sum/count/average) — not a full multi-dimensional pivot engine.

Renders one quick preview image of a single PDF page, scaled to fit within a maximum dimension — distinct from Page Thumbnail Strip, which renders every page as a filmstrip.

Resizes an image to a current platform preset — Instagram feed post (1080x1350, the best-performing 4:5 portrait format as of 2026, since Instagram moved off the square grid), Instagram Story (1080x1920), X/Twitter post (1200x675), Facebook feed post (1080x1350) — verified against each platform's current published guidance rather than assumed from memory, since these specs genuinely change over time. "crop" fills the target exactly (cropping excess); "pad" fits the whole image within the target (letterboxed with a white background).

Inverts each pixel whose luminance exceeds threshold, producing the classic darkroom-solarization look. This is a real per-pixel getImageData loop — no native ctx.filter shortcut produces this effect.

Changes a video's playback speed (0.25×–4×) — video timestamps are scaled directly, and the audio pitch is kept natural by chaining ffmpeg's atempo filter, since atempo itself only accepts a 0.5–2.0 factor per instance. Expects an input with an audio track.

Splits a PDF into two files at its midpoint — the common special case of PDF Split by Range. For an odd page count, the first half gets the smaller share (rounded down) and the second half gets the remainder.

Packs multiple images into one sprite sheet (a uniform grid, cell-sized to the largest input image) and outputs both the sheet PNG and a JSON manifest listing every sprite's exact position and size within it.

Reformats a SQL query with consistent whitespace and casing via the sql-formatter library — hand-rolling SQL tokenization would be a correctness trap.

Flags statistical outliers per numeric column using a real, named method: IQR (values beyond threshold × the interquartile range past Q1/Q3 — 1.5 is the conventional threshold) or z-score (values more than threshold standard deviations from the mean) — not an ad-hoc "far from average" heuristic.

Widens the stereo image via ffmpeg's extrastereo filter (confirmed present in this app's bundled ffmpeg core), which increases the difference between the left and right channels. widthPercent maps directly to extrastereo's own m coefficient (100% = m=1.0, unchanged; higher widens).

Adds a basic sticky-note annotation (a note icon plus text, shown collapsed by default) at an exact position on one page — built via a real /Type /Annot /Subtype /Text dictionary, not a full interactive-annotation system.

Removes common English stopwords using the real, named NLTK English stopwords list (nltk.corpus.stopwords.words('english'), the standard 179-word list most NLP tooling uses as its baseline) — not an ad hoc list invented for this tool. Matching is case-insensitive and word-boundary-based (via Intl.Segmenter word segmentation), so a stopword inside a larger word isn't removed.

Computes the real Levenshtein edit distance between two strings via dynamic programming, expressed both as a raw edit-distance number and as a normalized similarity percentage (1 - distance / longer-string-length).

Burns a .srt/.vtt subtitle file into a video's picture, permanently, via ffmpeg's subtitles filter. Provide one video file and one subtitle file — which is which is detected by extension, not by upload order.

Extracts a video's first embedded subtitle stream as an .srt file — reports a real, named error rather than crashing if the video has no subtitle stream.

Converts between .srt and .vtt subtitle formats via ffmpeg's real, native subtitle demuxer/muxer support — actual timestamp-format (comma vs. period milliseconds) and container-syntax (the WEBVTT header, cue structure) conversion, not just a file extension change. Distinct from Subtitle Burner/Extractor, neither of which converts between subtitle formats.

Strips comments and excess path-data precision from an SVG using real DOM parsing (DOMParser) — regex-stripping a whole SVG file risks corrupting path syntax, so only isolated numeric tokens inside already-DOM-accessed 'd' attributes are touched.

Mirrors one half of the image onto the other, producing a perfectly symmetric result. "horizontal" mirrors left onto right (a vertical line of symmetry); "vertical" mirrors top onto bottom (a horizontal line of symmetry).

Converts leading indentation between tabs and spaces, respecting tabWidth consistently in both directions — tabs-to-spaces expands each leading tab to tabWidth spaces, spaces-to-tabs collapses each run of tabWidth leading spaces back to one tab (a shorter leftover run of fewer than tabWidth spaces is left as spaces, not padded away).

Fills a Mustache-style {{variable}} template (first file) with values from a JSON data file (second file, supporting dot-path keys like user.name). Undefined variables are substituted with an empty string in the output, and named individually in an accompanying warnings report rather than silently ignored.

Speeds up or slows down audio while preserving pitch, via ffmpeg's plain atempo filter — no rubberband dependency. atempo's own documented valid range is 0.5-2.0 per filter instance (values outside that need multiple chained atempo filters), which is exactly the range this tool's tempoFactor is restricted to, so a single filter application always suffices.

Generates a test tone (sine, square, or sawtooth) at a given frequency and duration via ffmpeg's audio-synthesis source filters — sine uses the dedicated `sine` source; square and sawtooth use `aevalsrc` with real, standard per-sample waveform expressions, since ffmpeg has no dedicated generator filter for those two shapes.

Counts characters, words, lines, and sentences using Intl.Segmenter for word/sentence boundaries — naive whitespace/period-splitting under- or over-counts real text (abbreviations, languages with no spaces between words).

Detects a legacy text encoding (trying UTF-8, then Windows-1252) and normalizes it to UTF-8 — browsers can only natively *encode* text as UTF-8 (TextEncoder has no option for legacy encodings), so a target other than UTF-8 is reported as unsupported rather than silently mangled.

Draws text at a free, exact (x, y) pixel position with a chosen font, size, and color — distinct from Watermark Creator (Batch 4), which is limited to five fixed corner/center positions and a reduced-opacity look.

Converts text to International Morse code (letters/digits/common punctuation), space-separated within a word and "/" between words. Characters with no Morse equivalent are passed through as themselves rather than silently dropped.

Reverses a text file by character, word, or line — character reversal uses Intl.Segmenter's grapheme-cluster boundaries, not a raw string reverse, which would corrupt emoji and combining characters.

Grabs a single representative frame at roughly 10% into the video's duration, rather than frame 0 — the very first frame is very often a black/fade-in/blank frame and rarely the frame anyone actually wants as a thumbnail.

Repeats a text watermark in a diagonal tiled pattern across the entire image, spaced spacingPx apart — distinct from Watermark Creator, which places one fixed-position text instance rather than a repeating pattern.

Renders a PNG's transparent areas against a light/dark checkerboard — the standard image-editor convention for showing transparency — and flattens the result into an opaque preview image. Useful for previewing what Transparent Background Remover's output actually looks like without opening it in an editor first.

Makes every pixel within tolerancePercent of a target color fully transparent — the same per-pixel color-distance check as Color Replace, but setting alpha to 0 instead of swapping in a new color. Output is always PNG regardless of the input format, since PNG is the only common format here with real alpha-channel support.

Trims leading/trailing whitespace from every cell, preserving the input's own format (CSV, TSV, or XLSX).

Converts between tab-separated and comma-separated values via SheetJS.

Converts between tab-separated values and JSON, the same shape as CSV ↔ JSON but tab-delimited.

Read-only: counts the real number of distinct RGBA colors in an image via a full getImageData scan (a Set keyed on the packed 32-bit pixel value) — not an estimate or a palette-extractor approximation.

Extracts the distinct values of a given key across a JSON array of objects, preserving first-seen order. Object/array values are deduplicated by their JSON.stringify representation, primitives by value.

Converts between a date/time and a Unix timestamp, timezone-aware in both directions.

Encodes or decodes a text file's content as a URI component.

Parses a URL query string into structured key-value pairs, or builds one from a JSON object of key-value pairs, via the real URLSearchParams API both ways. Repeated keys are handled correctly as arrays in both directions, not silently collapsed to the last value.

Turns a text file's content into a URL slug — diacritics are stripped via Unicode normalization (so "café" becomes "cafe"), not just dropped as unrecognized bytes.

Generates UUIDv4s via crypto.randomUUID(), or ULIDs (a real Crockford-Base32-encoded 48-bit-timestamp + 80-bit-random identifier, per the ULID spec) — not a UUID with dashes stripped and relabeled.

Applies a different speed factor to each of several time segments, filling any gaps with normal speed, and joins the result via the concat demuxer — each segment is independently re-encoded with matching settings so the join is a reliable stream copy, verified end to end rather than assumed to work.

Mirrors every page's content top-to-bottom via a real content-stream transformation matrix (pdf-lib's embedPage transformationMatrix option) — vector content and text stay real and selectable, not rasterized.

Desaturates a video to black & white via ffmpeg's hue filter (hue=s=0, zeroing saturation while leaving luma untouched) — a simple, long-established core filter, not one of the uncertain optional-library cases.

Grabs gridCols × gridRows frames evenly spaced across the video's real, probed duration, and tiles them into one contact-sheet image — frame grabbing is ffmpeg's job, but the tiling reuses this app's own Canvas 2D image I/O helper (the same one Cluster K/D image tools share) rather than doing layout work inside ffmpeg.

Crops a video to a fixed rectangle via ffmpeg's crop filter.

Grabs a single frame at a timestamp, or one frame every N seconds throughout the video, as PNG images.

Repeats a video repeatCount times back-to-back via the ffmpeg concat demuxer — the same stream-copy technique Video Merger/Joiner uses, applied to repeated copies of one file instead of several different ones.

Joins several videos into one via stream copy (the ffmpeg concat demuxer) — works best when every input shares the same codec and resolution; ffmpeg reports a real error if they conflict, rather than producing a silently broken file.

Plays a video backwards via ffmpeg's reverse (video) and areverse (audio) filters, keeping both tracks in sync. Both filters buffer the entire input in memory before writing any output — this is genuinely memory-intensive and can be slow or fail outright on long clips.

Rotates a video clockwise by 90/180/270° using ffmpeg's transpose filter — this actually re-encodes the rotated pixels, rather than just setting a rotation metadata flag some players ignore, so the output displays correctly everywhere.

Reduces shaky handheld camera motion using ffmpeg's deshake filter — a single-pass frame-to-frame motion stabilizer. Not vidstab's two-pass detect/transform technique (vidstab is confirmed absent from this app's bundled ffmpeg core, verified via a real filter-list run, not assumed), but a real, working stabilization pass rather than no stabilization tool at all.

Burns a semi-transparent text watermark into a video via ffmpeg's drawtext filter, using this app's own bundled font file (drawtext needs an explicit fontfile — there's no system font database inside the WASM sandbox to resolve a font name against). drawtext's availability is confirmed via a real captured ffmpeg.exec(['-filters']) run against this project's actual bundled @ffmpeg/core — it's genuinely present, not silently broken.

Generates a tiled sprite sheet of thumbnails grabbed every intervalSec, plus a real WebVTT (RFC-shaped) file mapping each timestamp range to its sprite region via the standard #xywh=x,y,w,h media-fragment syntax — the format video players use for scrubbing-preview thumbnails. Frame grabbing reuses this app's ffmpeg pipeline (like Video Contact Sheet); the tiling and VTT text generation are done in this browser tab.

Converts a video to an animated GIF using two-pass palette generation (palettegen/paletteuse) — a single-pass GIF encode looks visibly worse (banding, a generic 256-color web palette) than one built from a palette optimized for this specific clip.

Cuts a clip out of a video by stream-copying (no re-encode) — fast, but the cut lands on the nearest keyframe rather than an exact frame, since stream copy cannot re-cut mid-frame.

Darkens an image's edges via a radial black gradient composited with globalCompositeOperation = 'multiply' — multiply scales existing pixel values toward black rather than replacing them outright, so a 0-alpha center stop leaves the image's center genuinely untouched instead of just visually similar.

Composes three effects into one aged-photo look, scaled by intensity: a sepia tone (reusing Sepia Filter's ctx.filter technique), a radial multiply vignette (reusing Vignette Effect's gradient technique), and film grain — the one genuinely new piece, added as per-pixel random luminance noise via crypto.getRandomValues().

Rasterizes corresponding pages from two PDFs (pdf.js, the same approach PDF to JPG/PNG uses) and reuses Image Diff Viewer's real pixel-comparison logic on each page pair — a genuinely different comparison from PDF Text Compare (Batch 4), which compares extracted text, not appearance.

A basic left-join-style lookup between two spreadsheet files: for every row in the first file, finds the first matching row in the second (matchColumn == lookupColumn's value) and appends returnColumn's value — select the first file, then the second, in that order.

Boosts audio by a flat gain in dB, or normalizes it with ffmpeg's loudnorm filter (real EBU R128 loudness normalization, not a flat gain multiply — that's not what "normalize" should mean).

Counts vowels, consonants, and other characters in a text file — genuinely distinct from Text Statistics's word/line/sentence focus, a letter-level breakdown instead.

Draws a text watermark over an image at reduced opacity, in one of five positions. Logo-image watermarking is out of scope for this pass — it would need a second input file, which this tool does not yet support.

Renders a static waveform image from an audio file via ffmpeg's own showwavespic filter — option names (size/s, colors) verified against ffmpeg's real filter documentation before use, rather than assumed from a generic 'width/height/color' guess.

Repackages a TTF or OTF font into WOFF2 via wawoff2, a WebAssembly port of Google's own reference woff2 encoder — the SFNT font tables are recompressed as-is (Brotli), not re-authored, so glyph data is unchanged.

Re-encodes a video with a named, sensible resolution + bitrate + container combination tuned for web delivery, real values not arbitrary ones: 'standard' targets 720p at a real, commonly-recommended ~2.5 Mbps H.264 video / 128 kbps AAC audio; 'high' targets 1080p at ~5 Mbps / 192 kbps — both figures within the range YouTube/Vimeo's own published encoding recommendations use for their respective resolutions. Always outputs H.264/AAC in MP4 with -movflags +faststart (the real, standard flag that moves the MP4 moov atom to the front of the file so browser playback can start before the whole file has downloaded).

Records webcam video (with audio) directly to a downloadable file via getUserMedia + MediaRecorder — nothing is uploaded.

Collapses repeated spaces/tabs to one and normalizes line endings consistently to the selected target — never a mix.

Outputs word-frequency data as {text, weight} pairs — the shape most word-cloud visualization libraries (d3-cloud, wordcloud2.js, etc.) expect as input. Reuses Word Frequency Counter's exact same Intl.Segmenter-based counting; the difference is purely the output shape and purpose, not a second counting implementation.

Counts word frequency using Intl.Segmenter for real word-boundary detection, not naive whitespace splitting, and reports the top N.

Wraps text to a maximum line width, breaking only at word boundaries — a single word longer than maxWidth is placed on its own (overlong) line rather than being cut mid-word.

Computes a real word-granularity diff between two text files, reusing Diff Checker's exact same Longest Common Subsequence algorithm — just tokenized into words instead of lines. Distinct from Diff Checker's line-level comparison: a single-word change inside a long line shows as one word added/removed here, instead of the entire line being marked changed.

Parses an English number phrase ("two thousand and five", "negative forty-two") back into an integer — the reverse of Number to Words. Malformed or unrecognized input is a named error listing exactly which word failed, not a best-guess wrong number.

Structurally compares two .xlsx workbooks: sheet names present in only one, row/column counts per shared sheet, and every differing cell value — spreadsheet-native, distinct from JSON Diff Viewer, which compares JSON structures rather than workbook cells.

Checks whether a file is well-formed XML, using the browser's native DOMParser, and reports what's wrong if it isn't.

Converts XML to YAML by parsing through the browser's real DOMParser into the same JSON representation JSON ↔ XML uses (documented array/object convention), then serializing that with the `yaml` package — reusing both existing, tested conversions rather than a third, independent XML→YAML implementation.

Reads a PDF's XMP metadata stream (a separate, XML-based metadata standard from the classic Info dictionary PDF Metadata Viewer covers) via direct low-level stream inspection — pdf-lib has no dedicated XMP API. A PDF with no XMP stream is reported as a normal result, not an error.

Converts between YAML and JSON via the `yaml` library.

Converts YAML to XML by parsing with the `yaml` package into the same JSON representation JSON ↔ XML uses (documented array/object convention), then serializing that with the browser's real XMLSerializer — reusing both existing, tested conversions rather than a third, independent YAML→XML implementation.