# Tools

350 deterministic tools in 15 categories. Free, no key needed. Each page shows the contract, an example and how to call it over MCP, HTTP or the CLI.

- [CSV & tables](#csv) (29)
- [YAML, TOML, INI, XML & TSV](#formats) (10)
- [JSON & JSONL](#json) (31)
- [Text](#text) (34)
- [Sequences & diffs](#sequences) (10)
- [Dates & times (UTC, ISO 8601)](#dates) (44)
- [Numbers & math](#math) (58)
- [Vectors & matrices](#linear-algebra) (27)
- [Units & sizes](#units) (11)
- [Graphs & scheduling](#graphs) (20)
- [File paths (lexical)](#paths) (20)
- [Forms](#forms) (6)
- [Encoding & checksums](#encoding) (8)
- [URLs & IP addresses](#web) (35)
- [Versions & config](#versions) (7)

## CSV & tables

Convert, join, filter, sort, reconcile and compare CSV tables.

- [CSV abs integer column](/tools/csv-abs-integer-column) `csv-abs-integer-column`: Replace every data cell in a named CSV column with the absolute value of a canonical integer.
- [CSV add row number](/tools/csv-add-row-number) `csv-add-row-number`: Prepend a 1-based row_number column of canonical integer strings.
- [CSV anti join](/tools/csv-anti-join) `csv-anti-join`: Keep left CSV rows whose exact key tuples do not appear in the right document.
- [CSV clamp integer column](/tools/csv-clamp-integer-column) `csv-clamp-integer-column`: Clamp every data cell in a named CSV column to optional canonical integer min and max bounds.
- [CSV concat](/tools/csv-concat) `csv-concat`: Concatenate CSV documents that share identical headers, preserving document and row order.
- [CSV dedupe](/tools/csv-dedupe) `csv-dedupe`: Remove duplicate CSV data rows while preserving the first occurrence.
- [CSV distinct values](/tools/csv-distinct-values) `csv-distinct-values`: List distinct exact values of one CSV column in first-seen order.
- [CSV drop columns](/tools/csv-drop-columns) `csv-drop-columns`: Drop named CSV columns and keep the remaining columns in original header order.
- [CSV fill defaults](/tools/csv-fill-defaults) `csv-fill-defaults`: Replace empty cells in named CSV columns with exact default strings.
- [CSV filter empty](/tools/csv-filter-empty) `csv-filter-empty`: Keep or drop CSV rows whose named column is the empty string.
- [CSV filter equals](/tools/csv-filter-equals) `csv-filter-equals`: Keep CSV data rows whose named column equals an exact string.
- [CSV group count](/tools/csv-group-count) `csv-group-count`: Count CSV rows by exact named-column tuples in first-seen order.
- [CSV inner join](/tools/csv-inner-join) `csv-inner-join`: Inner join two CSV documents on exact named key columns.
- [CSV left join](/tools/csv-left-join) `csv-left-join`: Left join two CSV documents on exact named key columns.
- [CSV merge columns](/tools/csv-merge-columns) `csv-merge-columns`: Join named CSV columns with an exact separator into one column.
- [CSV min max integers](/tools/csv-min-max-integers) `csv-min-max-integers`: Minimum and maximum of a CSV column of strict signed base-10 integer strings.
- [CSV reconcile](/tools/csv-reconcile) `csv-reconcile`: Reconcile two CSV documents by key columns, reporting full population totals and bounded samples for added, removed, changed, invalid-key, and ambiguous rows.
- [CSV rename columns](/tools/csv-rename-columns) `csv-rename-columns`: Rename CSV headers by an exact from/to mapping, preserving row cells and column order.
- [CSV replace exact](/tools/csv-replace-exact) `csv-replace-exact`: Replace CSV data cells whose entire value equals an exact find string.
- [CSV row diff](/tools/csv-row-diff) `csv-row-diff`: Compare two CSV documents with identical headers by unique key tuples and report added, removed, and changed rows.
- [CSV scale integer column](/tools/csv-scale-integer-column) `csv-scale-integer-column`: Multiply every data cell in a named CSV column by a canonical integer factor.
- [CSV schema check](/tools/csv-schema-check) `csv-schema-check`: Validate a CSV document against an ordered column list and per-column string constraints.
- [CSV select columns](/tools/csv-select-columns) `csv-select-columns`: Select and reorder exact named columns from a complete CSV document.
- [CSV slice rows](/tools/csv-slice-rows) `csv-slice-rows`: Take a contiguous window of CSV data rows by offset and limit, keeping the header.
- [CSV sort](/tools/csv-sort) `csv-sort`: Stably sort CSV rows by exact named string columns.
- [CSV split column](/tools/csv-split-column) `csv-split-column`: Split one CSV column on an exact separator into uniquely named columns.
- [CSV sum integers](/tools/csv-sum-integers) `csv-sum-integers`: Sum a CSV column of strict signed base-10 integer strings using BigInt.
- [CSV to JSON](/tools/csv-to-json) `csv-to-json`: Convert a complete CSV document into an array of string-valued objects.
- [CSV transpose](/tools/csv-transpose) `csv-transpose`: Transpose a CSV matrix including the header row, then re-validate headers.

## YAML, TOML, INI, XML & TSV

Convert YAML, TOML, INI, XML and TSV documents to and from JSON, with explicit rejections.

- [INI to JSON](/tools/ini-to-json) `ini-to-json`: Convert an INI string to a JSON object.
- [JSON to INI](/tools/json-to-ini) `json-to-ini`: Convert JSON data to an INI string.
- [JSON to TOML](/tools/json-to-toml) `json-to-toml`: Convert JSON data to a TOML string.
- [JSON to TSV](/tools/json-to-tsv) `json-to-tsv`: Convert a JSON array of objects to a TSV string.
- [JSON to XML](/tools/json-to-xml) `json-to-xml`: Convert JSON data to an XML string.
- [JSON to YAML](/tools/json-to-yaml) `json-to-yaml`: Convert JSON data to a YAML string.
- [TOML to JSON](/tools/toml-to-json) `toml-to-json`: Convert a TOML string to a JSON object.
- [TSV to JSON](/tools/tsv-to-json) `tsv-to-json`: Convert a complete TSV document into an array of string-valued objects.
- [XML to JSON](/tools/xml-to-json) `xml-to-json`: Convert an XML string to a JSON object.
- [YAML to JSON](/tools/yaml-to-json) `yaml-to-json`: Convert a YAML string to a JSON object or array.

## JSON & JSONL

Diff, patch, query, join, group and validate JSON documents and arrays.

- [Array to JSONL](/tools/array-to-jsonl) `array-to-jsonl`: Serialize an array of JSON-safe values as JSON Lines text.
- [JSON array anti join](/tools/json-array-anti-join) `json-array-anti-join`: Anti join two JSON arrays of objects on exact keys.
- [JSON array concat](/tools/json-array-concat) `json-array-concat`: Concatenate multiple JSON arrays of objects into one.
- [JSON array count](/tools/json-array-count) `json-array-count`: Count structural occurrences in a JSON array in first-seen order.
- [JSON array distinct by](/tools/json-array-distinct-by) `json-array-distinct-by`: Deduplicate a JSON array of objects based on specific keys.
- [JSON array drop keys](/tools/json-array-drop-keys) `json-array-drop-keys`: Remove specific keys from each object in a JSON array.
- [JSON array filter equals](/tools/json-array-filter-equals) `json-array-filter-equals`: Filter JSON array objects where a key equals a specific value.
- [JSON array group by](/tools/json-array-group-by) `json-array-group-by`: Group an array of JSON objects by exact keys.
- [JSON array group count](/tools/json-array-group-count) `json-array-group-count`: Group an array of JSON objects by exact keys and return the count.
- [JSON array index by](/tools/json-array-index-by) `json-array-index-by`: Convert an array of objects into a single object indexed by a specific key.
- [JSON array inner join](/tools/json-array-inner-join) `json-array-inner-join`: Inner join two JSON arrays of objects on exact keys.
- [JSON array left join](/tools/json-array-left-join) `json-array-left-join`: Left join two JSON arrays of objects on exact keys.
- [JSON array project](/tools/json-array-project) `json-array-project`: Select specific keys from each object in a JSON array.
- [JSON array rename keys](/tools/json-array-rename-keys) `json-array-rename-keys`: Rename specific keys in each object in a JSON array.
- [JSON array sort objects](/tools/json-array-sort-objects) `json-array-sort-objects`: Stably sort an array of objects by explicit string keys using UTF-16 lexicographic order.
- [JSON array unique](/tools/json-array-unique) `json-array-unique`: Deduplicate a JSON array by structural equality, keeping first-seen order.
- [JSON canonical serialize](/tools/json-canonical-serialize) `json-canonical-serialize`: Serialize a JSON value to deterministic compact text with sorted object keys and safe integers only.
- [JSON deep diff](/tools/json-deep-diff) `json-deep-diff`: Bounded deterministic JSON difference records. Not a JSON Patch implementation.
- [JSON deep equal](/tools/json-deep-equal) `json-deep-equal`: JSON-only structural equality. Object key order does not matter; array order does.
- [JSON flatten](/tools/json-flatten) `json-flatten`: Flatten a JSON value into a null-prototype map keyed by RFC 6901 JSON Pointers.
- [JSON merge patch](/tools/json-merge-patch) `json-merge-patch`: Apply an RFC 7396 JSON Merge Patch to a JSON value.
- [JSON omit pointers](/tools/json-omit-pointers) `json-omit-pointers`: Deep-clone JSON and delete values at explicit RFC 6901 pointers.
- [JSON pick pointers](/tools/json-pick-pointers) `json-pick-pointers`: Pick cloned JSON values at explicit RFC 6901 pointers into a null-prototype map.
- [JSON pointer get](/tools/json-pointer-get) `json-pointer-get`: Return the cloned JSON value at an RFC 6901 pointer.
- [JSON pointer has](/tools/json-pointer-has) `json-pointer-has`: Return whether an RFC 6901 pointer exists as an own path.
- [JSON pointer list](/tools/json-pointer-list) `json-pointer-list`: List RFC 6901 pointers to every reachable JSON node, root first.
- [JSON schema validate](/tools/json-schema-validate) `json-schema-validate`: Validate a JSON instance against ComputeFirst Schema 1.0.
- [JSON to CSV](/tools/json-to-csv) `json-to-csv`: Serialize string-valued JSON rows to CSV using explicit ordered columns.
- [JSON unflatten](/tools/json-unflatten) `json-unflatten`: Reconstruct a JSON value from a map of RFC 6901 JSON Pointers to leaves.
- [JSONL to array](/tools/jsonl-to-array) `jsonl-to-array`: Parse strict JSON Lines text into an array of JSON-safe values.
- [JSONL validate](/tools/jsonl-validate) `jsonl-validate`: Validate strict JSON Lines text and report the value count and UTF-8 byte length.

## Text

Compare texts, work with lines, patches, merges and Unicode details.

- [Text apply unified patch](/tools/text-apply-unified-patch) `text-apply-unified-patch`: Apply a one-file unified patch to text at original line addresses with exact hunk matches.
- [Text conflict parse](/tools/text-conflict-parse) `text-conflict-parse`: Parse merge or diff3 conflict-marker text into ordered text and conflict parts.
- [Text conflict render](/tools/text-conflict-render) `text-conflict-render`: Render text and conflict parts as merge or diff3 conflict-marker text.
- [Text control characters find](/tools/text-control-characters-find) `text-control-characters-find`: Find non-whitespace control characters in a text string.
- [Text count](/tools/text-count) `text-count`: Count Unicode code points, UTF-16 code units, UTF-8 bytes, and lines.
- [Text diff stats](/tools/text-diff-stats) `text-diff-stats`: Summarize a line-record diff as keep, insert, delete, and hunk counts.
- [Text extract between](/tools/text-extract-between) `text-extract-between`: Extract exact substrings between start and end markers, left to right and non-overlapping.
- [Text indentation detect](/tools/text-indentation-detect) `text-indentation-detect`: Detect whether a text uses tabs or spaces for indentation by counting lines.
- [Text invert unified patch](/tools/text-invert-unified-patch) `text-invert-unified-patch`: Invert a one-file unified patch by swapping file names and delete/insert ops.
- [Text line diff](/tools/text-line-diff) `text-line-diff`: Diff two texts as line records, preserving each line terminator.
- [Text line endings normalize](/tools/text-line-endings-normalize) `text-line-endings-normalize`: Normalize all line endings in a text to a specific format (LF, CRLF, or CR).
- [Text lines chunk](/tools/text-lines-chunk) `text-lines-chunk`: Split parsed lines into consecutive chunks of size lines each.
- [Text lines count](/tools/text-lines-count) `text-lines-count`: Count exact line multiplicities in first-seen order.
- [Text lines difference](/tools/text-lines-difference) `text-lines-difference`: Set difference a minus b using exact line equality.
- [Text lines head](/tools/text-lines-head) `text-lines-head`: Return the first n parsed lines with LF reconstruction.
- [Text lines intersection](/tools/text-lines-intersection) `text-lines-intersection`: Set intersection of two line sequences using exact line equality.
- [Text lines multiset subtract](/tools/text-lines-multiset-subtract) `text-lines-multiset-subtract`: Multiset subtract b from a: remaining counts, first-seen order from a.
- [Text lines multiset union](/tools/text-lines-multiset-union) `text-lines-multiset-union`: Multiset sum of two line bags: counts add, first-seen order from a then new from b.
- [Text lines tail](/tools/text-lines-tail) `text-lines-tail`: Return the last n parsed lines with LF reconstruction.
- [Text lines unique](/tools/text-lines-unique) `text-lines-unique`: Remove exact duplicate lines, keeping first-seen order.
- [Text NFC](/tools/text-nfc) `text-nfc`: Normalize Unicode text to NFC (canonical composition).
- [Text NFD](/tools/text-nfd) `text-nfd`: Normalize Unicode text to NFD (canonical decomposition).
- [Text parse unified patch](/tools/text-parse-unified-patch) `text-parse-unified-patch`: Parse a one-file unified patch into path names and 0-based hunks.
- [Text prefix suffix check](/tools/text-prefix-suffix-check) `text-prefix-suffix-check`: Exact prefix and/or suffix boolean checks using JS string startsWith/endsWith.
- [Text replace exact](/tools/text-replace-exact) `text-replace-exact`: Replace exact UTF-16 substrings without regex, case folding, or Unicode normalization.
- [Text slice codepoints](/tools/text-slice-codepoints) `text-slice-codepoints`: Slice a string by Unicode code-point indexes, not UTF-16 code units.
- [Text split exact](/tools/text-split-exact) `text-split-exact`: Split text on an exact literal separator and reject results that exceed max_parts.
- [Text strip BOM](/tools/text-strip-bom) `text-strip-bom`: Remove one leading U+FEFF byte-order mark from a Unicode string.
- [Text tabs to spaces](/tools/text-tabs-to-spaces) `text-tabs-to-spaces`: Convert tab characters to spaces.
- [Text three way merge](/tools/text-three-way-merge) `text-three-way-merge`: Three-way merge of text line records with merge or diff3 conflict markers.
- [Text trailing whitespace trim](/tools/text-trailing-whitespace-trim) `text-trailing-whitespace-trim`: Remove trailing whitespace from each line in a text.
- [Text unicode normalization check](/tools/text-unicode-normalization-check) `text-unicode-normalization-check`: Check if a text string is in various Unicode normalization forms (NFC, NFD, NFKC, NFKD).
- [Text unified diff](/tools/text-unified-diff) `text-unified-diff`: Emit a one-file unified diff of two texts with comma counts and LF document breaks.
- [Text word diff](/tools/text-word-diff) `text-word-diff`: Diff two texts as whitespace versus non-whitespace word tokens.

## Sequences & diffs

Edit scripts, longest common subsequences, hunks and three-way merges.

- [Sequence apply edit script](/tools/sequence-apply-edit-script) `sequence-apply-edit-script`: Apply a keep/delete/insert edit script to a bounded sequence with exact value matching and no fuzz.
- [Sequence apply hunks](/tools/sequence-apply-hunks) `sequence-apply-hunks`: Apply disjoint original-address sequence hunks with exact context and no fuzz.
- [Sequence compose edit scripts](/tools/sequence-compose-edit-scripts) `sequence-compose-edit-scripts`: Compose two sequence edit scripts into one per-item keep/delete/insert script.
- [Sequence diff hunks](/tools/sequence-diff-hunks) `sequence-diff-hunks`: Group a Myers sequence edit script into context hunks with 0-based original addresses.
- [Sequence edit script](/tools/sequence-edit-script) `sequence-edit-script`: Compute the Myers shortest edit script between two bounded sequences, with keep/delete/insert counts.
- [Sequence index map](/tools/sequence-index-map) `sequence-index-map`: Map each left-sequence index to a kept right index, or null if deleted, and list inserted right indices.
- [Sequence invert hunks](/tools/sequence-invert-hunks) `sequence-invert-hunks`: Invert sequence hunks by swapping delete/insert and old/new counts.
- [Sequence LCS](/tools/sequence-lcs) `sequence-lcs`: Compute the longest common subsequence of two bounded sequences from the Myers shortest edit script.
- [Sequence longest common substring](/tools/sequence-lcsubstring) `sequence-lcsubstring`: Find the longest contiguous common subarray of two bounded sequences.
- [Sequence three way merge](/tools/sequence-three-way-merge) `sequence-three-way-merge`: Three-way merge two sequence descendants against a shared base into clean or conflict regions.

## Dates & times (UTC, ISO 8601)

Add, compare and bucket ISO 8601 dates and UTC timestamps.

- [Duration add](/tools/duration-add) `duration-add`: Sum mixed SI duration terms in nanoseconds and return the exact rational in a target unit.
- [Duration compare](/tools/duration-compare) `duration-compare`: Compare two SI duration amounts after converting both to nanoseconds.
- [Duration convert](/tools/duration-convert) `duration-convert`: Convert a canonical integer duration between nanosecond-based SI units as an exact rational.
- [ISO date add](/tools/iso-date-add) `iso-date-add`: Add a signed whole-day delta to a strict YYYY-MM-DD calendar date.
- [ISO date add months](/tools/iso-date-add-months) `iso-date-add-months`: Add a signed month count to a YYYY-MM-DD date, clamping the day to the target month.
- [ISO date add years](/tools/iso-date-add-years) `iso-date-add-years`: Add a signed whole-year delta to a YYYY-MM-DD date, clamping the day if 29 February has no match.
- [ISO date age](/tools/iso-date-age) `iso-date-age`: Compute the calendar-aware elapsed years, months, and days between a birth date and an as-of date.
- [ISO date business day add](/tools/iso-date-business-day-add) `iso-date-business-day-add`: Add a signed count of business days to a date, skipping caller-supplied weekend weekdays and holidays.
- [ISO date business days count](/tools/iso-date-business-days-count) `iso-date-business-days-count`: Count the business days in an inclusive date range, skipping caller-supplied weekend weekdays and holidays.
- [ISO date clamp](/tools/iso-date-clamp) `iso-date-clamp`: Clamp a YYYY-MM-DD calendar date into an inclusive [min, max] range.
- [ISO date compare](/tools/iso-date-compare) `iso-date-compare`: Compare two YYYY-MM-DD calendar dates and return -1, 0, or 1.
- [ISO date day of year](/tools/iso-date-day-of-year) `iso-date-day-of-year`: Return the ordinal day number (1-366) of a YYYY-MM-DD date within its calendar year.
- [ISO date days in month](/tools/iso-date-days-in-month) `iso-date-days-in-month`: Return the number of calendar days in a given proleptic Gregorian year and month.
- [ISO date difference](/tools/iso-date-difference) `iso-date-difference`: Whole days from start to end as a canonical integer string (end - start).
- [ISO date from day of year](/tools/iso-date-from-day-of-year) `iso-date-from-day-of-year`: Convert a calendar year and ordinal day number (1-366) to a YYYY-MM-DD date.
- [ISO date is business day](/tools/iso-date-is-business-day) `iso-date-is-business-day`: Test whether a date is a business day given caller-supplied weekend weekdays and holiday dates.
- [ISO date is leap year](/tools/iso-date-is-leap-year) `iso-date-is-leap-year`: Test whether a proleptic Gregorian calendar year is a leap year.
- [ISO date last weekday of month](/tools/iso-date-last-weekday-of-month) `iso-date-last-weekday-of-month`: Return the date of the last occurrence of an ISO weekday within a calendar month.
- [ISO date min max](/tools/iso-date-min-max) `iso-date-min-max`: Return the earliest and latest date in a non-empty array of YYYY-MM-DD calendar dates.
- [ISO date month end](/tools/iso-date-month-end) `iso-date-month-end`: Return the last valid calendar day of the year-month of a YYYY-MM-DD date.
- [ISO date month start](/tools/iso-date-month-start) `iso-date-month-start`: Return the first calendar day of the year-month of a YYYY-MM-DD date.
- [ISO date next weekday](/tools/iso-date-next-weekday) `iso-date-next-weekday`: Return the next date on or after a given date that falls on a specified ISO weekday.
- [ISO date nth weekday of month](/tools/iso-date-nth-weekday-of-month) `iso-date-nth-weekday-of-month`: Return the date of the nth occurrence of an ISO weekday within a calendar month.
- [ISO date observed shift](/tools/iso-date-observed-shift) `iso-date-observed-shift`: Shift a date forward or backward until it lands on a day that is neither a weekend nor a caller-supplied holiday.
- [ISO date previous weekday](/tools/iso-date-previous-weekday) `iso-date-previous-weekday`: Return the most recent date on or before a given date that falls on a specified ISO weekday.
- [ISO date quarter bounds](/tools/iso-date-quarter-bounds) `iso-date-quarter-bounds`: Return the calendar quarter number and the first/last dates of the quarter containing a date.
- [ISO date range contains](/tools/iso-date-range-contains) `iso-date-range-contains`: Test whether an inclusive [start, end] date range contains a given date.
- [ISO date range intersect](/tools/iso-date-range-intersect) `iso-date-range-intersect`: Compute the intersection of two inclusive [start, end] date ranges.
- [ISO date range list](/tools/iso-date-range-list) `iso-date-range-list`: Enumerate the dates in an inclusive [start, end] range stepped by a whole number of days.
- [ISO date range overlap](/tools/iso-date-range-overlap) `iso-date-range-overlap`: Test whether two inclusive [start, end] date ranges share at least one day.
- [ISO date range split by month](/tools/iso-date-range-split-by-month) `iso-date-range-split-by-month`: Split an inclusive [start, end] date range into per-calendar-month sub-ranges.
- [ISO date range union](/tools/iso-date-range-union) `iso-date-range-union`: Merge overlapping or day-adjacent inclusive [start, end] date ranges into the fewest equivalent ranges.
- [ISO date sort](/tools/iso-date-sort) `iso-date-sort`: Stable-sort an array of YYYY-MM-DD calendar dates.
- [ISO date to week](/tools/iso-date-to-week) `iso-date-to-week`: Convert a YYYY-MM-DD calendar date to an ISO-8601 week date.
- [ISO date week bounds](/tools/iso-date-week-bounds) `iso-date-week-bounds`: Return the Monday and Sunday of the ISO-8601 week that contains a calendar date.
- [ISO date week count in year](/tools/iso-date-week-count-in-year) `iso-date-week-count-in-year`: Return the number of ISO-8601 weeks (52 or 53) in an ISO week-numbering year.
- [ISO date weekday](/tools/iso-date-weekday) `iso-date-weekday`: ISO-8601 weekday number of a strict YYYY-MM-DD date (Monday=1 ... Sunday=7).
- [ISO date weekday occurrences in range](/tools/iso-date-weekday-occurrences-in-range) `iso-date-weekday-occurrences-in-range`: List every date within an inclusive date range that falls on a given ISO weekday.
- [ISO date-time add seconds](/tools/iso-datetime-add-seconds) `iso-datetime-add-seconds`: Add a signed whole-second delta to a strict UTC ISO-8601 datetime.
- [ISO date-time clamp](/tools/iso-datetime-clamp) `iso-datetime-clamp`: Clamp a strict UTC ISO-8601 datetime into an inclusive [min, max] range.
- [ISO date-time compare](/tools/iso-datetime-compare) `iso-datetime-compare`: Compare two strict UTC ISO-8601 datetimes and return -1, 0, or 1.
- [ISO date-time diff seconds](/tools/iso-datetime-diff-seconds) `iso-datetime-diff-seconds`: Return the signed whole-second difference between two strict UTC ISO-8601 datetimes.
- [ISO date-time truncate](/tools/iso-datetime-truncate) `iso-datetime-truncate`: Truncate a strict UTC ISO-8601 datetime toward UTC zero at day, hour, minute, or second.
- [ISO week to date](/tools/iso-week-to-date) `iso-week-to-date`: Convert an ISO-8601 week date to a YYYY-MM-DD calendar date.

## Numbers & math

Exact integer, decimal and rational arithmetic, statistics and intervals.

- [Angle DMS convert](/tools/angle-dms-convert) `angle-dms-convert`: Convert a signed integer angle between degrees, arcminutes, and arcseconds as an exact rational.
- [Array integer adjacent diff](/tools/array-integer-adjacent-diff) `array-integer-adjacent-diff`: Replace an array of canonical integer strings with consecutive first differences.
- [Array integer clamp](/tools/array-integer-clamp) `array-integer-clamp`: Clamp an array of canonical integer strings to optional inclusive min and max bounds.
- [Array integer cumulative sum](/tools/array-integer-cumulative-sum) `array-integer-cumulative-sum`: Replace an array of canonical integer strings with equal-length prefix sums.
- [Array integer GCD](/tools/array-integer-gcd) `array-integer-gcd`: Compute the non-negative greatest common divisor of an array of canonical integer strings.
- [Array integer LCM](/tools/array-integer-lcm) `array-integer-lcm`: Compute the non-negative least common multiple of an array of canonical integer strings.
- [Array integer median](/tools/array-integer-median) `array-integer-median`: Select lower and upper middle canonical integers; emit median only for odd length.
- [Array integer min max](/tools/array-integer-min-max) `array-integer-min-max`: Return the numeric minimum and maximum of canonical integer strings.
- [Array integer mode](/tools/array-integer-mode) `array-integer-mode`: Return the most frequent canonical integers, listing every mode in first-seen order.
- [Array integer product](/tools/array-integer-product) `array-integer-product`: Multiply an array of canonical integer strings and return the canonical product.
- [Array integer ranks](/tools/array-integer-ranks) `array-integer-ranks`: Assign competition (1224) ranks to canonical integers; ties share the minimum rank.
- [Array integer sum](/tools/array-integer-sum) `array-integer-sum`: Sum an array of canonical integer strings and return the canonical total.
- [Array rational mean](/tools/array-rational-mean) `array-rational-mean`: Return the reduced arithmetic mean of an array of canonical rationals.
- [Array rational min max](/tools/array-rational-min-max) `array-rational-min-max`: Return the reduced numeric minimum and maximum of an array of canonical rationals.
- [Array rational sum](/tools/array-rational-sum) `array-rational-sum`: Sum an array of canonical rationals and return the reduced total.
- [Decimal add](/tools/decimal-add) `decimal-add`: Exact decimal addition of canonicalizable decimal strings.
- [Decimal compare](/tools/decimal-compare) `decimal-compare`: Compare two decimal strings exactly after canonicalization.
- [Decimal subtract](/tools/decimal-subtract) `decimal-subtract`: Exact decimal subtraction a minus b of canonicalizable decimal strings.
- [Integer add](/tools/integer-add) `integer-add`: Add two canonical signed integer strings and return their canonical sum.
- [Integer base convert](/tools/integer-base-convert) `integer-base-convert`: Convert a signed integer string between bases 2 and 36 using BigInt.
- [Integer binomial coefficient](/tools/integer-binomial-coefficient) `integer-binomial-coefficient`: Compute the exact binomial coefficient C(n, k), the number of ways to choose k items from n.
- [Integer catalan number](/tools/integer-catalan-number) `integer-catalan-number`: Compute the nth Catalan number exactly.
- [Integer compare](/tools/integer-compare) `integer-compare`: Compare two canonical signed base-10 integer strings using BigInt.
- [Integer CRT](/tools/integer-crt) `integer-crt`: Solve a system of integer congruences (x ≡ remainder mod modulus) with the Chinese Remainder Theorem.
- [Integer derangements count](/tools/integer-derangements-count) `integer-derangements-count`: Compute !n, the number of derangements (permutations with no fixed point) of n items, exactly.
- [Integer digit sum](/tools/integer-digit-sum) `integer-digit-sum`: Sum the base-b digits of the magnitude of an integer string.
- [Integer digital root](/tools/integer-digital-root) `integer-digital-root`: Repeatedly sum the base-b digits of the magnitude of an integer string until a single digit remains.
- [Integer divisors](/tools/integer-divisors) `integer-divisors`: List every positive divisor of a positive integer, ascending.
- [Integer divmod](/tools/integer-divmod) `integer-divmod`: Integer quotient and remainder truncated toward zero.
- [Integer extended GCD](/tools/integer-extended-gcd) `integer-extended-gcd`: Compute the extended Euclidean algorithm result: gcd(a, b) and Bezout coefficients x, y with a*x + b*y = gcd.
- [Integer factorial](/tools/integer-factorial) `integer-factorial`: Compute n! (n factorial) exactly for a bounded non-negative integer n.
- [Integer GCD](/tools/integer-gcd) `integer-gcd`: Compute the non-negative greatest common divisor of two canonical integer strings.
- [Integer is perfect square](/tools/integer-is-perfect-square) `integer-is-perfect-square`: Test whether a non-negative integer string is a perfect square.
- [Integer is prime](/tools/integer-is-prime) `integer-is-prime`: Deterministically test whether a non-negative integer string is prime.
- [Integer LCM](/tools/integer-lcm) `integer-lcm`: Compute the non-negative least common multiple of two canonical integer strings.
- [Integer mod inverse](/tools/integer-mod-inverse) `integer-mod-inverse`: Compute the modular multiplicative inverse of a modulo modulus, when it exists.
- [Integer mod pow](/tools/integer-mod-pow) `integer-mod-pow`: Compute base^exponent mod modulus exactly using fast modular exponentiation.
- [Integer multiply](/tools/integer-multiply) `integer-multiply`: Multiply two canonical base-10 integer strings and return their product.
- [Integer nth root](/tools/integer-nth-root) `integer-nth-root`: Compute the exact floor of the nth root of a non-negative integer string.
- [Integer permutations count](/tools/integer-permutations-count) `integer-permutations-count`: Compute the exact number of k-permutations of n distinct items, P(n, k) = n! / (n-k)!.
- [Integer prime factors](/tools/integer-prime-factors) `integer-prime-factors`: Compute the prime factorization of a positive integer as a list of prime/exponent pairs.
- [Integer sort](/tools/integer-sort) `integer-sort`: Stable-sort canonical signed base-10 integer strings using BigInt.
- [Integer sqrt](/tools/integer-sqrt) `integer-sqrt`: Compute the exact floor of the square root of a non-negative integer string.
- [Integer totient](/tools/integer-totient) `integer-totient`: Compute Euler's totient function: the count of integers in [1, value] coprime to value.
- [Interval contains](/tools/interval_contains) `interval_contains`: Test whether a numeric interval contains a point or interval.
- [Interval difference](/tools/interval_difference) `interval_difference`: Compute the portion of interval a outside interval b.
- [Interval intersection](/tools/interval_intersection) `interval_intersection`: Compute the closed intersection of two numeric intervals.
- [Interval overlap](/tools/interval_overlap) `interval_overlap`: Test whether two numeric intervals overlap.
- [Interval union](/tools/interval_union) `interval_union`: Merge overlapping or adjacent numeric intervals.
- [Mixed number to rational](/tools/mixed-number-to-rational) `mixed-number-to-rational`: Convert a mixed number (sign, whole part, proper-fraction numerator and denominator) into a single reduced rational.
- [Rational add](/tools/rational-add) `rational-add`: Add two rational numbers given as numerator/denominator integer strings and return the reduced sum.
- [Rational compare](/tools/rational-compare) `rational-compare`: Compare two rational numbers given as numerator/denominator integer strings by exact value.
- [Rational multiply](/tools/rational-multiply) `rational-multiply`: Multiply two rational numbers given as numerator/denominator integer strings and return the reduced product.
- [Rational power](/tools/rational-power) `rational-power`: Raise a rational number to an integer exponent and return the exact reduced result.
- [Rational reciprocal](/tools/rational-reciprocal) `rational-reciprocal`: Invert a rational number given as a numerator/denominator integer-string pair.
- [Rational simplify](/tools/rational-simplify) `rational-simplify`: Reduce a numerator/denominator pair to lowest terms with the sign normalized onto the numerator.
- [Rational subtract](/tools/rational-subtract) `rational-subtract`: Subtract one rational number from another, given as numerator/denominator integer strings, and return the reduced difference.
- [Rational to mixed number](/tools/rational-to-mixed-number) `rational-to-mixed-number`: Convert a rational number into a sign, whole part, and proper-fraction numerator/denominator.

## Vectors & matrices

Exact vector and matrix arithmetic: products, norms, determinants, inverses and linear systems.

- [Matrix add](/tools/matrix-add) `matrix-add`: Add two equal-shape finite-number matrices elementwise.
- [Matrix determinant](/tools/matrix-determinant) `matrix-determinant`: Compute the determinant of a small square finite-number matrix.
- [Matrix hadamard](/tools/matrix-hadamard) `matrix-hadamard`: Multiply two equal-shape finite-number matrices elementwise (Hadamard product).
- [Matrix identity](/tools/matrix-identity) `matrix-identity`: Construct the NxN identity matrix for a given size.
- [Matrix inverse](/tools/matrix-inverse) `matrix-inverse`: Compute the inverse of a small square finite-number matrix.
- [Matrix multiply](/tools/matrix-multiply) `matrix-multiply`: Multiply an MxK finite-number matrix by a KxN finite-number matrix, producing an MxN matrix.
- [Matrix rank](/tools/matrix-rank) `matrix-rank`: Compute the numerical rank of a finite-number matrix (square or rectangular).
- [Matrix scale](/tools/matrix-scale) `matrix-scale`: Multiply every entry of a finite-number matrix by a scalar.
- [Matrix solve linear](/tools/matrix-solve-linear) `matrix-solve-linear`: Solve the small square linear system A x = b for x using Gaussian elimination.
- [Matrix subtract](/tools/matrix-subtract) `matrix-subtract`: Subtract two equal-shape finite-number matrices elementwise (a minus b).
- [Matrix trace](/tools/matrix-trace) `matrix-trace`: Compute the trace (sum of diagonal entries) of a square finite-number matrix.
- [Matrix transpose](/tools/matrix-transpose) `matrix-transpose`: Transpose an MxN finite-number matrix into an NxM matrix.
- [Matrix vector multiply](/tools/matrix-vector-multiply) `matrix-vector-multiply`: Multiply an MxN finite-number matrix by a length-N finite-number vector, producing a length-M vector.
- [Vector add](/tools/vector-add) `vector-add`: Add two equal-length finite-number vectors elementwise.
- [Vector angle](/tools/vector-angle) `vector-angle`: Compute the angle in radians between two equal-length finite-number vectors.
- [Vector approx equal](/tools/vector-approx-equal) `vector-approx-equal`: Compare two equal-length finite-number vectors for approximate equality within an absolute tolerance.
- [Vector cross](/tools/vector-cross) `vector-cross`: Compute the 3-dimensional cross product of two finite-number vectors.
- [Vector distance](/tools/vector-distance) `vector-distance`: Compute the Euclidean, Manhattan, or Chebyshev distance between two equal-length finite-number vectors.
- [Vector dot](/tools/vector-dot) `vector-dot`: Compute the dot (scalar) product of two equal-length finite-number vectors.
- [Vector hadamard](/tools/vector-hadamard) `vector-hadamard`: Multiply two equal-length finite-number vectors elementwise (Hadamard product).
- [Vector lerp](/tools/vector-lerp) `vector-lerp`: Linearly interpolate (or extrapolate) between two equal-length finite-number vectors.
- [Vector norm](/tools/vector-norm) `vector-norm`: Compute the L1, L2 (Euclidean), or L-infinity (Chebyshev) norm of a finite-number vector.
- [Vector normalize](/tools/vector-normalize) `vector-normalize`: Scale a finite-number vector to unit Euclidean length.
- [Vector outer product](/tools/vector-outer-product) `vector-outer-product`: Compute the outer product of two finite-number vectors, producing a matrix.
- [Vector projection](/tools/vector-projection) `vector-projection`: Compute the vector projection of a finite-number vector onto another.
- [Vector scale](/tools/vector-scale) `vector-scale`: Multiply every entry of a finite-number vector by a scalar.
- [Vector subtract](/tools/vector-subtract) `vector-subtract`: Subtract two equal-length finite-number vectors elementwise (a minus b).

## Units & sizes

Convert, add and compare lengths, masses, temperatures and byte sizes.

- [Byte size add](/tools/bytesize-add) `bytesize-add`: Add non-negative integer byte-size terms in mixed IEC units and return the exact sum in a chosen unit.
- [Byte size compare](/tools/bytesize-compare) `bytesize-compare`: Compare two non-negative integer byte sizes by exact byte amounts.
- [Byte size convert](/tools/bytesize-convert) `bytesize-convert`: Convert a non-negative integer byte size between IEC binary units as an exact rational.
- [Length add](/tools/length-add) `length-add`: Add integer length terms in mixed units and return the exact sum in a chosen unit.
- [Length compare](/tools/length-compare) `length-compare`: Compare two integer length measurements by exact nanometer amounts.
- [Length convert](/tools/length-convert) `length-convert`: Convert a canonical integer length between exact SI and international customary units.
- [Mass add](/tools/mass-add) `mass-add`: Add mixed-unit canonical integer mass amounts and express the sum in a target unit as a reduced rational.
- [Mass compare](/tools/mass-compare) `mass-compare`: Compare two mixed-unit canonical integer mass amounts using exact nanogram BigInt values.
- [Mass convert](/tools/mass-convert) `mass-convert`: Convert a canonical integer mass amount between exact nanogram-based units as a reduced rational.
- [Temperature compare](/tools/temperature-compare) `temperature-compare`: Compare two temperatures in C, F, or K by converting both to Kelvin rationals.
- [Temperature convert](/tools/temperature-convert) `temperature-convert`: Convert a decimal temperature between Celsius, Fahrenheit, and Kelvin as an exact rational.

## Graphs & scheduling

Topological sort, cycles, paths, reachability and task schedules.

- [Graph ancestors](/tools/graph-ancestors) `graph-ancestors`: List every ancestor of given targets, including the targets, in reverse-graph BFS discovery order.
- [Graph connected components](/tools/graph-connected-components) `graph-connected-components`: Partition a directed simple graph into undirected connected components, ignoring edge direction.
- [Graph DAG longest path](/tools/graph-dag-longest-path) `graph-dag-longest-path`: Return a longest node-weighted path in a DAG, where path weight is the sum of node durations.
- [Graph dependency impact](/tools/graph-dependency-impact) `graph-dependency-impact`: List nodes downstream of a removed set: not themselves removed, reachable by a directed path of length at least 1.
- [Graph find cycle](/tools/graph-find-cycle) `graph-find-cycle`: Find one directed cycle by 3-color DFS, or report that the graph is acyclic.
- [Graph from adjacency](/tools/graph-from-adjacency) `graph-from-adjacency`: Rebuild a simple directed graph from adjacency lists of node ids and successors.
- [Graph induced subgraph](/tools/graph-induced-subgraph) `graph-induced-subgraph`: Return the vertex-induced subgraph on a listed node subset, preserving declared node and edge order.
- [Graph reachable from](/tools/graph-reachable-from) `graph-reachable-from`: List nodes reachable from given sources by directed BFS, in discovery order.
- [Graph reverse](/tools/graph-reverse) `graph-reverse`: Reverse every directed edge of a simple graph, keeping node order and original edge order.
- [Graph shortest unweighted path](/tools/graph-shortest-unweighted-path) `graph-shortest-unweighted-path`: Find a shortest directed path by fewest edges from source to target.
- [Graph strongly connected components](/tools/graph-strongly-connected-components) `graph-strongly-connected-components`: Partition a directed simple graph into strongly connected components, listed by declared node index.
- [Graph to adjacency](/tools/graph-to-adjacency) `graph-to-adjacency`: Convert a directed simple graph into per-node outgoing adjacency lists.
- [Graph topological sort](/tools/graph-topological-sort) `graph-topological-sort`: Return a Kahn topological order of a directed acyclic graph, breaking ready-set ties by declared node index.
- [Graph transitive closure](/tools/graph-transitive-closure) `graph-transitive-closure`: List directed reachability pairs of path length at least 1, ordered by declared node index.
- [Graph transitive reduction](/tools/graph-transitive-reduction) `graph-transitive-reduction`: Compute the transitive reduction of a DAG: keep an edge u→v iff the original graph has no directed path from u to v of length at least 2.
- [Graph validate](/tools/graph-validate) `graph-validate`: Inspect a well-formed directed simple graph and report counts, isolated nodes, and maximum degrees.
- [Schedule ASAP layers](/tools/schedule-asap-layers) `schedule-asap-layers`: Partition a DAG into ASAP topological generations: each layer is the nodes that become ready together.
- [Schedule critical path](/tools/schedule-critical-path) `schedule-critical-path`: Compute CPM zero-slack critical nodes and tight edges on a DAG, plus one representative critical path.
- [Schedule earliest finish](/tools/schedule-earliest-finish) `schedule-earliest-finish`: Compute CPM earliest start and earliest finish times for a DAG with node durations, plus the project makespan.
- [Schedule ready nodes](/tools/schedule-ready-nodes) `schedule-ready-nodes`: List DAG nodes that can start because they are not completed and every predecessor is completed.

## File paths (lexical)

Normalize, join, match and group path strings without touching a filesystem.

- [Path format convert](/tools/path-format-convert) `path-format-convert`: Convert file paths between POSIX and Windows formats, handling slashes, drive letters, and roots lexically.
- [Path lexical common ancestor](/tools/path-lexical-common-ancestor) `path-lexical-common-ancestor`: Compute the deepest common ancestor directory of a set of paths.
- [Path lexical contains](/tools/path-lexical-contains) `path-lexical-contains`: Check whether a child path is lexically inside a parent directory.
- [Path lexical join](/tools/path-lexical-join) `path-lexical-join`: Join an array of path segments lexically, resolving absolute reset boundaries and normalizing separators.
- [Path lexical normalize](/tools/path-lexical-normalize) `path-lexical-normalize`: Normalize a path lexically: collapse redundant separators, resolve "." and ".." segments.
- [Path lexical parse](/tools/path-lexical-parse) `path-lexical-parse`: Decompose a file path into its lexical components without accessing the filesystem.
- [Path lexical relative](/tools/path-lexical-relative) `path-lexical-relative`: Compute the lexical relative path from one path to another without filesystem access.
- [Path lexical sanitize](/tools/path-lexical-sanitize) `path-lexical-sanitize`: Sanitize an untrusted path to produce a safe relative path, stripping roots, drive letters, traversal segments, and illegal characters.
- [Path set classify](/tools/path-set-classify) `path-set-classify`: Classify an array of file paths by file extension, depth histogram, and path format.
- [Path set dedupe](/tools/path-set-dedupe) `path-set-dedupe`: Deduplicate an array of paths based on lexical equivalence while preserving first or last seen order.
- [Path set difference](/tools/path-set-difference) `path-set-difference`: Compute the set difference (A \ B) of two path collections using lexical path equivalence.
- [Path set glob filter](/tools/path-set-glob-filter) `path-set-glob-filter`: Filter an array of paths against glob patterns with inclusion and exclusion rules lexically without filesystem access.
- [Path set glob test](/tools/path-set-glob-test) `path-set-glob-test`: Test a single path string against glob patterns lexically and return match disposition and matching pattern.
- [Path set hierarchy tree](/tools/path-set-hierarchy-tree) `path-set-hierarchy-tree`: Transform a flat array of file paths into a nested deterministic directory tree structure.
- [Path set ignore filter](/tools/path-set-ignore-filter) `path-set-ignore-filter`: Filter paths against gitignore-style rule lines (negation, comments, directory trailing slashes) lexically.
- [Path set intersection](/tools/path-set-intersection) `path-set-intersection`: Compute the set intersection of multiple path collections using lexical path equivalence.
- [Path set minimal covering](/tools/path-set-minimal-covering) `path-set-minimal-covering`: Find the minimal covering set of paths by collapsing child paths when an ancestor path is already in the set.
- [Path set partition directory](/tools/path-set-partition-directory) `path-set-partition-directory`: Partition an array of file paths into buckets grouped by parent directory or directory at a specified depth.
- [Path set prefix strip](/tools/path-set-prefix-strip) `path-set-prefix-strip`: Strip a common directory prefix or base path from an array of paths lexically.
- [Path set union](/tools/path-set-union) `path-set-union`: Compute the set union of multiple path collections, normalized and deterministically sorted.

## Forms

Compare form definitions, answers and response sets.

- [Form answer diff](/tools/form-answer-diff) `form-answer-diff`: Diff two answer maps against one shared form definition.
- [Form compare](/tools/form-compare) `form-compare`: Compare two filled form snapshots and return compact field and answer changes.
- [Form definition diff](/tools/form-definition-diff) `form-definition-diff`: Diff two form definitions by stable field id, including choice lists and field order.
- [Form field map](/tools/form-field-map) `form-field-map`: Rename form fields with an explicit id map and reject collisions.
- [Form response check](/tools/form-response-check) `form-response-check`: Report missing required answers, nulls, type failures, and choice failures.
- [Form response diff](/tools/form-response-diff) `form-response-diff`: Reconcile two form response sets by exact respondent id.

## Encoding & checksums

Base64, UTF-8, hex bytes and non-cryptographic checksums.

- [Adler-32](/tools/adler32) `adler32`: Adler-32 of UTF-8 bytes (RFC 1950). Integrity check only; no security claim.
- [Base64 UTF-8](/tools/base64-utf8) `base64-utf8`: Decode standard Base64 to UTF-8 text. Transformation only; no security claim.
- [CRC-32](/tools/crc32) `crc32`: CRC-32 of UTF-8 bytes (ISO 3309 / ZIP / PNG polynomial). Integrity check only; no security claim.
- [Hex bytes concat](/tools/hex-bytes-concat) `hex-bytes-concat`: Concatenate a bounded ordered list of lowercase hex byte strings into one hex string.
- [Hex bytes slice](/tools/hex-bytes-slice) `hex-bytes-slice`: Slice a lowercase hex byte string by explicit byte-index bounds, half-open like Array.slice.
- [Hex bytes xor](/tools/hex-bytes-xor) `hex-bytes-xor`: Byte-wise XOR of two equal-length lowercase hex byte strings. Transformation only; no cryptographic security claim.
- [UTF-8 Base64](/tools/utf8-base64) `utf8-base64`: Encode a Unicode string as standard Base64 of its UTF-8 bytes. Transformation only; no security claim.
- [UTF-8 hex](/tools/utf8-hex) `utf8-hex`: Encode a Unicode string as lowercase hex of its UTF-8 bytes. Transformation only; no security claim.

## URLs & IP addresses

Parse, build and normalize URLs and query strings; IPv4 and IPv6 addresses, CIDR blocks and subnets.

- [IPv4 address classify](/tools/ipv4-address-classify) `ipv4-address-classify`: Classify an IPv4 address against the static IANA IPv4 special-purpose address registry.
- [IPv4 address compare](/tools/ipv4-address-compare) `ipv4-address-compare`: Compare two canonical IPv4 addresses by their numeric uint32 value.
- [IPv4 address distance](/tools/ipv4-address-distance) `ipv4-address-distance`: Compute the signed integer distance between two IPv4 addresses (address_b minus address_a).
- [IPv4 address offset](/tools/ipv4-address-offset) `ipv4-address-offset`: Add a signed integer offset to an IPv4 address, throwing if the result leaves the IPv4 address space.
- [IPv4 CIDR aggregate](/tools/ipv4-cidr-aggregate) `ipv4-cidr-aggregate`: Merge a list of IPv4 CIDR blocks into the minimal equivalent list of non-overlapping CIDR blocks.
- [IPv4 CIDR contains](/tools/ipv4-cidr-contains) `ipv4-cidr-contains`: Test whether one IPv4 CIDR block fully contains another IPv4 CIDR block.
- [IPv4 CIDR overlap](/tools/ipv4-cidr-overlap) `ipv4-cidr-overlap`: Test whether two IPv4 CIDR blocks overlap (share at least one address).
- [IPv4 CIDR parse](/tools/ipv4-cidr-parse) `ipv4-cidr-parse`: Parse an IPv4 CIDR block into its network, broadcast, netmask, wildcard mask, usable host range and address counts.
- [IPv4 CIDR subnets](/tools/ipv4-cidr-subnets) `ipv4-cidr-subnets`: Split an IPv4 CIDR block into the full ordered list of equal-size subnets at a given longer prefix.
- [IPv4 format](/tools/ipv4-format) `ipv4-format`: Format a uint32 integer string or four octets as a canonical dotted-decimal IPv4 address.
- [IPv4 in CIDR](/tools/ipv4-in-cidr) `ipv4-in-cidr`: Test whether a canonical IPv4 address lies in a CIDR prefix whose host bits are zero.
- [IPv4 mask convert](/tools/ipv4-mask-convert) `ipv4-mask-convert`: Convert between an IPv4 prefix length, dotted subnet netmask, and dotted wildcard (host) mask.
- [IPv4 parse](/tools/ipv4-parse) `ipv4-parse`: Parse a canonical dotted-decimal IPv4 address into octets and a uint32 integer string.
- [IPv4 prefix for hosts](/tools/ipv4-prefix-for-hosts) `ipv4-prefix-for-hosts`: Compute the smallest IPv4 CIDR block (largest prefix length) whose usable host capacity meets a required count.
- [IPv4 range to cidrs](/tools/ipv4-range-to-cidrs) `ipv4-range-to-cidrs`: Convert an arbitrary IPv4 address range into the minimal list of CIDR blocks that exactly covers it.
- [IPv6 address classify](/tools/ipv6-address-classify) `ipv6-address-classify`: Classify an IPv6 address against the static IANA IPv6 special-purpose address registry.
- [IPv6 address compare](/tools/ipv6-address-compare) `ipv6-address-compare`: Compare two IPv6 addresses by their numeric 128-bit value.
- [IPv6 address distance](/tools/ipv6-address-distance) `ipv6-address-distance`: Compute the signed integer distance between two IPv6 addresses (address_b minus address_a).
- [IPv6 address offset](/tools/ipv6-address-offset) `ipv6-address-offset`: Add a signed integer offset to an IPv6 address, throwing if the result leaves the IPv6 address space.
- [IPv6 CIDR aggregate](/tools/ipv6-cidr-aggregate) `ipv6-cidr-aggregate`: Merge a list of IPv6 CIDR blocks into the minimal equivalent list of non-overlapping CIDR blocks.
- [IPv6 CIDR contains](/tools/ipv6-cidr-contains) `ipv6-cidr-contains`: Test whether one IPv6 CIDR block fully contains another IPv6 CIDR block.
- [IPv6 CIDR overlap](/tools/ipv6-cidr-overlap) `ipv6-cidr-overlap`: Test whether two IPv6 CIDR blocks overlap (share at least one address).
- [IPv6 CIDR parse](/tools/ipv6-cidr-parse) `ipv6-cidr-parse`: Parse an IPv6 CIDR block into its canonical network address, prefix, first/last address, and total address count.
- [IPv6 CIDR subnets](/tools/ipv6-cidr-subnets) `ipv6-cidr-subnets`: Split an IPv6 CIDR block into the full ordered list of equal-size subnets at a given longer prefix.
- [IPv6 format](/tools/ipv6-format) `ipv6-format`: Format 8 hextets or a 128-bit integer string as the RFC 5952 canonical compressed IPv6 address.
- [IPv6 in CIDR](/tools/ipv6-in-cidr) `ipv6-in-cidr`: Test whether an IPv6 address lies in a CIDR prefix whose host bits are zero.
- [IPv6 IPv4 mapped](/tools/ipv6-ipv4-mapped) `ipv6-ipv4-mapped`: Convert between an IPv4 address and its IPv4-mapped IPv6 form (::ffff:0:0/96), in either direction.
- [IPv6 normalize](/tools/ipv6-normalize) `ipv6-normalize`: Normalize any valid textual IPv6 address directly into its RFC 5952 canonical compressed string.
- [IPv6 parse](/tools/ipv6-parse) `ipv6-parse`: Parse an IPv6 address (any RFC 4291 textual form) into its 8 hextets and a 128-bit integer string.
- [IPv6 range to cidrs](/tools/ipv6-range-to-cidrs) `ipv6-range-to-cidrs`: Convert an arbitrary IPv6 address range into the minimal list of CIDR blocks that exactly covers it.
- [URL normalize](/tools/url-normalize) `url-normalize`: Normalize an absolute http or https URL via WHATWG parse. No DNS, fetch, or security-equivalence claim.
- [URL query build](/tools/url-query-build) `url-query-build`: Build a query string or replace an absolute URL query from ordered pairs. No fetching.
- [URL query merge](/tools/url-query-merge) `url-query-merge`: Merge query pairs into an absolute URL. No fetching.
- [URL query parse](/tools/url-query-parse) `url-query-parse`: Parse query pairs and fragment from an absolute URL. Parse only; no fetching.
- [URL resolve](/tools/url-resolve) `url-resolve`: Resolve a URL against an absolute http(s) base using WHATWG. No fetching. Result must be http(s).

## Versions & config

Semantic version ranges and sorting; .env parsing and merging.

- [.env merge](/tools/env-merge) `env-merge`: Overlay two dotenv-subset documents, replacing left values and appending right-only keys.
- [.env parse](/tools/env-parse) `env-parse`: Parse a strict dotenv-subset document into ordered key/value entries.
- [.env stringify](/tools/env-stringify) `env-stringify`: Serialize unique env key/value entries to a canonical dotenv-subset document.
- [SemVer compare](/tools/semver-compare) `semver-compare`: Compare two strict Semantic Versions by precedence.
- [SemVer filter](/tools/semver-filter) `semver-filter`: Filter strict versions that satisfy a range, preserving original order and strings.
- [SemVer satisfies](/tools/semver-satisfies) `semver-satisfies`: Test whether a strict version satisfies a semver range.
- [SemVer sort](/tools/semver-sort) `semver-sort`: Sort strict valid Semantic Versions in ascending precedence order.