Text Sorter

Introduction:

Text lists become easier to reuse when order, spacing, and separators are consistent. Sorting sounds simple until numbers, accents, articles, duplicate lines, and pasted whitespace start changing what "correct order" actually means. This tool is built for that practical cleanup work.

It is useful when you have a list of filenames, titles, tags, codes, or notes and need a predictable output string rather than another round of manual editing. The package can reorder items alphabetically or naturally, reverse the current sequence, rank by length, or shuffle the list, while also trimming, filtering, numbering, and rejoining the results for whatever comes next.

A familiar example is a copied file list such as `File10`, `File2`, and `File1`. Plain alphabetical comparison often puts `File10` before `File2`, because it compares characters one by one. Natural comparison treats the digit runs as numbers instead, which produces the order most people expect when scanning filenames, versions, or item labels.

The tool also helps when the list is messy rather than merely unsorted. Blank lines, repeated entries, ordered-list prefixes, uneven spacing, and leading articles in titles can all be cleaned before the final output string is assembled. That makes it useful for quick editorial cleanup, data-prep passes, or turning a rough note dump into something safe to paste into a document or script.

What it does not do is act like a full record parser. A `.csv` file is read as plain text and then split by the separator rules you choose, so quoted commas and multi-column table structure are outside the scope of this package. It works best on single-column lists or token streams where each item can be treated as standalone text.

Everyday Use & Decision Guide:

For most lists, the first useful pass is conservative: paste the text, match the `Input separator` to the source, choose `Alphabetical (A-Z)` or `Natural (A-Z)`, and enable `Ignore blank lines` plus `Trim each line` if the source came from email, chat, or a spreadsheet export. That usually removes the noise before you make harder judgment calls about duplicates or locale-specific ordering.

The tool is a strong fit for one-item-per-line cleanup, ad hoc token lists, and filename or title sorting. It is a poor fit for structured CSV records with quoted separators, because the split stage is intentionally simple text splitting rather than full CSV parsing.

• Leave `Locale` blank unless you need a specific language rule. A fixed locale is useful for reproducible team output, but it can change the order of accented letters.
• Use `Natural (A-Z)` for names with embedded numbers such as `File2`, `photo12`, or `item100`. Plain alphabetical mode will compare those digit runs as text instead.
• `Unique` removes duplicates after cleanup and sorting. If `Case sensitive` is off, lines that differ only by case collapse to one item.
• `Ignore leading articles` changes the comparison key, not the displayed text. Titles still come out with `A`, `An`, or `The` intact.
• If the red `Invalid regex` message appears, the list is still processed without the regex filter until the pattern is fixed.

A good final check is to compare `Sorted Output` with the summary badges. If the item count, unique count, sort mode, and locale badge match what you intended, you are usually ready to copy or export.

Technical Details:

Text sorting is really a question of collation, which means the rule used to compare strings. In this package, alphabetical modes use language-sensitive string comparison, and natural modes enable numeric collation so digit runs are compared by value instead of one character at a time. That is why `File2` can sort before `File10`, even though a plain lexical pass would see `1` before `2` and keep `File10` earlier.

The `Locale` field is intended for BCP 47 language tags such as `en-US`, `fr`, or `de`. If the entered tag cannot be used, the code falls back to the browser default. `Case sensitive` changes both the collator sensitivity used for ordering and the simpler substring checks used by include or exclude filtering and duplicate removal, so the same toggle affects more than one stage of the pipeline.

Order of operations matters here. The source text is split first, then each item can be trimmed, stripped of leading list numbers, and normalized for internal whitespace. Blank-line removal and plain-text include or exclude filters happen before sorting. Regex include filtering, when enabled, runs after that cleanup stage. Sorting, reversing, or shuffling comes next, and duplicate removal happens afterward. Only then are optional line numbers, prefixes, suffixes, and the chosen output joiner applied.

Seeded shuffle is implemented as a deterministic shuffle pass driven by a 32-bit seed derived from the supplied text. That makes it useful for repeatable editorial or workflow ordering, because the same input and the same seed recreate the same sequence. It should not be treated as a cryptographic draw or an audit-grade randomization method.

