shelving 1.117.0 → 1.117.2

package/error/EnhancedError.d.ts

@@ -3,7 +3,7 @@
  * - Context is appended to `.message` in the format `message: debuggedContext`
  * - Context is converted to a string using `debug()`
  */
-export declare class EnhancedError extends global.Error {
+export declare class EnhancedError extends Error {
     readonly context: unknown;
     constructor(message: string, context?: unknown);
 }

package/error/EnhancedError.js

@@ -4,7 +4,7 @@ import { debug } from "../util/debug.js";
  * - Context is appended to `.message` in the format `message: debuggedContext`
  * - Context is converted to a string using `debug()`
  */
-export class EnhancedError extends global.Error {
+export class EnhancedError extends Error {
     context;
     constructor(message, context) {
         const debugged = context !== undefined ? debug(context, 2) : "";

package/error/{AssertionError.d.ts → StateError.d.ts}

@@ -1,7 +1,7 @@
 import type { ErrorCode } from "../util/error.js";
 import { EnhancedError } from "./EnhancedError.js";
-/** Thrown if the is in a state . */
-export declare class AssertionError extends EnhancedError {
+/** Thrown if the state of the program is correct to execute a given operation. */
+export declare class StateError extends EnhancedError {
     readonly code: ErrorCode;
     constructor(message?: string, context?: unknown);
 }

package/error/{AssertionError.js → StateError.js}

@@ -1,9 +1,9 @@
 import { EnhancedError } from "./EnhancedError.js";
-/** Thrown if the is in a state . */
-export class AssertionError extends EnhancedError {
+/** Thrown if the state of the program is correct to execute a given operation. */
+export class StateError extends EnhancedError {
     code = "failed-precondition";
     constructor(message = "Failed precondition", context) {
         super(message, context);
     }
 }
-AssertionError.prototype.name = "AssertionError";
+StateError.prototype.name = "StateError";

package/error/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./AssertionError.js";
+export * from "./StateError.js";
 export * from "./ConnectionError.js";
 export * from "./PermissionError.js";
 export * from "./RequiredError.js";

package/error/index.js

@@ -1,4 +1,4 @@
-export * from "./AssertionError.js";
+export * from "./StateError.js";
 export * from "./ConnectionError.js";
 export * from "./PermissionError.js";
 export * from "./RequiredError.js";

package/iterate/InspectGenerator.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { StateError } from "../error/StateError.js";
 import { ThroughGenerator } from "./ThroughGenerator.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectGenerator.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectGenerator extends ThroughGenerator {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new AssertionError("Iteration not started");
+            throw new StateError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new AssertionError("Iteration not started");
+            throw new StateError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new AssertionError("Iteration not done");
+            throw new StateError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.117.0",
+	"version": "1.117.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/react/createCacheContext.js

@@ -1,5 +1,5 @@
 import { createContext, createElement, useContext, useRef } from "react";
-import { AssertionError } from "../error/AssertionError.js";
+import { StateError } from "../error/StateError.js";
 /**
  * Create a cache context that can be provided to React elements and allows them to call `useCache()`
  * - Cache is a `Map` indexed by strings that can be used to store any value.
@@ -10,7 +10,7 @@ export function createCacheContext() {
         useCache() {
             const cache = useContext(context);
             if (!cache)
-                throw new AssertionError("useCache() must be used inside <Cache>");
+                throw new StateError("useCache() must be used inside <Cache>");
             return cache;
         },
         CacheContext({ children }) {

package/sequence/InspectSequence.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { StateError } from "../error/StateError.js";
 import { ThroughSequence } from "./ThroughSequence.js";
 /** Used when the sequence hasn't inspected anything yet. */
 const _NOVALUE = Symbol("shelving/InspectSequence.NOVALUE");
@@ -20,21 +20,21 @@ export class InspectSequence extends ThroughSequence {
     /** The first yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get first() {
         if (this._first === _NOVALUE)
-            throw new AssertionError("Iteration not started");
+            throw new StateError("Iteration not started");
         return this._first;
     }
     _first = _NOVALUE;
     /** The last yielded value (throws if the iteration yielded no values, i.e. `this.count === 0`). */
     get last() {
         if (this._last === _NOVALUE)
-            throw new AssertionError("Iteration not started");
+            throw new StateError("Iteration not started");
         return this._last;
     }
     _last = _NOVALUE;
     /** The returned value (throws if the iteration is not done, i.e. `this.done === false`). */
     get returned() {
         if (this._returned === _NOVALUE)
-            throw new AssertionError("Iteration not done");
+            throw new StateError("Iteration not done");
         return this._returned;
     }
     _returned = _NOVALUE;

package/util/array.js

@@ -1,5 +1,5 @@
-import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
+import { ValueError } from "../error/ValueError.js";
 import { omitItems, pickItems } from "./iterate.js";
 import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
@@ -7,14 +7,14 @@ export const isArray = (value) => Array.isArray(value);
 /** Assert that an unknown value is an array. */
 export function assertArray(arr) {
     if (!isArray(arr))
-        throw new AssertionError(`Must be array`, arr);
+        throw new ValueError(`Must be array`, arr);
 }
 /** Is an unknown value an item in a specified array? */
 export const isArrayItem = (arr, item) => arr.includes(item);
 /** Assert that an unknown value is an item in a specified array. */
 export function assertArrayItem(arr, item) {
     if (!isArrayItem(arr, item))
-        throw new AssertionError(`Must be array item`, item);
+        throw new ValueError(`Must be array item`, item);
 }
 /** Convert an iterable to an array (if its not already an array). */
 export function getArray(items) {
@@ -141,7 +141,7 @@ export function isArrayLength(arr, min = 1, max = Infinity) {
 }
 export function assertArrayLength(arr, min = 1, max = Infinity) {
     if (!isArray(arr) || !isArrayLength(arr, min, max))
-        throw new AssertionError(`Must be array with length ${formatRange(min, max)}`, arr);
+        throw new ValueError(`Must be array with length ${formatRange(min, max)}`, arr);
 }
 export function getArrayLength(arr, min = 1, max = Infinity) {
     assertArrayLength(arr, min, max);

package/util/assert.js

@@ -1,11 +1,11 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Assert two values are equal. */
 export function assertEqual(left, right) {
     if (left !== right)
-        throw new AssertionError(`Must be equal`, { left, right });
+        throw new ValueError(`Must be equal`, { left, right });
 }
 /** Assert two values are equal. */
 export function assertNot(left, right) {
     if (left === right)
-        throw new AssertionError(`Must not be equal`, { left, right });
+        throw new ValueError(`Must not be equal`, { left, right });
 }

package/util/async.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Is a value an asynchronous value implementing a `then()` function. */
 export const isAsync = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
 /** Is a value a synchronous value. */
@@ -16,17 +16,17 @@ export function throwAsync(value) {
 /** Assert a synchronous value. */
 export function assertNotAsync(value) {
     if (isAsync(value))
-        throw new AssertionError("Must be synchronous", value);
+        throw new ValueError("Must be synchronous", value);
 }
 /** Assert an asynchronous value. */
 export function assertAsync(value) {
     if (!isAsync(value))
-        throw new AssertionError("Must be asynchronous", value);
+        throw new ValueError("Must be asynchronous", value);
 }
 /** Assert a promise. */
 export function assertPromise(value) {
     if (!(value instanceof Promise))
-        throw new AssertionError("Must be promise", value);
+        throw new ValueError("Must be promise", value);
 }
 /** Run any queued microtasks now. */
 export function runMicrotasks() {

package/util/class.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { debug } from "./debug.js";
 /** Is a given value a class constructor? */
 export const isConstructor = (value) => typeof value === "function" && value.toString().startsWith("class");
@@ -7,5 +7,5 @@ export const isInstance = (value, type) => value instanceof type;
 /** Assert that a value is an instance of something. */
 export function assertInstance(value, type) {
     if (!(value instanceof type))
-        throw new AssertionError(`Must be instance of ${debug(type)}`, value);
+        throw new ValueError(`Must be instance of ${debug(type)}`, value);
 }

package/util/color.js

@@ -65,7 +65,7 @@ export const isColor = (value) => value instanceof Color;
 /** Assert that an unknown value is a `Color` instance. */
 export function assertColor(value) {
     if (!isColor(value))
-        throw new ValueError("Invalid color", value);
+        throw new ValueError("Must be color", value);
 }
 /** Convert a possible color to a `Color` instance or `undefined` */
 export function getOptionalColor(possible) {

package/util/data.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
 import { isObject, isPlainObject } from "./object.js";
 /** Is an unknown value a data object? */
@@ -6,14 +6,14 @@ export const isData = (value) => isPlainObject(value);
 /** Assert that an unknown value is a data object. */
 export function assertData(value) {
     if (!isPlainObject(value))
-        throw new AssertionError("Must be data", value);
+        throw new ValueError("Must be data", value);
 }
 /** Is an unknown value the key for an own prop of a data object. */
 export const isDataProp = (data, key) => typeof key === "string" && Object.hasOwn(data, key);
 /** Assert that an unknown value is the key for an own prop of a data object. */
 export function assertDataProp(data, key) {
     if (!isDataProp(data, key))
-        throw new AssertionError("Must be data prop", key);
+        throw new ValueError("Must be data prop", key);
 }
 export function getData(input) {
     return isIterable(input) ? Object.fromEntries(input) : input;

package/util/date.js

@@ -50,7 +50,7 @@ export function getOptionalDate(possible = "now") {
 export function getDate(possible) {
     const date = getOptionalDate(possible);
     if (!date)
-        throw new ValueError(`Must be date`, possible);
+        throw new ValueError(`Invalid date`, possible);
     return date;
 }
 /** Convert an unknown value to a timestamp (milliseconds past Unix epoch), or `undefined` if it couldn't be converted. */

package/util/dictionary.js

@@ -1,4 +1,3 @@
-import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
@@ -22,7 +21,7 @@ export const isDictionaryItem = (obj, key) => typeof key === "string" && Object.
 /** Assert that an unknown value is the key for an own prop of a dictionary. */
 export function assertDictionaryItem(obj, key) {
     if (!isDictionaryItem(obj, key))
-        throw new AssertionError("Must be dictionary item", key);
+        throw new ValueError("Must be dictionary item", key);
 }
 /** Get an item in a map or throw an error if it doesn't exist. */
 export function getDictionaryItem(obj, key) {

package/util/hydrate.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isArray } from "./array.js";
 import { isDate } from "./date.js";
 import { isMap } from "./map.js";
@@ -31,7 +31,7 @@ export function hydrate(value, hydrations) {
         const hydration = hydrations[$type];
         if (hydration)
             return { __proto__: hydration.prototype, ...mapObject($value, hydrate, hydrations) };
-        throw new AssertionError(`Cannot hydrate "${$type}" object`, value);
+        throw new ValueError(`Cannot hydrate "${$type}" object`, value);
     }
     return value;
 }
@@ -62,7 +62,7 @@ export function dehydrate(value, hydrations) {
             for (const [$type, hydration] of getProps(hydrations))
                 if (proto === hydration.prototype)
                     return { $type, $value: mapObject(value, dehydrate, hydrations) };
-            throw new AssertionError(`Cannot dehydrate object`, value);
+            throw new ValueError(`Cannot dehydrate object`, value);
         }
     }
     return value;

package/util/map.js

@@ -1,5 +1,5 @@
-import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isIterable, limitItems } from "./iterate.js";
 /** Class for a `Map` that cannot be changed (so you can extend `Map` while implementing `ImmutableMap`). */
 export const ImmutableMap = Map;
@@ -8,14 +8,14 @@ export const isMap = (value) => value instanceof Map;
 /** Assert that a value is a `Map` instance. */
 export function assertMap(value) {
     if (!isMap(value))
-        throw new AssertionError("Must be map", value);
+        throw new ValueError("Must be map", value);
 }
 /** Is an unknown value a key for an item in a map? */
 export const isMapItem = (map, key) => map.has(key);
 /** Assert that an unknown value is a key for an item in a map. */
 export function assertMapItem(map, key) {
     if (!isMapItem(map, key))
-        throw new AssertionError("Must be map item", key);
+        throw new ValueError("Must be map item", key);
 }
 export function getMap(input) {
     return isMap(input) ? input : new Map(isIterable(input) ? input : Object.entries(input));

package/util/null.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Function that always returns null. */
 export const getNull = () => null;
 /** Is a value null? */
@@ -6,14 +6,14 @@ export const isNull = (value) => value === null;
 /** Assert that a value is not null. */
 export function assertNull(value) {
     if (value !== null)
-        throw new AssertionError("Must be null", value);
+        throw new ValueError("Must be null", value);
 }
 /** Is a value not null? */
 export const notNull = (value) => value !== null;
 /** Assert that a value is not null. */
 export function assertNotNull(value) {
     if (value === null)
-        throw new AssertionError("Must not be null", value);
+        throw new ValueError("Must not be null", value);
 }
 /** Get the not-nullish version of value. */
 export function getNotNull(value) {
@@ -25,14 +25,14 @@ export const isNullish = (value) => value === null || value === undefined;
 /** Assert that a value is not nullish. */
 export function assertNullish(value) {
     if (value !== null && value !== undefined)
-        throw new AssertionError("Must be null or undefined", value);
+        throw new ValueError("Must be null or undefined", value);
 }
 /** Is a value not nullish? */
 export const notNullish = (value) => value !== null && value !== undefined;
 /** Assert that a value is not nullish. */
 export function assertNotNullish(value) {
     if (value === null || value === undefined)
-        throw new AssertionError("Must not be null or undefined", value);
+        throw new ValueError("Must not be null or undefined", value);
 }
 /** Get the not-nullish version of value. */
 export function getNotNullish(value) {

package/util/object.js

@@ -1,11 +1,11 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isIterable } from "./iterate.js";
 /** Is an unknown value an unknown object? */
 export const isObject = (value) => typeof value === "object" && value !== null;
 /** Assert that a value is an object */
 export function assertObject(value) {
     if (!isObject(value))
-        throw new AssertionError("Must be object", value);
+        throw new ValueError("Must be object", value);
 }
 /** Is an unknown value a plain object? */
 export function isPlainObject(value) {
@@ -18,14 +18,14 @@ export function isPlainObject(value) {
 /** Assert that an unknown value is a plain object */
 export function assertPlainObject(value) {
     if (!isPlainObject(value))
-        throw new AssertionError(`Must be plain object`, value);
+        throw new ValueError(`Must be plain object`, value);
 }
 /** Is an unknown value the key for an own prop of an object. */
 export const isProp = (obj, key) => Object.hasOwn(obj, key);
 /** Assert that an unknown value is the key for an own prop of an object. */
 export function assertProp(obj, key) {
     if (!isProp(obj, key))
-        throw new AssertionError("Must be object prop", key);
+        throw new ValueError("Must be object prop", key);
 }
 /** Turn a possible object into an object. */
 export function getObject(obj) {

package/util/path.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 /** Is a string path an absolute path? */
 export const isAbsolutePath = (path) => path.startsWith("/");
 /** Is a string path an absolute path? */
@@ -22,7 +22,7 @@ export function getPath(path, base = _LOCATION) {
         return cleanPath(new URL(path, `http://j.com${typeof base === "string" ? base : base.pathname}/`).pathname);
     }
     catch {
-        throw new AssertionError("Invalid path", path);
+        throw new ValueError("Invalid path", path);
     }
 }
 const _LOCATION = typeof window === "object" ? window.location : "/";

package/util/serialise.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isArray } from "./array.js";
 import { getPrototype, isObject } from "./object.js";
 const R_QUOTE = /"/g;
@@ -39,7 +39,7 @@ export function serialise(value) {
         const props = Object.entries(value).map(serialiseEntry).sort();
         return `{${type ? `"$type":${escapeString(type)}${props.length ? "," : ""}` : ""}${props.join(",")}}`;
     }
-    throw new AssertionError("serialize(): Unknown value", value);
+    throw new ValueError("Cannot serialize value", value);
 }
 const serialiseEntry = ([key, value]) => `${escapeString(key)}:${serialise(value)}`;
 const escapeString = (str) => `"${str.replace(R_QUOTE, `\\"`)}"`;

package/util/set.js

@@ -1,18 +1,18 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { limitItems } from "./iterate.js";
 /** Is an unknown value a set? */
 export const isSet = (value) => value instanceof Set;
 /** Assert that a value is a `Set` instance. */
 export function assertSet(value) {
     if (!isSet(value))
-        throw new AssertionError(`Must be set`, value);
+        throw new ValueError(`Must be set`, value);
 }
 /** Is an unknown value an item in a set? */
 export const isSetItem = (set, item) => set.has(item);
 /** Assert that an unknown value is an item in a set. */
 export function assertSetItem(set, item) {
     if (!isSetItem(set, item))
-        throw new AssertionError("Must be set item", item);
+        throw new ValueError("Must be set item", item);
 }
 /** Convert an iterable to a `Set` (if it's already a `Set` it passes through unchanged). */
 export function getSet(iterable) {

package/util/source.js

@@ -1,4 +1,4 @@
-import { AssertionError } from "../error/AssertionError.js";
+import { ValueError } from "../error/ValueError.js";
 import { isObject } from "./object.js";
 /**
  * Recurse through `Sourceable` objects and return the first one that is an instance of `type`, or `null` if no source object matches.
@@ -17,6 +17,6 @@ export function getOptionalSource(type, value) {
 export function getSource(type, data) {
     const source = getOptionalSource(type, data);
     if (!source)
-        throw new AssertionError(`Source "${type.name}" not found`, data);
+        throw new ValueError(`Source "${type.name}" not found`, data);
     return source;
 }

package/util/string.d.ts

@@ -72,7 +72,7 @@ export declare const getOptionalSlug: (str: string) => string | undefined;
 export declare function getSlug(str: string): string;
 /** Convert a string to a unique ref e.g. `abc123`, or return `undefined` if conversion resulted in an empty ref. */
 export declare const getOptionalRef: (str: string) => string | undefined;
-/** Convert a string to a unique ref e.g. `abc123`, or throw `AssertionError` if conversion resulted in an empty ref. */
+/** Convert a string to a unique ref e.g. `abc123`, or throw `ValueError` if conversion resulted in an empty ref. */
 export declare function getRef(str: string): string;
 /**
  * Return an array of the separate words and "quoted phrases" found in a string.
@@ -100,8 +100,8 @@ export declare function limitString(str: string, maxLength: number, append?: str
  * - Excess segments in `String.prototype.split()` is counterintuitive because further parts are thrown away.
  * - Excess segments in `splitString()` are concatenated onto the last segment (set `max` to `null` if you want infinite segments).
  *
- * @throws AssertionError if `min` isn't met.
- * @throws AssertionError if any of the segments are empty.
+ * @throws ValueError if `min` isn't met.
+ * @throws ValueError if any of the segments are empty.
  */
 export declare function splitString(str: string, separator: string, min: 1, max: 1): readonly [string];
 export declare function splitString(str: string, separator: string, min: 2, max: 2): readonly [string, string];

package/util/string.js

@@ -1,5 +1,4 @@
 /* eslint-disable no-control-regex */
-import { AssertionError } from "../error/AssertionError.js";
 import { ValueError } from "../error/ValueError.js";
 import { getArray, isArray } from "./array.js";
 import { formatDate, isDate } from "./date.js";
@@ -51,7 +50,7 @@ export const isStringLength = (str, min = 1, max = Infinity) => str.length >= mi
 /** Assert that a value has a specific length (or length is in a specific range). */
 export function assertStringLength(str, min = 1, max = Infinity) {
     if (!isString(str) || !isStringLength(str, min, max))
-        throw new AssertionError(`Must be string with length ${formatRange(min, max)}`, str);
+        throw new ValueError(`Must be string with length ${formatRange(min, max)}`, str);
 }
 /** Get a string if it has the specified minimum length.  */
 export function getStringLength(str, min = 1, max = Infinity) {
@@ -111,21 +110,21 @@ export const simplifyString = (str) => str
     .toLowerCase();
 /** Convert a string to a `kebab-case` URL slug, or return `undefined` if conversion resulted in an empty ref. */
 export const getOptionalSlug = (str) => simplifyString(str).replace(/ /g, "-") || undefined;
-/* Convert a string to a `kebab-case` URL slug, or throw `AssertionError` if conversion resulted in an empty ref. */
+/* Convert a string to a `kebab-case` URL slug, or throw `ValueError` if conversion resulted in an empty ref. */
 export function getSlug(str) {
     const slug = getOptionalSlug(str);
     if (slug)
         return slug;
-    throw new AssertionError("Invalid slug", str);
+    throw new ValueError("Invalid slug", str);
 }
 /** Convert a string to a unique ref e.g. `abc123`, or return `undefined` if conversion resulted in an empty ref. */
 export const getOptionalRef = (str) => simplifyString(str).replace(/ /g, "") || undefined;
-/** Convert a string to a unique ref e.g. `abc123`, or throw `AssertionError` if conversion resulted in an empty ref. */
+/** Convert a string to a unique ref e.g. `abc123`, or throw `ValueError` if conversion resulted in an empty ref. */
 export function getRef(str) {
     const ref = getOptionalRef(str);
     if (ref)
         return ref;
-    throw new AssertionError("Invalid string ref", str);
+    throw new ValueError("Invalid string ref", str);
 }
 /**
  * Return an array of the separate words and "quoted phrases" found in a string.
@@ -168,6 +167,6 @@ export function splitString(str, separator, min = 1, max = Infinity) {
     if (segments.length > max)
         segments.splice(max - 1, segments.length, segments.slice(max - 1).join(separator));
     if (segments.length < min || !segments.every(Boolean))
-        throw new AssertionError(`Must be string with ${formatRange(min, max)} non-empty segments separated by "${separator}"`, str);
+        throw new ValueError(`Must be string with ${formatRange(min, max)} non-empty segments separated by "${separator}"`, str);
     return segments;
 }

package/util/template.js

@@ -1,3 +1,4 @@
+import { ValueError } from "../error/ValueError.js";
 import { EMPTY_DATA } from "./data.js";
 import { setMapItem } from "./map.js";
 import { isObject } from "./object.js";
@@ -27,7 +28,7 @@ function _split(template) {
         const placeholder = matches[i];
         const post = matches[i + 1];
         if (i > 1 && !pre.length)
-            throw new SyntaxError("Placeholders must be separated by at least one character");
+            throw new ValueError("Placeholders must be separated by at least one character", template);
         const name = placeholder === "*" ? String(asterisks++) : R_NAME.exec(placeholder)?.[0] || "";
         chunks.push({ pre, placeholder, name, post });
     }

package/util/time.js

@@ -98,7 +98,7 @@ export function getOptionalTime(possible) {
 export function getTime(possible) {
     const time = getOptionalTime(possible);
     if (!time)
-        throw new ValueError(`Must be time`, possible);
+        throw new ValueError(`Invalid time`, possible);
     return time;
 }
 /** Get the time as in `hh:mm` format (hours, minutes), e.g. `13.59` */

package/util/units.js

@@ -1,5 +1,5 @@
-import { AssertionError } from "../error/AssertionError.js";
 import { RequiredError } from "../error/RequiredError.js";
+import { ValueError } from "../error/ValueError.js";
 import { DAY, HOUR, MILLION, MINUTE, MONTH, NNBSP, SECOND, WEEK, YEAR } from "./constants.js";
 import { ImmutableMap } from "./map.js";
 import { formatQuantity, pluralizeQuantity } from "./number.js";
@@ -63,7 +63,7 @@ export class Unit {
         if (thisToBase)
             return base._toUnit(_convert(amount, thisToBase), unit);
         // Cannot convert.
-        throw new AssertionError(`Cannot convert "${this.key}" to "${unit.key}"`);
+        throw new ValueError(`Cannot convert "${this.key}" to "${unit.key}"`);
     }
     /** Format an amount with a given unit of measure, e.g. `12 kg` or `29.5 l` */
     format(amount, options) {