@jarenjs/formats 0.9.2 → 0.34.2

package/README.md

@@ -1,10 +1,12 @@
 # @jarenjs/formats
 
-Format validators for the JSON Schema `format` keyword, built on the text validators of [`@jarenjs/core`](../core). Includes all standard string formats (`date-time`, `date`, `time`, `duration`, `email`, `idn-email`, `hostname`, `idn-hostname`, `ipv4`, `ipv6`, `uri`, `uri-reference`, `uri-template`, `iri`, `iri-reference`, `uuid`, `regex`) plus many extras (`isbn10`, `mac`, `base64`, `alpha`, `color`, ...) and numeric formats (`int8` ... `uint64`, `float16` ... `float64`).
+Format validators for the JSON Schema `format` keyword, built on the text validators of [`@jarenjs/core`](../core). Includes all standard string formats (`date-time`, `date`, `time`, `duration`, `email`, `idn-email`, `hostname`, `idn-hostname`, `ipv4`, `ipv6`, `uri`, `uri-reference`, `uri-template`, `iri`, `iri-reference`, `uuid`, `regex`) plus many extras (`iregexp`, `isbn10`, `mac`, `base64`, `alpha`, `color`, ...) and numeric formats (`int8` ... `uint64`, `float16` ... `float64`).
 