Decoration happens after ordering. When `Line numbers` is enabled, numbers are zero-padded to the width of the final item count. Prefixes and suffixes are then attached to each item, and the list is joined with the selected `Output separator`. `Newline style` matters only when the joiner itself is newline; if you switch the output separator to comma, semicolon, space, or tab, the newline setting has no effect on the exported text.

The four output surfaces describe different stages of the same run, which is why their numbers do not always match exactly. `Sorted Output` is the final decorated string. `Text Stats` combines raw-input counts with processed-output counts. `Character Counts` measures the sorted item list before numbering, prefixes, suffixes, and final joining. `JSON` records the settings and the processed `output` array, which means it is good for auditing the run but not identical to the final pasted text when decorations are enabled.

Files are read locally in the browser and newlines are normalized on load. No network request is required for sorting, statistics, counts, copying, or downloads. A dropped or uploaded `.txt` or `.csv` file is simply another source of plain text for the same pipeline.

Step-by-Step Guide:

This flow gives you a clean output without guessing which setting changed the list.

1. Paste the source into `Text`, or use `Upload file` to load a `.txt` or `.csv` file. Dropped files are read locally and newlines are normalized automatically.
2. Set `Input separator` to match the source. Use `New Line` for one-item-per-line lists and switch to comma, semicolon, space, or tab only when the source is truly token-based.
3. Choose `Sort mode`. `Natural (A-Z)` is the safest first pass for filenames and version-like labels, `Alphabetical` is best for plain words, and `Shuffle` plus `Shuffle seed` is the path for repeatable randomized order.
4. Open `Advanced` and apply cleanup toggles such as `Trim each line`, `Ignore blank lines`, `Unique`, `Ignore leading articles`, `Line numbers`, `Prefix to add`, and `Suffix to add`.
5. If you need filtering, use `Include only items containing`, `Exclude items containing`, or turn on `Regex filter`. If `Invalid regex` appears under `Pattern`, fix the pattern or `Flags` before trusting the filtered set.
6. Read `Sorted Output` first. It shows the exact text that `Copy Sorted` and `Download Sorted` will export, including numbering, affixes, and the selected joiner.
7. Open `Text Stats`, `Character Counts`, or `JSON` when you need counts, audit detail, or a machine-friendly array, then export from the tab that matches the job.

When the final text looks right in `Sorted Output` and the badges reflect the sort mode and locale you meant to use, the run is ready to leave the page.

Interpreting Results:

Treat `Sorted Output` as the authoritative final text. It is the only surface that includes zero-padded line numbers, prefixes, suffixes, and the chosen output separator in one place.

• `Text Stats` combines raw-source counts with processed counts, so it tells you how much cleanup changed the list rather than how the final pasted string is decorated.
• `Character Counts` measures the sorted item list before numbering, prefixes, suffixes, and final joining. It is useful for size checks, but it is not a byte-for-byte description of `Sorted Output`.
• `JSON` is an audit of settings and processed items, not a mirror of the decorated output text. If you need the exact pasted string, use `Sorted Output` instead.
• Locale-sensitive ordering can change the placement of accented letters, and unseeded shuffle cannot be reproduced exactly. If those details matter, verify a few edge items before copying the result.

When reproducibility matters, save the output together with the chosen `Locale`, the `Case sensitive` setting, and any `Shuffle seed` you used.

Worked Examples:

FAQ:

Glossary:

Collation

The rule set used to compare strings for ordering.

Natural sort

String ordering that treats embedded digit runs as numeric values.

BCP 47 tag

A locale identifier such as `en-US` or `de`.

Seeded shuffle

A reproducible randomized order driven by the same seed text.

References:

• ECMAScript Internationalization API Specification, `Intl.Collator`, TC39 / ECMA-402.
• RFC 5646: Tags for Identifying Languages, IETF, September 2009.
• Unicode Collation, Unicode Consortium.