semola 0.5.4 → 0.6.0

package/dist/lib/cache/index.mjs

@@ -1,4 +1,36 @@
-import { err, mightThrow, mightThrowSync, ok } from "../errors/index.mjs";
+import { mightThrow, mightThrowSync } from "../errors/index.mjs";
+//#region src/lib/cache/errors.ts
+var CacheError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CacheError";
+	}
+};
+var InvalidTTLError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidTTLError";
+	}
+};
+var NotFoundError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "NotFoundError";
+	}
+};
+var SerializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SerializationError";
+	}
+};
+var DeserializationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DeserializationError";
+	}
+};
+//#endregion
 //#region src/lib/cache/index.ts
 var Cache = class {
 	options;
@@ -10,41 +42,34 @@ var Cache = class {
 		this.deserialize = options.deserializer ?? ((raw) => JSON.parse(raw));
 	}
 	async get(key) {
-		if (!this.isEnabled) return this.fail("NotFoundError", `Key ${key} not found`);
+		if (!this.isEnabled) throw new NotFoundError(`Key ${key} not found`);
 		const resolvedKey = this.resolveKey(key);
 		const [error, value] = await mightThrow(this.options.redis.get(resolvedKey));
-		if (error) return this.fail("CacheError", `Unable to get value for key ${key}`);
-		if (value === null || value === void 0) return this.fail("NotFoundError", `Key ${key} not found`);
+		if (error) throw new CacheError(`Unable to get value for key ${key}`);
+		if (value === null || value === void 0) throw new NotFoundError(`Key ${key} not found`);
 		const [deserializeErr, deserialized] = mightThrowSync(() => this.deserialize(value));
-		if (deserializeErr) return this.fail("CacheError", `Unable to deserialize value for key ${key}`);
-		return ok(deserialized);
+		if (deserializeErr) throw new DeserializationError(`Unable to deserialize value for key ${key}`);
+		return deserialized;
 	}
 	async set(key, value) {
-		if (!this.isEnabled) return ok(value);
+		if (!this.isEnabled) return value;
 		const [serializeErr, serialized] = mightThrowSync(() => this.serialize(value));
-		if (serializeErr) return this.fail("CacheError", `Unable to serialize value for key ${key}`);
-		if (serialized === null || serialized === void 0) return this.fail("CacheError", `Unable to serialize value for key ${key}`);
+		if (serializeErr) throw new SerializationError(`Unable to serialize value for key ${key}`);
+		if (serialized === null || serialized === void 0) throw new SerializationError(`Unable to serialize value for key ${key}`);
 		const [ttlErr, ttl] = mightThrowSync(() => this.resolveTTL(key, value));
-		if (ttlErr) return this.fail("InvalidTTLError", `Unable to resolve ttl for key ${key}`);
-		if (!this.isTTLValid(ttl)) return this.fail("InvalidTTLError", `Unable to save records with ttl equal to ${ttl}`);
+		if (ttlErr) throw new InvalidTTLError(`Unable to resolve ttl for key ${key}`);
+		if (!this.isTTLValid(ttl)) throw new InvalidTTLError(`Unable to save records with ttl equal to ${ttl}`);
 		const resolvedKey = this.resolveKey(key);
 		const [setError] = await mightThrow(this.getSetPromise(resolvedKey, serialized, ttl));
-		if (setError) return this.fail("CacheError", `Unable to set value for key ${key}`);
-		return ok(value);
+		if (setError) throw new CacheError(`Unable to set value for key ${key}`);
+		return value;
 	}
 	async delete(key) {
-		if (!this.isEnabled) return ok(0);
+		if (!this.isEnabled) return 0;
 		const resolvedKey = this.resolveKey(key);
 		const [error, data] = await mightThrow(this.options.redis.del(resolvedKey));
-		if (error) return this.fail("CacheError", `Unable to delete key ${key}`);
-		return ok(data);
-	}
-	fail(type, message) {
-		this.options.onError?.({
-			type,
-			message
-		});
-		return err(type, message);
+		if (error) throw new CacheError(`Unable to delete key ${key}`);
+		return data;
 	}
 	get isEnabled() {
 		return this.options.enabled !== false;

package/dist/lib/cron/index.cjs

@@ -185,6 +185,38 @@ const Month = {
 	dec: 12
 };
 //#endregion
+//#region src/lib/cron/errors.ts
+var InvalidValueError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidValueError";
+	}
+};
+var OutOfBoundError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OutOfBoundError";
+	}
+};
+var CronExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CronExpressionError";
+	}
+};
+var EmptyCronExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EmptyCronExpressionError";
+	}
+};
+var CronLengthError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CronLengthError";
+	}
+};
+//#endregion
 //#region src/lib/cron/core/scanner.ts
 const FieldAmount = {
 	min: 5,
@@ -237,21 +269,20 @@ var Scanner = class {
 		this.tokens = [];
 	}
 	scan() {
-		if (this.expression.length === 0) return require_lib_errors_index.err("EmptyCronExpressionError", "Cron expression have zero length");
+		if (this.expression.length === 0) throw new EmptyCronExpressionError("Cron expression have zero length");
 		const fields = this.expression.trim().split(/\s+/);
 		const hasMinLen = fields.length === FieldAmount.min;
 		const hasMaxLen = fields.length === FieldAmount.max;
-		if (!hasMinLen && !hasMaxLen) return require_lib_errors_index.err("CronLengthError", `Invalid number of fields for '${this.expression}'. Expected 5 or 6 fields but got ${fields.length} field(s)`);
+		if (!hasMinLen && !hasMaxLen) throw new CronLengthError(`Invalid number of fields for '${this.expression}'. Expected 5 or 6 fields but got ${fields.length} field(s)`);
 		const components = this.createComponent(fields);
 		for (let idx = 0; idx < components.length; idx++) {
 			const component = components[idx];
-			if (!component) return require_lib_errors_index.err("CronExpressionError", `Invalid cron expression: ${this.expression}`);
+			if (!component) throw new CronExpressionError(`Invalid cron expression: ${this.expression}`);
 			this.current = 0;
 			this.start = 0;
-			const [error, _] = this.scanComponent(component);
-			if (error) return require_lib_errors_index.err(error.type, error.message);
+			this.scanComponent(component);
 		}
-		return require_lib_errors_index.ok(this.tokens);
+		return this.tokens;
 	}
 	scanComponent(component) {
 		const { field, content } = component;
@@ -260,36 +291,30 @@ var Scanner = class {
 			switch (currentCh) {
 				case "*": {
 					const ch = this.peek(content);
-					if (this.match(content, "/")) {
-						const [error, _] = this.handleStep(component);
-						if (error) return require_lib_errors_index.err(error.type, error.message);
-					} else if (!ch || ch === ",") this.addToken("*", "any", "*", field);
-					else return require_lib_errors_index.err("CronExpressionError", `Invalid any expression '${content}' for field '${field}'`);
+					if (this.match(content, "/")) this.handleStep(component);
+					else if (!ch || ch === ",") this.addToken("*", "any", "*", field);
+					else throw new CronExpressionError(`Invalid any expression '${content}' for field '${field}'`);
 					break;
 				}
 				case "-":
 					currentCh = this.advance(content);
-					if (this.isDigit(currentCh)) {
-						const [error, _] = this.handleRangeWithStep(component);
-						if (error) return require_lib_errors_index.err(error.type, error.message);
-					} else return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+					if (this.isDigit(currentCh)) this.handleRangeWithStep(component);
+					else throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 					break;
 				case ",": {
-					if (this.current === 1 && this.start === 0) return require_lib_errors_index.err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					if (this.current === 1 && this.start === 0) throw new CronExpressionError(`Invalid list expression '${content}' for field '${field}'`);
 					const next = this.peek(content);
-					if (!next || next === ",") return require_lib_errors_index.err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					if (!next || next === ",") throw new CronExpressionError(`Invalid list expression '${content}' for field '${field}'`);
 					break;
 				}
 				default:
-					if (this.isDigit(currentCh)) {
-						const [error, _] = this.handleNumber(component);
-						if (error) return require_lib_errors_index.err(error.type, error.message);
-					} else return require_lib_errors_index.err("CronExpressionError", `Invalid cron expression '${this.expression}' in field '${field}'`);
+					if (this.isDigit(currentCh)) this.handleNumber(component);
+					else throw new CronExpressionError(`Invalid cron expression '${this.expression}' in field '${field}'`);
 					break;
 			}
 			this.start = this.current;
 		}
-		return require_lib_errors_index.ok(true);
+		return true;
 	}
 	addToken(component, type, value, field) {
 		const token = new Token(component, type, value, field);
@@ -318,12 +343,12 @@ var Scanner = class {
 			this.advance(content);
 			ch = this.peek(content);
 		}
-		if (ch && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		if (ch && ch !== ",") throw new CronExpressionError(`Invalid step expression '${content}' for field '${field}'`);
 		const tokenContent = content.substring(this.start, this.current);
 		const value = content.slice(slashIdx + 1, this.current);
-		if (value.length === 0) return require_lib_errors_index.err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		if (value.length === 0) throw new CronExpressionError(`Invalid step expression '${content}' for field '${field}'`);
 		this.addToken(tokenContent, "step", Number(value), field);
-		return require_lib_errors_index.ok(true);
+		return true;
 	}
 	handleRangeWithStep(component) {
 		const { field, content } = component;
@@ -332,13 +357,12 @@ var Scanner = class {
 			this.advance(content);
 			ch = this.peek(content);
 		}
-		if (!ch) return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return require_lib_errors_index.err(error.type, error.message);
-			return require_lib_errors_index.ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 	}
 	handleNumber(component) {
 		const { field, content } = component;
@@ -351,27 +375,25 @@ var Scanner = class {
 		if (!ch) {
 			const item = content.substring(this.start);
 			this.addToken(item, "number", Number(item), field);
-			return require_lib_errors_index.ok(true);
+			return true;
 		}
 		if (this.match(content, "-")) {
-			const [error, _] = this.handleRange(component);
-			if (error) return require_lib_errors_index.err(error.type, error.message);
-			return require_lib_errors_index.ok(true);
+			this.handleRange(component);
+			return true;
 		}
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return require_lib_errors_index.err(error.type, error.message);
-			return require_lib_errors_index.ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		if (!this.isDigit(ch) && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid number '${content}' for field '${field}'`);
+		if (!this.isDigit(ch) && ch !== ",") throw new CronExpressionError(`Invalid number '${content}' for field '${field}'`);
 		const item = content.substring(this.start, this.current);
 		this.addToken(item, "number", Number(item), field);
-		return require_lib_errors_index.ok(true);
+		return true;
 	}
 	handleRange(component) {
 		const { field, content } = component;
 		let ch = this.peek(content);
-		if (!ch) return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (!ch) throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 		while (ch && this.isDigit(ch)) {
 			this.advance(content);
 			ch = this.peek(content);
@@ -379,17 +401,16 @@ var Scanner = class {
 		if (!ch) {
 			const tokenContent = content.substring(this.start);
 			this.addToken(tokenContent, "range", tokenContent, field);
-			return require_lib_errors_index.ok(true);
+			return true;
 		}
 		if (this.match(content, "/")) {
-			const [error, _] = this.handleStep(component);
-			if (error) return require_lib_errors_index.err(error.type, error.message);
-			return require_lib_errors_index.ok(true);
+			this.handleStep(component);
+			return true;
 		}
-		if (ch && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (ch && ch !== ",") throw new CronExpressionError(`Invalid range expression '${content}' for field '${field}'`);
 		const tokenContent = content.substring(this.start, this.current);
 		this.addToken(tokenContent, "range", tokenContent, field);
-		return require_lib_errors_index.ok(true);
+		return true;
 	}
 	isDigit(ch) {
 		return ch >= "0" && ch <= "9";
@@ -472,70 +493,67 @@ var Cron = class {
 	}
 	handleStep(part, values, min, max) {
 		const [rangePart, stepStr] = part.split("/");
-		if (!rangePart) return require_lib_errors_index.err("InvalidValueError", `'${rangePart}' is empty`);
-		if (!stepStr) return require_lib_errors_index.err("InvalidValueError", `'${stepStr}' is empty`);
+		if (!rangePart) throw new InvalidValueError(`'${rangePart}' is empty`);
+		if (!stepStr) throw new InvalidValueError(`'${stepStr}' is empty`);
 		const step = Number(stepStr);
-		if (!Number.isInteger(step)) return require_lib_errors_index.err("InvalidValueError", `'${step}' is not a valid number`);
-		if (step <= 0) return require_lib_errors_index.err("OutOfBoundError", `Expected ${step} > 0`);
+		if (!Number.isInteger(step)) throw new InvalidValueError(`'${step}' is not a valid number`);
+		if (step <= 0) throw new OutOfBoundError(`Expected ${step} > 0`);
 		if (rangePart === "*") {
 			for (let i = min; i <= max; i += step) values[i] = 1;
-			return require_lib_errors_index.ok(true);
+			return;
 		}
-		if (rangePart.includes("-")) return this.handleStepRange(rangePart, step, values, min, max);
-		return this.handleStepSingle(rangePart, step, values, min, max);
+		if (rangePart.includes("-")) {
+			this.handleStepRange(rangePart, step, values, min, max);
+			return;
+		}
+		this.handleStepSingle(rangePart, step, values, min, max);
 	}
 	handleStepRange(range, step, values, min, max) {
 		const [startStr, endStr] = range.split("-");
-		if (!endStr) return require_lib_errors_index.err("InvalidValueError", `'${endStr}' is empty`);
+		if (!endStr) throw new InvalidValueError(`'${endStr}' is empty`);
 		let start = min;
 		if (startStr && startStr.length > 0) start = Number(startStr);
 		const end = Number(endStr);
-		if (!Number.isInteger(start)) return require_lib_errors_index.err("InvalidValueError", `'${start}' is not a valid number`);
-		if (!Number.isInteger(end)) return require_lib_errors_index.err("InvalidValueError", `'${end}' is not a valid number`);
-		if (start < min) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (end > max) return require_lib_errors_index.err("OutOfBoundError", `Expected ${end} <= ${max}`);
-		if (start > end) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} <= ${end}`);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (!Number.isInteger(end)) throw new InvalidValueError(`'${end}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (end > max) throw new OutOfBoundError(`Expected ${end} <= ${max}`);
+		if (start > end) throw new OutOfBoundError(`Expected ${start} <= ${end}`);
 		for (let i = start; i <= end; i += step) values[i] = 1;
-		return require_lib_errors_index.ok(true);
 	}
 	handleStepSingle(value, step, values, min, max) {
 		const start = Number(value);
-		if (!Number.isInteger(start)) return require_lib_errors_index.err("InvalidValueError", `'${start}' is not a valid number`);
-		if (start < min) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (start > max) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} <= ${max}`);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (start > max) throw new OutOfBoundError(`Expected ${start} <= ${max}`);
 		for (let i = start; i <= max; i += step) values[i] = 1;
-		return require_lib_errors_index.ok(true);
 	}
 	handleRange(part, values, min, max) {
 		const [startStr, endStr] = part.split("-");
-		if (!startStr) return require_lib_errors_index.err("InvalidValueError", `'${startStr}' is empty`);
-		if (!endStr) return require_lib_errors_index.err("InvalidValueError", `'${endStr}' is empty`);
+		if (!startStr) throw new InvalidValueError(`'${startStr}' is empty`);
+		if (!endStr) throw new InvalidValueError(`'${endStr}' is empty`);
 		const start = Number(startStr);
 		const end = Number(endStr);
-		if (!Number.isInteger(start)) return require_lib_errors_index.err("InvalidValueError", `'${start}' is not a valid number`);
-		if (!Number.isInteger(end)) return require_lib_errors_index.err("InvalidValueError", `'${end}' is not a valid number`);
-		if (start < min) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} >= ${min}`);
-		if (end > max) return require_lib_errors_index.err("OutOfBoundError", `Expected ${end} <= ${max}`);
-		if (start > end) return require_lib_errors_index.err("OutOfBoundError", `Expected ${start} <= ${end}`);
+		if (!Number.isInteger(start)) throw new InvalidValueError(`'${start}' is not a valid number`);
+		if (!Number.isInteger(end)) throw new InvalidValueError(`'${end}' is not a valid number`);
+		if (start < min) throw new OutOfBoundError(`Expected ${start} >= ${min}`);
+		if (end > max) throw new OutOfBoundError(`Expected ${end} <= ${max}`);
+		if (start > end) throw new OutOfBoundError(`Expected ${start} <= ${end}`);
 		for (let i = start; i <= end; i++) values[i] = 1;
-		return require_lib_errors_index.ok(true);
 	}
 	handleNumber(value, values, min, max) {
 		const n = Number(value);
-		if (!Number.isInteger(n)) return require_lib_errors_index.err("InvalidValueError", `'${value}' is not a valid number`);
-		if (n < min) return require_lib_errors_index.err("OutOfBoundError", `Expected ${n} >= ${min}`);
-		if (n > max) return require_lib_errors_index.err("OutOfBoundError", `Expected ${n} <= ${max}`);
+		if (!Number.isInteger(n)) throw new InvalidValueError(`'${value}' is not a valid number`);
+		if (n < min) throw new OutOfBoundError(`Expected ${n} >= ${min}`);
+		if (n > max) throw new OutOfBoundError(`Expected ${n} <= ${max}`);
 		values[n] = 1;
-		return require_lib_errors_index.ok(true);
 	}
 	constructor(options) {
 		this.options = options;
 		const expr = this.resolveAlias(options.schedule);
-		const [error, tokens] = new Scanner(expr).scan();
-		if (error) throw new Error(`${error.type}: ${error.message}`);
+		const tokens = new Scanner(expr).scan();
 		this.hasSeconds = expr.trim().split(/\s+/).length === FieldAmount.max;
-		const [parsingError, _] = this.parse(tokens);
-		if (parsingError) throw new Error(`${parsingError.type}: ${parsingError.message}`);
+		this.parse(tokens);
 	}
 	resolveAlias(schedule) {
 		return ALIASES[schedule] || schedule;
@@ -543,71 +561,53 @@ var Cron = class {
 	parse(tokens) {
 		for (let i = 0; i < tokens.length; i++) {
 			const token = tokens[i];
-			if (!token) return require_lib_errors_index.err("InvalidValueError", "Undefined token");
+			if (!token) throw new InvalidValueError("Undefined token");
 			const tokenType = token.getTokenType();
 			switch (token.getField()) {
-				case "second": {
-					const [error, _] = this.handleField(token, this.second, CronSecondRange.min, CronSecondRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "second":
+					this.handleField(token, this.second, CronSecondRange.min, CronSecondRange.max);
 					break;
-				}
-				case "minute": {
-					const [error, _] = this.handleField(token, this.minute, CronMinuteRange.min, CronMinuteRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "minute":
+					this.handleField(token, this.minute, CronMinuteRange.min, CronMinuteRange.max);
 					break;
-				}
-				case "hour": {
-					const [error, _] = this.handleField(token, this.hour, CronHourRange.min, CronHourRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "hour":
+					this.handleField(token, this.hour, CronHourRange.min, CronHourRange.max);
 					break;
-				}
-				case "day": {
+				case "day":
 					if (tokenType === "any") this._dayWildcard = true;
-					const [error, _] = this.handleField(token, this.day, CronDayRange.min, CronDayRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+					this.handleField(token, this.day, CronDayRange.min, CronDayRange.max);
 					break;
-				}
-				case "month": {
-					const [error, _] = this.handleField(token, this.month, CronMonthRange.min, CronMonthRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+				case "month":
+					this.handleField(token, this.month, CronMonthRange.min, CronMonthRange.max);
 					break;
-				}
-				case "weekday": {
+				case "weekday":
 					if (tokenType === "any") this._dowWildcard = true;
-					const [error, _] = this.handleField(token, this.dayOfWeek, CronDayOfWeekRange.min, CronDayOfWeekRange.max);
-					if (error) return require_lib_errors_index.err(error.type, `${error.message} in field '${token.getField()}'`);
+					this.handleField(token, this.dayOfWeek, CronDayOfWeekRange.min, CronDayOfWeekRange.max);
 					break;
-				}
-				default: return require_lib_errors_index.err("InvalidValueError", `Invalid field '${token.getField()}'`);
+				default: throw new InvalidValueError(`Invalid field '${token.getField()}'`);
 			}
 		}
-		return require_lib_errors_index.ok(true);
 	}
 	handleField(token, field, min, max) {
 		switch (token.getTokenType()) {
 			case "any":
 				this.fillRange(field, min, max);
 				break;
-			case "number": {
-				const [error, _] = this.handleNumber(token.getComponent(), field, min, max);
-				if (error) return require_lib_errors_index.err(error.type, error.message);
+			case "number":
+				this.handleNumber(token.getComponent(), field, min, max);
 				break;
-			}
 			case "range": {
 				const component = token.getComponent();
-				const [error, _] = this.handleRange(component, field, min, max);
-				if (error) return require_lib_errors_index.err(error.type, error.message);
+				this.handleRange(component, field, min, max);
 				break;
 			}
 			case "step": {
 				const component = token.getComponent();
-				const [error, _] = this.handleStep(component, field, min, max);
-				if (error) return require_lib_errors_index.err(error.type, error.message);
+				this.handleStep(component, field, min, max);
 				break;
 			}
-			default: return require_lib_errors_index.err("InvalidValueError", `Invalid token type '${token.getTokenType()}'`);
+			default: throw new InvalidValueError(`Invalid token type '${token.getTokenType()}'`);
 		}
-		return require_lib_errors_index.ok(true);
 	}
 	matches(date) {
 		const s = date.getSeconds();