-The JSON addressing formats are grouped separately in `jsonFormats`: `json-pointer`, `json-pointer-uri-fragment` and `relative-json-pointer` (RFC 6901), and `json-path`, which validates query strings against the complete [RFC 9535](https://www.rfc-editor.org/rfc/rfc9535.html) grammar using the parser of the JSONPath compiler in `@jarenjs/json`.
+The JSON addressing formats are grouped separately in `jsonFormats`: `json-pointer`, `json-pointer-uri-fragment` and `relative-json-pointer` (RFC 6901), and `json-path`, which validates query strings against the complete [RFC 9535](https://www.rfc-editor.org/rfc/rfc9535.html) grammar using the parser of the JSONPath compiler in `@jarenjs/json`, plus `json-path-segments` for the variable-rooted path strings of the Jaren query format.
 
-The name → predicate bindings live in one canonical table, exported as `formatTesters` (plus the per-group `stringFormatTesters`, `jsonFormatTesters`, `dateTimeFormatTesters`, `numberFormatTesters`): bare synchronous predicates without validator coupling. The format compilers above wrap these testers in the validator contract, and [`@jarenjs/forms`](../forms) merges its rendering hints over the same table for per-keystroke field validation — one registry, so the two layers can never drift apart.
+The geospatial formats are grouped in `geoFormats`: `geohash`, `wkt` and `geojson`, backed by the spatial kernel in `@jarenjs/core/geo`.
+
+The name → predicate bindings live in one canonical table, exported as `formatTesters` (plus the per-group `stringFormatTesters`, `jsonFormatTesters`, `geoFormatTesters`, `dateTimeFormatTesters`, `numberFormatTesters`): bare synchronous predicates without validator coupling. The format compilers above wrap these testers in the validator contract, and [`@jarenjs/forms`](../forms) merges its rendering hints over the same table for per-keystroke field validation — one registry, so the two layers can never drift apart.
 
 ## Usage
 
@@ -16,7 +18,8 @@ const jaren = new JarenValidator()
   .addFormats(formats.stringFormats)
   .addFormats(formats.numberFormats)
   .addFormats(formats.dateTimeFormats)
-  .addFormats(formats.jsonFormats);
+  .addFormats(formats.jsonFormats)
+  .addFormats(formats.geoFormats);
 
 const validate = jaren.compile({ type: 'string', format: 'json-path' });
 validate('$.store.book[?@.price < 10]'); // true
@@ -24,6 +27,10 @@ validate('$.store.book[?@.price < 10]'); // true
 
 Format assertion follows the specification per draft: asserted through draft 2019-09, annotation-only from draft 2020-12 on unless enabled via the `formatAssertion` option (`new JarenValidator({ formatAssertion: true })`) or a metaschema that declares the `format-assertion` vocabulary.
 
+**Register the group before you use a name from it, and register the right one.** The groups are split, so `date-time` lives in `dateTimeFormats` and *not* in `stringFormats`, and `json-path` lives in `jsonFormats`. Registering only `stringFormats` and then writing `format: 'date-time'` leaves the keyword accepting every value — per spec, an unregistered format is an annotation and asserts nothing, so nothing anywhere reports it. For schemas you own, compile with `new JarenValidator({ unknownFormats: 'error' })`: the missing registration then fails at compile time instead of silently. This repository does that for every schema it ships, gated by `test/validate/our-schema-formats.test.js`.
+
+**Register the compilers, not the testers.** `stringFormats` and `formatTesters` are both objects full of functions, but only the *compilers* take `(schemaObj, jsonSchema)` and return the per-value validator; a tester registered in a compiler's place compiles to nothing. That one throws under either `unknownFormats` setting, because it is never intentional. Use `formatTesters` directly — as [`@jarenjs/forms`](../forms) does for per-keystroke field validation — rather than through `addFormats`.
+
 ## ✍ The complete format list
 
 ### ✍ Formats for strings
@@ -38,24 +45,20 @@ These format validators are based on the [json-schema.org](https://json-schema.o
 
 - `duration` | duration from RFC3339
 - `iso-date-time` | ISO 8601 date-time with optional timezone
-- `iso-time` | ISO 8601 time with optional timezone
+- `iso-time` | ISO 8601 time with optional timezone — the timezone offset is uniformly optional, so a zone-less time such as `12:30:00` validates
 
-*Note: All date time formats can use formatMinimum / formatMaximum and formatExclusiveMinimum and formatExclusiveMaximum*
+*Note: All date time formats can use formatMinimum / formatMaximum and formatExclusiveMinimum and formatExclusiveMaximum. The bounds are folded to epoch milliseconds at compile time and string values compare as numbers, so a validation allocates no `Date`; a raw `Date` instance as the value is still accepted and compares numerically.*
 
 #### 🗨 Formats for url's, hostnames and emails
 
-- `url` | full URL
-- `url--full` | same as `url`, but more comprehensive
-- `uri` | full URI
-- `uri--full` | same as `uri`, but more comprehensive
-- `uri-reference` | URI reference, including full and relative URIs
-- `uri-reference--full` | same as `uri-reference`, but more comprehensive
+- `url` | http/https URL — a `uri` narrowed to the web schemes, so it must carry an authority and the RFC 3986 grammar still applies (`http://localhost:8080` and `http://127.0.0.1/` are URLs; `http://x/a|b` is not)
+- `uri` | full URI according to [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986), parsed against the grammar by character code — an ASCII grammar throughout, so a string carrying non-ASCII characters is an `iri` and not a `uri`
+- `uri-reference` | URI reference, absolute or relative, according to [RFC3986](https://datatracker.ietf.org/doc/html/rfc3986)
 - `uri-template` | URI template according to [RFC6570](https://datatracker.ietf.org/doc/html/rfc6570)
-- `iri` | full URI with international characters
-- `iri-reference` | full URI reference with with international characters
+- `iri` | full URI with international characters, according to [RFC3987](https://datatracker.ietf.org/doc/html/rfc3987) — parsed against the grammar by character code, so percent-encoding must be well formed and `iprivate` is accepted in the query only
+- `iri-reference` | full IRI reference, absolute or relative, according to [RFC3987](https://datatracker.ietf.org/doc/html/rfc3987)
 
-- `email` | email address
-- `email--full` | same as email, but more comprehensive
+- `email` | email address according to [RFC5321](https://datatracker.ietf.org/doc/html/rfc5321), including quoted-string local parts and `[192.0.2.1]` / `[IPv6:::1]` address literals
 - `hostname` | host name according to [RFC1034](https://datatracker.ietf.org/doc/html/rfc1034#section-3.5)
 - `idn-hostname` | host name with international characters
 - `idn-email` | email address with international characters
@@ -81,6 +84,7 @@ These are grouped in `jsonFormats`.
 - `json-pointer-uri-fragment` | JSON-pointer fragment according to [RFC6901](https://datatracker.ietf.org/doc/html/rfc6901#section-6)
 - `relative-json-pointer` | relative JSON-pointer according to [draft-luff-relative-json-pointer-00](https://datatracker.ietf.org/doc/html/draft-luff-relative-json-pointer-00)
 - `json-path` | JSONPath query according to [RFC9535](https://www.rfc-editor.org/rfc/rfc9535.html), checked against the complete grammar (including filter well-typedness) by the parser of the JSONPath compiler in `@jarenjs/json`
+- `json-path-segments` | a variable-rooted path string — `$name` followed by optional [RFC9535](https://www.rfc-editor.org/rfc/rfc9535.html) segments (`$book.price[?@.isbn]`), the form the Jaren query format uses to address a bound variable. Not a valid RFC 9535 query on its own (the RFC's root identifier is `$` alone), so `json-path` rejects it; both formats recognize the five built-in function extensions and no others, because a format has to mean the same thing in every schema
 
 #### 🗨 Miscellaneous formats
 
@@ -92,14 +96,25 @@ These are grouped in `jsonFormats`.
 - `lowercase` | allow only lower case alpha characters
 - `color` | web color hex string (starts with #, must be 3 or 6 hax characters)
 - `regex` | tests whether a string is a valid regular expression
+- `iregexp` | tests whether a string is a valid I-Regexp according to [RFC9485](https://www.rfc-editor.org/rfc/rfc9485.html) — the interoperable subset that means the same thing in every regexp dialect, so it is stricter than `regex`: shorthand classes (`\d`, `\w`), lazy quantifiers, anchors and lookaround are all rejected
 - `base64` | base64 encoded data
 - `byte` | same as `base64` format
 
 - `isbn10` | International Standard Book Number 10 digit number
 - `isbn13` | International Standard Book Number 13 digit number
 
-- `country2` | Country code by alpha-2 according to ISO3166-1 _!No tests exists!_
-- `iban` | International Bank Account Number _!No tests exists!_
+- `country2` | country code by alpha-2 according to [ISO3166-1](https://www.iso.org/iso-3166-country-codes.html) — the 249 assigned codes plus `XK`, the user-assigned code for Kosovo; matched case-insensitively
+- `iban` | International Bank Account Number according to [ISO13616](https://www.iso.org/standard/81090.html) — checks the country's registered length, the alphanumeric body and the ISO 7064 MOD 97-10 check digits, so a transposed digit is caught; accepts both the compact electronic format (`NL91ABNA0417164300`) and the print format grouped in fours (`NL91 ABNA 0417 1643 00`)
+
+### ✍ Geospatial formats
+
+These are grouped in `geoFormats`, backed by the spatial kernel in [`@jarenjs/core/geo`](../core).
+
+- `geohash` | a base-32 geohash cell name, any length (`u173z`); the alphabet is lowercase and deliberately omits `a`, `i`, `l` and `o`
+- `wkt` | a Well-Known Text geometry (ISO 19125 / OGC Simple Features): the seven tagged types with optional `Z`/`M`/`ZM` modifiers, `EMPTY`, consistent coordinate counts and closed polygon rings; an unmodified tag accepts 2 or 3 coordinates per point, as the field (PostGIS) does
+- `geojson` | a structurally valid GeoJSON object per [RFC 7946](https://datatracker.ietf.org/doc/html/rfc7946) — unlike every other format this one applies to **objects**, and it enforces the invariant JSON Schema provably cannot: every linear ring closed
+
+`geojson` exists *next to* the GeoJSON meta-schema artifacts in [`@jarenjs/json`](../json), not instead of them, and the division of labour is deliberate: the format is the one-keyword annotation that answers yes or no in a single call, while the meta-schema locates the failure and (in the `$query`-extended variant) also checks ring winding. Reach for the schema when you want a diagnosis; reach for the format when you only want the gate.
 
 ### ✍ Formats for numbers
 
@@ -126,4 +141,4 @@ These are grouped in `numberFormats`. Formats for numbers validate both numbers
 
 ## Development
 
-Unit tests live in `test/formats/` at the repository root; `test/formats/testers.test.js` enforces that every compiler registry's key set equals its tester group's, so the validator layer and the bare-predicate layer can never drift. The predicates themselves are implemented and tested in [`@jarenjs/core`](../core). See the repository [README](../../README.md) for the monorepo picture and the [ROADMAP](../../ROADMAP.md) for planned formats.
+Unit tests live in `test/formats/` at the repository root; `test/formats/testers.test.js` enforces that every compiler registry's key set equals its tester group's, so the validator layer and the bare-predicate layer can never drift. The predicates themselves are implemented and tested in [`@jarenjs/core`](../core). See the repository [README](../../README.md) for the monorepo picture and the [ROADMAP](../../docs/ROADMAP.md) for planned formats.

package/dist/types/geo.d.ts

@@ -0,0 +1,77 @@
+export type JSONSchema = {
+    format?: string;
+    formatMinimum?: string;
+    formatExclusiveMinimum?: string;
+    formatMaximum?: string;
+    formatExclusiveMaximum?: string;
+};
+export type ValidationObject = {
+    options: {
+        skipErrors: boolean;
+    };
+    createErrorHandler: (expected: any, key: string, ...details: any[]) => (data: any, dataPath?: string) => boolean;
+};
+/**
+ * @typedef {{format?: string, formatMinimum?: string, formatExclusiveMinimum?: string, formatMaximum?: string, formatExclusiveMaximum?: string}} JSONSchema
+ * @typedef {{
+ *   options: {skipErrors: boolean},
+ *   createErrorHandler: (expected: any, key: string, ...details: any[]) => (data: any, dataPath?: string) => boolean
+ * }} ValidationObject
+ */
+/**
+ * Compiles a validator for the 'geohash' format.
+ * Validates geohash strings: any length, every character in the
+ * base-32 geohash alphabet.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileGeohashFormat(schemaObj, { format: 'geohash' })('u173z'); // true
+ * compileGeohashFormat(schemaObj, { format: 'geohash' })('u17a'); // false ('a' is not in the alphabet)
+ */
+export declare const compileGeohashFormat: (schemaObj: import("./string.js").ValidationObject, jsonSchema: import("./string.js").JSONSchema) => (data: unknown, dataPath?: string) => boolean;
+/**
+ * Compiles a validator for the 'wkt' format.
+ * Validates Well-Known Text geometry strings (ISO 19125 / OGC Simple
+ * Features): the seven tagged geometry types with optional Z/M/ZM
+ * modifiers, consistent coordinate counts, and closed polygon rings.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileWktFormat(schemaObj, { format: 'wkt' })('POINT (4.9041 52.3676)'); // true
+ * compileWktFormat(schemaObj, { format: 'wkt' })('POLYGON ((0 0, 4 0, 4 4, 1 1))'); // false (open ring)
+ */
+export declare const compileWktFormat: (schemaObj: import("./string.js").ValidationObject, jsonSchema: import("./string.js").JSONSchema) => (data: unknown, dataPath?: string) => boolean;
+/**
+ * Compiles a validator for the 'geojson' format. Unlike the string
+ * formats, this one applies to **objects**: any non-array object must be
+ * a structurally valid GeoJSON object (RFC 7946) — the coordinate
+ * nesting its `type` requires, positions inside the WGS 84 bounds, and
+ * every linear ring closed. Non-object values pass, following the rule
+ * that a format constrains only its own type.
+ *
+ * This is the quick, shallow judgment; the GeoJSON meta-schema artifacts
+ * in `@jarenjs/json` validate the same grammar more thoroughly (locating
+ * the failure, and — in the Jaren-extended variant — checking ring
+ * winding through `$query`). Reach for the schema when you want to know
+ * *what* is wrong; reach for the format when a one-keyword annotation is
+ * worth more than a diagnosis.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })({ type: 'Point', coordinates: [4.9, 52.4] }); // true
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })({ type: 'Polygon', coordinates: [[[0,0],[1,0],[1,1],[2,2]]] }); // false (open ring)
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })('not an object'); // true (wrong type is not this format's business)
+ */
+export declare function compileGeoJsonFormat(schemaObj: ValidationObject, jsonSchema: JSONSchema): (data: unknown, dataPath?: string) => boolean;
+/**
+ * Object mapping geospatial format names to their compiler functions.
+ *
+ * @type {Record<string, (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean>}
+ */
+export declare const formatValidators: Record<string, (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean>;

package/dist/types/index.d.ts

@@ -19,4 +19,5 @@ export { formatValidators as dateTimeFormats } from './datetime.js';
 export { formatValidators as stringFormats } from './string.js';
 export { formatValidators as numberFormats } from './number.js';
 export { formatValidators as jsonFormats } from './json.js';
-export { formatTesters, stringFormatTesters, jsonFormatTesters, dateTimeFormatTesters, numberFormatTesters, } from './testers.js';
+export { formatValidators as geoFormats } from './geo.js';
+export { formatTesters, stringFormatTesters, jsonFormatTesters, geoFormatTesters, dateTimeFormatTesters, numberFormatTesters, } from './testers.js';

package/dist/types/json.d.ts

@@ -63,6 +63,30 @@ export declare const compileRelativeJsonPointerFormat: (schemaObj: import("./str
  * compileJsonPathFormat(schemaObj, { format: 'json-path' })('$.foo '); // false (trailing whitespace)
  */
 export declare const compileJsonPathFormat: (schemaObj: import("./string.js").ValidationObject, jsonSchema: import("./string.js").JSONSchema) => (data: unknown, dataPath?: string) => boolean;
+/**
+ * Compiles a validator for the 'json-path-segments' format.
+ * Validates a *variable-rooted* path string: `$name` followed by
+ * optional RFC 9535 segments (`$book.price[?@.isbn]`). Such a string is
+ * not a valid RFC 9535 query — the RFC's root identifier is `$` alone —
+ * so `json-path` would reject it; this format is what gives the Jaren
+ * query format's variable-rooted paths the same schema-time
+ * well-formedness that absolute paths get from `json-path`.
+ *
+ * Both formats recognize the five built-in function extensions and no
+ * others: a format is a property of the string itself, so it must mean
+ * the same thing in every schema regardless of which custom extensions
+ * a particular host registered.
+ *
+ * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book.price'); // true
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book'); // true
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$.price'); // false (that is json-path)
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book.price['); // false
+ */
+export declare const compileJsonPathSegmentsFormat: (schemaObj: import("./string.js").ValidationObject, jsonSchema: import("./string.js").JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
  * Object mapping JSON-related format names to their compiler functions.
  *

package/dist/types/string.d.ts

@@ -135,25 +135,28 @@ export declare const compileColorFormat: (schemaObj: ValidationObject, jsonSchem
  */
 export declare const compileRegexFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
- * Compiles a validator for the 'uri' format.
- * Validates absolute URI strings per RFC 3986.
+ * Compiles a validator for the 'iregexp' format.
+ * Validates that a string is a valid I-Regexp (RFC 9485) pattern - the
+ * interoperable subset that carries the same meaning across regexp
+ * dialects. Stricter than 'regex': shorthand classes (\d, \w), lazy
+ * quantifiers, anchors and lookaround are all rejected.
  *
  * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
  * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
  * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- * @example
- * compileUriFormat(schemaObj, { format: 'uri' })('https://example.com'); // true
  */
-export declare const compileUriFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
+export declare const compileIRegexpFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
- * Compiles a validator for the 'uri--full' format.
- * Validates absolute URI strings with stricter checking.
+ * Compiles a validator for the 'uri' format.
+ * Validates absolute URI strings per RFC 3986.
  *
  * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
  * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
  * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileUriFormat(schemaObj, { format: 'uri' })('https://example.com'); // true
  */
-export declare const compileUriFullFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
+export declare const compileUriFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
  * Compiles a validator for the 'uri-reference' format.
  * Validates URI reference strings (absolute or relative) per RFC 3986.
@@ -163,15 +166,6 @@ export declare const compileUriFullFormat: (schemaObj: ValidationObject, jsonSch
  * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
  */
 export declare const compileUriReferenceFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
-/**
- * Compiles a validator for the 'uri-reference--full' format.
- * Validates URI reference strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export declare const compileUriReferenceFullFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
  * Compiles a validator for the 'uri-template' format.
  * Validates URI template strings per RFC 6570.
@@ -190,15 +184,6 @@ export declare const compileUriTemplateFormat: (schemaObj: ValidationObject, jso
  * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
  */
 export declare const compileUrlFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
-/**
- * Compiles a validator for the 'url--full' format.
- * Validates URL strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export declare const compileUrlFullFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
  * Compiles a validator for the 'iri' format.
  * Validates IRI strings per RFC 3987.
@@ -228,15 +213,6 @@ export declare const compileIriReferenceFormat: (schemaObj: ValidationObject, js
  * compileEmailFormat(schemaObj, { format: 'email' })('user@example.com'); // true
  */
 export declare const compileEmailFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
-/**
- * Compiles a validator for the 'email--full' format.
- * Validates email address strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export declare const compileEmailFullFormat: (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean;
 /**
  * Compiles a validator for the 'idn-email' format.
  * Validates internationalized email addresses (EAI) per RFC 6531.

package/dist/types/testers.d.ts

@@ -18,6 +18,14 @@ export declare const jsonFormatTesters: Record<string, StringFormatTester>;
  * @type {Record<string, StringFormatTester>}
  */
 export declare const dateTimeFormatTesters: Record<string, StringFormatTester>;
+/**
+ * Geospatial format testers (the geo.js compiler group). `geohash` and
+ * `wkt` take strings; `geojson` takes the OBJECT value — the quick
+ * yes-or-no twin of the GeoJSON meta-schema artifacts in `@jarenjs/json`,
+ * including the ring-closure invariant JSON Schema cannot express.
+ * @type {Record<string, (value: any) => boolean>}
+ */
+export declare const geoFormatTesters: Record<string, (value: any) => boolean>;
 /**
  * Number format testers (the number.js compiler group). These take the
  * NUMBER value, not a string.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/formats",
   "private": false,
-  "version": "0.9.2",
+  "version": "0.34.2",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -26,7 +26,7 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public",
@@ -43,7 +43,7 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.9.2",
-    "@jarenjs/json": "^0.9.2"
+    "@jarenjs/core": "^0.34.2",
+    "@jarenjs/json": "^0.34.2"
   }
 }

package/src/datetime.js

@@ -7,14 +7,20 @@ import {
 
 import {
   isDateType,
+  isDateTimeRFC3339,
+  isDateOnlyRFC3339,
+  isTimeOnlyRFC3339,
   getDateTypeOfDateTimeRFC3339,
   getDateTypeOfDateOnlyRFC3339,
   getDateTypeOfTimeOnlyRFC3339,
+  getEpochOfDateTimeRFC3339,
+  getEpochOfDateOnlyRFC3339,
+  getEpochOfTimeOnlyRFC3339,
   isValidDuration,
-  isValidISODateTime,
-  isValidISOTime,
   getDateTypeOfISODateTime,
   getDateTypeOfISOTime,
+  getEpochOfISODateTime,
+  getEpochOfISOTime,
 } from '@jarenjs/core/dates';
 
 /**
@@ -25,6 +31,16 @@ import {
  * }} ValidationObject
  */
 
+// The bound validators compare epoch milliseconds: the bound is folded
+// to a number at compile time and the value arrives as either an epoch
+// number (the string path, which then allocates nothing) or a raw Date
+// instance (which the relational operators coerce numerically, keeping
+// that door open). Only the error path materializes a Date, so the
+// reported error value stays what it always was.
+function asDateValue(value) {
+  return typeof value === 'number' ? new Date(value) : value;
+}
+
 /**
  * Compiles a format minimum validator function for date/time types.
  * Supports both inclusive (formatMinimum) and exclusive (formatExclusiveMinimum) bounds.
@@ -32,7 +48,7 @@ import {
  * @param {(value: string) => Date | undefined} parseType - Function to parse string into Date
  * @param {ValidationObject} schemaObj - The validation object for error handling and options
  * @param {JSONSchema} jsonSchema - The JSON schema containing format constraints
- * @returns {((date: Date, dataPath?: string) => boolean) | undefined} A validator function or undefined if no minimum constraint
+ * @returns {((date: number | Date, dataPath?: string) => boolean) | undefined} A validator function or undefined if no minimum constraint
  */
 function compileFormatMinimumByType(parseType, schemaObj, jsonSchema) {
   const [min, emin] = getInclusiveExclusiveBounds(
@@ -43,18 +59,20 @@ function compileFormatMinimumByType(parseType, schemaObj, jsonSchema) {
 
   if (emin != null) {
     const addError = schemaObj.createErrorHandler(emin, 'formatExclusiveMinimum');
+    const bound = emin.valueOf();
 
     return function isFormatExclusiveMinimum(date, dataPath) {
-      return date > emin
-        || addError(date, dataPath);
+      return date > bound
+        || addError(asDateValue(date), dataPath);
     };
   }
   else if (min) {
     const addError = schemaObj.createErrorHandler(min, 'formatMinimum');
+    const bound = min.valueOf();
 
     return function isFormatMinimum(date, dataPath) {
-      return date >= min
-        || addError(date, dataPath);
+      return date >= bound
+        || addError(asDateValue(date), dataPath);
     };
   }
 
@@ -68,7 +86,7 @@ function compileFormatMinimumByType(parseType, schemaObj, jsonSchema) {
  * @param {(value: string) => Date | undefined} parseType - Function to parse string into Date
  * @param {ValidationObject} schemaObj - The validation object for error handling and options
  * @param {JSONSchema} jsonSchema - The JSON schema containing format constraints
- * @returns {((date: Date, dataPath?: string) => boolean) | undefined} A validator function or undefined if no maximum constraint
+ * @returns {((date: number | Date, dataPath?: string) => boolean) | undefined} A validator function or undefined if no maximum constraint
  */
 function compileFormatMaximumByType(parseType, schemaObj, jsonSchema) {
   const [max, emax] = getInclusiveExclusiveBounds(
@@ -79,18 +97,20 @@ function compileFormatMaximumByType(parseType, schemaObj, jsonSchema) {
 
   if (emax != null) {
     const addError = schemaObj.createErrorHandler(emax, 'formatExclusiveMaximum');
+    const bound = emax.valueOf();
 
     return function isFormatExclusiveMaximum(date, dataPath) {
-      return date < emax
-        || addError(date, dataPath);
+      return date < bound
+        || addError(asDateValue(date), dataPath);
     };
   }
   else if (max) {
     const addError = schemaObj.createErrorHandler(max, 'formatMaximum');
+    const bound = max.valueOf();
 
     return function isFormatMaximum(date, dataPath) {
-      return date <= max
-        || addError(date, dataPath);
+      return date <= bound
+        || addError(asDateValue(date), dataPath);
     };
   }
 
@@ -105,6 +125,11 @@ function compileFormatMaximumByType(parseType, schemaObj, jsonSchema) {
  * @param {(value: string) => Date | undefined} parseType - Function to parse string into Date
  * @param {ValidationObject} schemaObj - The validation object for error handling and options
  * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @param {(value: string) => boolean} [isType] - Boolean tester matching parseType's
+ *   accepted grammar; used on the boundless path so no Date is constructed
+ * @param {(value: string) => number | undefined} [parseEpoch] - Epoch twin of
+ *   parseType; used on the bounded path so string values compare as numbers
+ *   without constructing a Date
  * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
  * @example
  * // Basic format validation
@@ -116,7 +141,7 @@ function compileFormatMaximumByType(parseType, schemaObj, jsonSchema) {
  *   formatMinimum: '2024-01-01T00:00:00Z'
  * })('2024-06-15T12:00:00Z'); // true
  */
-function compileFormatByType(name, parseType, schemaObj, jsonSchema) {
+function compileFormatByType(name, parseType, schemaObj, jsonSchema, isType = undefined, parseEpoch = undefined) {
   if (jsonSchema.format !== name)
     throw new Error('ERROR: This should not happen!');
 
@@ -134,10 +159,14 @@ function compileFormatByType(name, parseType, schemaObj, jsonSchema) {
     jsonSchema,
   );
 
+  // the bounded paths parse string values with the epoch twin where one
+  // exists, so a passing validation allocates nothing
+  const parseValue = parseEpoch != null ? parseEpoch : parseType;
+
   if (validateMin != null && validateMax != null) {
     return function validateFormatBetween(data, dataPath) {
       if (isStringType(data)) {
-        const date = parseType(data);
+        const date = parseValue(data);
         return date == null
           ? addError(data, dataPath)
           : validateMin(date, dataPath)
@@ -155,7 +184,7 @@ function compileFormatByType(name, parseType, schemaObj, jsonSchema) {
   if (validateMin != null) {
     return function validateFormatMinimum(data, dataPath) {
       if (isStringType(data)) {
-        const date = parseType(data);
+        const date = parseValue(data);
         return date == null
           ? addError(data, dataPath)
           : validateMin(date, dataPath);
@@ -170,10 +199,10 @@ function compileFormatByType(name, parseType, schemaObj, jsonSchema) {
   if (validateMax != null) {
     return function validateFormatMaximum(data, dataPath) {
       if (isStringType(data)) {
-        const date = parseType(data);
+        const date = parseValue(data);
         return date == null
           ? addError(data, dataPath)
-          : validateMax(date);
+          : validateMax(date, dataPath);
       }
       else if (isDateType(data))
         // @ts-ignore
@@ -183,6 +212,16 @@ function compileFormatByType(name, parseType, schemaObj, jsonSchema) {
     };
   }
 
+  // Without bounds only the format assertion remains; the boolean tester
+  // avoids parsing the string into a Date that would be discarded.
+  if (isType != null) {
+    return function validateDateTimeFormatOnly(data, dataPath) {
+      return isStringType(data)
+        ? isType(data) || addError(data, dataPath)
+        : true;
+    };
+  }
+
   return function validateDateTime(data, dataPath) {
     if (isStringType(data)) {
       const date = parseType(data);
@@ -218,6 +257,8 @@ export function compileDateTimeFormat(schemaObj, jsonSchema) {
     getDateTypeOfDateTimeRFC3339,
     schemaObj,
     jsonSchema,
+    isDateTimeRFC3339,
+    getEpochOfDateTimeRFC3339,
   );
 }
 
@@ -239,6 +280,8 @@ export function compileDateOnlyFormat(schemaObj, jsonSchema) {
     getDateTypeOfDateOnlyRFC3339,
     schemaObj,
     jsonSchema,
+    isDateOnlyRFC3339,
+    getEpochOfDateOnlyRFC3339,
   );
 }
 
@@ -261,6 +304,8 @@ export function compileTimeOnlyFormat(schemaObj, jsonSchema) {
     getDateTypeOfTimeOnlyRFC3339,
     schemaObj,
     jsonSchema,
+    isTimeOnlyRFC3339,
+    getEpochOfTimeOnlyRFC3339,
   );
 }
 
@@ -289,7 +334,7 @@ export function compileDurationFormat(schemaObj, jsonSchema) {
 
   // when skipErrors is true, we don't need to create error objects
   if (schemaObj.options.skipErrors) {
-    return function validateDurationFast(data, dataPath) {
+    return function validateDurationFast(data, _dataPath) {
       return isStringType(data)
         ? isValidDuration(data)
         : true;
@@ -330,6 +375,8 @@ export function compileISODateTimeFormat(schemaObj, jsonSchema) {
     getDateTypeOfISODateTime,
     schemaObj,
     jsonSchema,
+    undefined,
+    getEpochOfISODateTime,
   );
 }
 
@@ -354,6 +401,8 @@ export function compileISOTimeFormat(schemaObj, jsonSchema) {
     getDateTypeOfISOTime,
     schemaObj,
     jsonSchema,
+    undefined,
+    getEpochOfISOTime,
   );
 }
 

package/src/geo.js

@@ -0,0 +1,109 @@
+//@ts-check
+
+// The name -> predicate bindings live in ONE place: testers.js. This
+// module only wraps them in the validator's compiler contract.
+import { geoFormatTesters } from './testers.js';
+
+import { createStringFormatCompiler } from './string.js';
+
+/**
+ * @typedef {{format?: string, formatMinimum?: string, formatExclusiveMinimum?: string, formatMaximum?: string, formatExclusiveMaximum?: string}} JSONSchema
+ * @typedef {{
+ *   options: {skipErrors: boolean},
+ *   createErrorHandler: (expected: any, key: string, ...details: any[]) => (data: any, dataPath?: string) => boolean
+ * }} ValidationObject
+ */
+
+// =============================================================================
+// Geospatial Format Compilers
+// =============================================================================
+
+/**
+ * Compiles a validator for the 'geohash' format.
+ * Validates geohash strings: any length, every character in the
+ * base-32 geohash alphabet.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileGeohashFormat(schemaObj, { format: 'geohash' })('u173z'); // true
+ * compileGeohashFormat(schemaObj, { format: 'geohash' })('u17a'); // false ('a' is not in the alphabet)
+ */
+export const compileGeohashFormat = createStringFormatCompiler('geohash', geoFormatTesters['geohash']);
+
+/**
+ * Compiles a validator for the 'wkt' format.
+ * Validates Well-Known Text geometry strings (ISO 19125 / OGC Simple
+ * Features): the seven tagged geometry types with optional Z/M/ZM
+ * modifiers, consistent coordinate counts, and closed polygon rings.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileWktFormat(schemaObj, { format: 'wkt' })('POINT (4.9041 52.3676)'); // true
+ * compileWktFormat(schemaObj, { format: 'wkt' })('POLYGON ((0 0, 4 0, 4 4, 1 1))'); // false (open ring)
+ */
+export const compileWktFormat = createStringFormatCompiler('wkt', geoFormatTesters['wkt']);
+
+/**
+ * Compiles a validator for the 'geojson' format. Unlike the string
+ * formats, this one applies to **objects**: any non-array object must be
+ * a structurally valid GeoJSON object (RFC 7946) — the coordinate
+ * nesting its `type` requires, positions inside the WGS 84 bounds, and
+ * every linear ring closed. Non-object values pass, following the rule
+ * that a format constrains only its own type.
+ *
+ * This is the quick, shallow judgment; the GeoJSON meta-schema artifacts
+ * in `@jarenjs/json` validate the same grammar more thoroughly (locating
+ * the failure, and — in the Jaren-extended variant — checking ring
+ * winding through `$query`). Reach for the schema when you want to know
+ * *what* is wrong; reach for the format when a one-keyword annotation is
+ * worth more than a diagnosis.
+ *
+ * @param {ValidationObject} schemaObj - The validation object for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })({ type: 'Point', coordinates: [4.9, 52.4] }); // true
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })({ type: 'Polygon', coordinates: [[[0,0],[1,0],[1,1],[2,2]]] }); // false (open ring)
+ * compileGeoJsonFormat(schemaObj, { format: 'geojson' })('not an object'); // true (wrong type is not this format's business)
+ */
+export function compileGeoJsonFormat(schemaObj, jsonSchema) {
+  if (jsonSchema.format !== 'geojson')
+    throw new Error('Format is not equal to jsonSchema (should not happen!)');
+
+  const isGeoJson = geoFormatTesters['geojson'];
+
+  if (schemaObj.options.skipErrors) {
+    return function validateGeoJsonFormatFast(data, _dataPath) {
+      return data === null || typeof data !== 'object' || Array.isArray(data)
+        ? true
+        : isGeoJson(data);
+    };
+  }
+
+  const addError = schemaObj.createErrorHandler('geojson', 'format', isGeoJson.constructor.name);
+
+  return function validateGeoJsonFormat(data, dataPath) {
+    return data === null || typeof data !== 'object' || Array.isArray(data)
+      ? true
+      : isGeoJson(data) || addError(data, dataPath);
+  };
+}
+
+// =============================================================================
+// Aggregated Format Validators Object
+// =============================================================================
+
+/**
+ * Object mapping geospatial format names to their compiler functions.
+ *
+ * @type {Record<string, (schemaObj: ValidationObject, jsonSchema: JSONSchema) => (data: unknown, dataPath?: string) => boolean>}
+ */
+export const formatValidators = {
+  'geohash': compileGeohashFormat,
+  'wkt': compileWktFormat,
+  'geojson': compileGeoJsonFormat,
+};

package/src/index.js

@@ -21,11 +21,13 @@ export { formatValidators as dateTimeFormats } from './datetime.js';
 export { formatValidators as stringFormats } from './string.js';
 export { formatValidators as numberFormats } from './number.js';
 export { formatValidators as jsonFormats } from './json.js';
+export { formatValidators as geoFormats } from './geo.js';
 
 export {
   formatTesters,
   stringFormatTesters,
   jsonFormatTesters,
+  geoFormatTesters,
   dateTimeFormatTesters,
   numberFormatTesters,
 } from './testers.js';

package/src/json.js

@@ -71,6 +71,31 @@ export const compileRelativeJsonPointerFormat = createStringFormatCompiler('rela
  */
 export const compileJsonPathFormat = createStringFormatCompiler('json-path', jsonFormatTesters['json-path']);
 
+/**
+ * Compiles a validator for the 'json-path-segments' format.
+ * Validates a *variable-rooted* path string: `$name` followed by
+ * optional RFC 9535 segments (`$book.price[?@.isbn]`). Such a string is
+ * not a valid RFC 9535 query — the RFC's root identifier is `$` alone —
+ * so `json-path` would reject it; this format is what gives the Jaren
+ * query format's variable-rooted paths the same schema-time
+ * well-formedness that absolute paths get from `json-path`.
+ *
+ * Both formats recognize the five built-in function extensions and no
+ * others: a format is a property of the string itself, so it must mean
+ * the same thing in every schema regardless of which custom extensions
+ * a particular host registered.
+ *
+ * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ * @example
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book.price'); // true
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book'); // true
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$.price'); // false (that is json-path)
+ * compileJsonPathSegmentsFormat(schemaObj, { format: 'json-path-segments' })('$book.price['); // false
+ */
+export const compileJsonPathSegmentsFormat = createStringFormatCompiler('json-path-segments', jsonFormatTesters['json-path-segments']);
+
 // =============================================================================
 // Aggregated Format Validators Object
 // =============================================================================
@@ -87,4 +112,5 @@ export const formatValidators = {
   'relative-json-pointer': compileRelativeJsonPointerFormat,
   // JSONPath
   'json-path': compileJsonPathFormat,
+  'json-path-segments': compileJsonPathSegmentsFormat,
 };

package/src/string.js

@@ -1,5 +1,4 @@
 //@ts-check
-// eslint-disable no-useless-escape
 
 import {
   isStringType,
@@ -35,7 +34,7 @@ export function createStringFormatCompiler(formatName, isFormatTest) {
 
     // when skipErrors is true, we don't need to create error objects
     if (schemaObj.options.skipErrors) {
-      return function validateStringFormatFast(data, dataPath) {
+      return function validateStringFormatFast(data, _dataPath) {
         return isStringType(data)
           ? isFormatTest(data)
           : true;
@@ -183,6 +182,19 @@ export const compileColorFormat = createStringFormatCompiler('color', stringForm
  */
 export const compileRegexFormat = createStringFormatCompiler('regex', stringFormatTesters['regex']);
 
+/**
+ * Compiles a validator for the 'iregexp' format.
+ * Validates that a string is a valid I-Regexp (RFC 9485) pattern - the
+ * interoperable subset that carries the same meaning across regexp
+ * dialects. Stricter than 'regex': shorthand classes (\d, \w), lazy
+ * quantifiers, anchors and lookaround are all rejected.
+ *
+ * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
+ * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
+ * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
+ */
+export const compileIRegexpFormat = createStringFormatCompiler('iregexp', stringFormatTesters['iregexp']);
+
 // =============================================================================
 // URI Format Compilers
 // =============================================================================
@@ -199,16 +211,6 @@ export const compileRegexFormat = createStringFormatCompiler('regex', stringForm
  */
 export const compileUriFormat = createStringFormatCompiler('uri', stringFormatTesters['uri']);
 
-/**
- * Compiles a validator for the 'uri--full' format.
- * Validates absolute URI strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export const compileUriFullFormat = createStringFormatCompiler('uri--full', stringFormatTesters['uri--full']);
-
 /**
  * Compiles a validator for the 'uri-reference' format.
  * Validates URI reference strings (absolute or relative) per RFC 3986.
@@ -219,16 +221,6 @@ export const compileUriFullFormat = createStringFormatCompiler('uri--full', stri
  */
 export const compileUriReferenceFormat = createStringFormatCompiler('uri-reference', stringFormatTesters['uri-reference']);
 
-/**
- * Compiles a validator for the 'uri-reference--full' format.
- * Validates URI reference strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export const compileUriReferenceFullFormat = createStringFormatCompiler('uri-reference--full', stringFormatTesters['uri-reference--full']);
-
 /**
  * Compiles a validator for the 'uri-template' format.
  * Validates URI template strings per RFC 6570.
@@ -249,16 +241,6 @@ export const compileUriTemplateFormat = createStringFormatCompiler('uri-template
  */
 export const compileUrlFormat = createStringFormatCompiler('url', stringFormatTesters['url']);
 
-/**
- * Compiles a validator for the 'url--full' format.
- * Validates URL strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export const compileUrlFullFormat = createStringFormatCompiler('url--full', stringFormatTesters['url--full']);
-
 // =============================================================================
 // IRI Format Compilers (Internationalized Resource Identifiers)
 // =============================================================================
@@ -299,16 +281,6 @@ export const compileIriReferenceFormat = createStringFormatCompiler('iri-referen
  */
 export const compileEmailFormat = createStringFormatCompiler('email', stringFormatTesters['email']);
 
-/**
- * Compiles a validator for the 'email--full' format.
- * Validates email address strings with stricter checking.
- *
- * @param {ValidationObject} schemaObj - The validation JSONSchema for error handling and options
- * @param {JSONSchema} jsonSchema - The JSON schema containing the format definition
- * @returns {(data: unknown, dataPath?: string) => boolean} A validator function
- */
-export const compileEmailFullFormat = createStringFormatCompiler('email--full', stringFormatTesters['email--full']);
-
 /**
  * Compiles a validator for the 'idn-email' format.
  * Validates internationalized email addresses (EAI) per RFC 6531.
@@ -510,20 +482,17 @@ export const formatValidators = {
   'color': compileColorFormat,
   // Regex
   'regex': compileRegexFormat,
+  'iregexp': compileIRegexpFormat,
   // URI
   'uri': compileUriFormat,
-  'uri--full': compileUriFullFormat,
   'uri-reference': compileUriReferenceFormat,
-  'uri-reference--full': compileUriReferenceFullFormat,
   'uri-template': compileUriTemplateFormat,
   'url': compileUrlFormat,
-  'url--full': compileUrlFullFormat,
   // IRI
   'iri': compileIriFormat,
   'iri-reference': compileIriReferenceFormat,
   // Email
   'email': compileEmailFormat,
-  'email--full': compileEmailFullFormat,
   'idn-email': compileIdnEmailFormat,
   // Hostname
   'hostname': compileHostnameFormat,

package/src/testers.js

@@ -23,14 +23,10 @@
 
 import {
   isValidUri,
-  isValidUriFull,
   isValidUriRef,
-  isValidUriRefFull,
   isValidUriTemplate,
   isValidUrl,
-  isValidUrlFull,
   isValidEmail,
-  isValidEmailFull,
   isValidIdnEmail,
   isValidHostname,
   isValidIdnHostname,
@@ -54,6 +50,7 @@ import {
   isValidBase64,
   isValidCountryAlpha2,
   isValidIBAN,
+  isValidIRegexp,
 } from '@jarenjs/core/text';
 
 import {
@@ -93,8 +90,15 @@ import {
   isValidJSONPointerUriFragment,
   isValidRelativeJSONPointer,
   isValidJSONPathStrict,
+  isValidJSONPathSegments,
 } from '@jarenjs/json';
 
+import {
+  isValidGeohash,
+  isValidWkt,
+  isValidGeoJson,
+} from '@jarenjs/core/geo';
+
 /** @typedef {(value: string) => boolean} StringFormatTester */
 /** @typedef {(value: number) => boolean} NumberFormatTester */
 
@@ -118,20 +122,17 @@ export const stringFormatTesters = {
   'color': isValidHexColor,
   // Regex
   'regex': isStringRegExp,
+  'iregexp': isValidIRegexp,
   // URI
   'uri': isValidUri,
-  'uri--full': isValidUriFull,
   'uri-reference': isValidUriRef,
-  'uri-reference--full': isValidUriRefFull,
   'uri-template': isValidUriTemplate,
   'url': isValidUrl,
-  'url--full': isValidUrlFull,
   // IRI
   'iri': isValidIRI,
   'iri-reference': isValidIRIRef,
   // Email
   'email': isValidEmail,
-  'email--full': isValidEmailFull,
   'idn-email': isValidIdnEmail,
   // Hostname
   'hostname': isValidHostname,
@@ -164,6 +165,7 @@ export const jsonFormatTesters = {
   'json-pointer-uri-fragment': isValidJSONPointerUriFragment,
   'relative-json-pointer': isValidRelativeJSONPointer,
   'json-path': isValidJSONPathStrict,
+  'json-path-segments': isValidJSONPathSegments,
 };
 
 /**
@@ -180,6 +182,19 @@ export const dateTimeFormatTesters = {
   'iso-time': isValidISOTime,
 };
 
+/**
+ * Geospatial format testers (the geo.js compiler group). `geohash` and
+ * `wkt` take strings; `geojson` takes the OBJECT value — the quick
+ * yes-or-no twin of the GeoJSON meta-schema artifacts in `@jarenjs/json`,
+ * including the ring-closure invariant JSON Schema cannot express.
+ * @type {Record<string, (value: any) => boolean>}
+ */
+export const geoFormatTesters = {
+  'geohash': isValidGeohash,
+  'wkt': isValidWkt,
+  'geojson': isValidGeoJson,
+};
+
 /**
  * Number format testers (the number.js compiler group). These take the
  * NUMBER value, not a string.
@@ -211,6 +226,7 @@ export const numberFormatTesters = {
 export const formatTesters = {
   ...stringFormatTesters,
   ...jsonFormatTesters,
+  ...geoFormatTesters,
   ...dateTimeFormatTesters,
   ...numberFormatTesters,
 };