@warlock.js/seal 5.10.0 → 5.11.0

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to `@warlock.js/seal` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.11.0 - 2026-09-14
+
+### Fixed
+
+- `v.boolean().accepted()` / `.declined()` (and their conditional variants) rejected every string form they advertised — `"yes"`, `"on"`, `"1"` — because the boolean type rule ran first. They now parse those form values into a real boolean.
+
 ## 5.10.0 - 2026-09-14
 
 ### Added

package/cjs/index.cjs

@@ -1127,6 +1127,238 @@ const removeEmptyArrayElementsMutator = async (value) => {
 	return value.filter((item) => !isEmptyValue(item));
 };
 
+//#endregion
+//#region ../seal/src/rules/scalar/accepted-rule.ts
+/**
+* The full set of values treated as "accepted" by `acceptedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().accepted()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const ACCEPTED_VALUES = [
+	"1",
+	"true",
+	"yes",
+	"y",
+	"on",
+	1,
+	true,
+	"Yes",
+	"Y",
+	"On"
+];
+const isAcceptedValue = (value) => {
+	return ACCEPTED_VALUES.includes(value);
+};
+/**
+* Validate value as accepted if it equals:
+* 1 | "1" | true | "true" | "yes" | "y" | "on"
+*/
+const acceptedRule = {
+	name: "accepted",
+	defaultErrorMessage: "The :input must be accepted",
+	description: "The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'",
+	async validate(value, context) {
+		if (isAcceptedValue(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Accepted value if another field's value equals to a specific value
+*/
+const acceptedIfRule = {
+	name: "acceptedIf",
+	description: "The field must be accepted if :field's value equals to :value",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue !== expectedValue) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is not equal to the given value
+*/
+const acceptedUnlessRule = {
+	name: "acceptedUnless",
+	description: "The field must be accepted if :field's value is not equal to :value",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue === expectedValue) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is required
+*/
+const acceptedIfRequiredRule = {
+	name: "acceptedIfRequired",
+	description: "The field must be accepted if :field is required",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is present
+*/
+const acceptedIfPresentRule = {
+	name: "acceptedIfPresent",
+	description: "The field must be accepted if :field is present",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue === void 0) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Accepted if another field is missing
+*/
+const acceptedWithoutRule = {
+	name: "acceptedWithout",
+	description: "The field must be accepted if :field is missing",
+	defaultErrorMessage: "The :input must be accepted",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue !== void 0) return invalidRule(this, context);
+		if (!isAcceptedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+//#region ../seal/src/rules/scalar/declined-rule.ts
+/**
+* The full set of values treated as "declined" by `declinedRule` and its
+* conditional variants. Shared with `formBooleanMutator` (see
+* `../../mutators/boolean-mutators`) so `v.boolean().declined()` recognizes
+* exactly this list — single source of truth, no duplicated literals.
+*/
+const DECLINED_VALUES = [
+	"0",
+	"false",
+	"no",
+	"n",
+	"off",
+	0,
+	false,
+	"No",
+	"N",
+	"Off"
+];
+const isDeclinedValue = (value) => {
+	return DECLINED_VALUES.includes(value);
+};
+/**
+* Validate value as declined if it equals:
+* 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
+*/
+const declinedRule = {
+	name: "declined",
+	defaultErrorMessage: "The :input must be declined",
+	description: "The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'",
+	async validate(value, context) {
+		if (isDeclinedValue(value)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Declined value if another field's value equals to a specific value
+*/
+const declinedIfRule = {
+	name: "declinedIf",
+	description: "The field must be declined if :field's value equals to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue !== expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is not equal to the given value
+*/
+const declinedUnlessRule = {
+	name: "declinedUnless",
+	description: "The field must be declined if :field's value is not equal to :value",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		const { value: expectedValue } = this.context.options;
+		this.context.translatableParams.field = this.context.options.field;
+		this.context.translatableParams.value = this.context.options.value;
+		if (fieldValue === expectedValue) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is required
+*/
+const declinedIfRequiredRule = {
+	name: "declinedIfRequired",
+	description: "The field must be declined if :field is required",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is present
+*/
+const declinedIfPresentRule = {
+	name: "declinedIfPresent",
+	description: "The field must be declined if :field is present",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue === void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Declined if another field is missing
+*/
+const declinedWithoutRule = {
+	name: "declinedWithout",
+	description: "The field must be declined if :field is missing",
+	defaultErrorMessage: "The :input must be declined",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		this.context.translatableParams.field = this.context.options.field;
+		if (fieldValue !== void 0) return invalidRule(this, context);
+		if (!isDeclinedValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
 //#endregion
 //#region ../seal/src/mutators/boolean-mutators.ts
 /**
@@ -1141,6 +1373,26 @@ const booleanCoerceMutator = async (value) => {
 	if (value === "false" || value === "0" || value === 0) return false;
 	return value;
 };
+/**
+* Parse form-shaped boolean values into a real boolean, ahead of the type
+* rule.
+*
+* Opted into by calling any `accepted*`/`declined*` method on
+* `v.boolean()` (see `BooleanValidator`'s `withFormBooleanMutator`). Converts
+* every value in `ACCEPTED_VALUES` (`1`, `"1"`, `true`, `"true"`, `"yes"`,
+* `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true`, and every value in
+* `DECLINED_VALUES` (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+* `"No"`, `"N"`, `"Off"`) to `false`. Any other value passes through
+* unchanged so the boolean type rule still rejects it.
+*
+* Named (not anonymous) so callers can detect whether it has already been
+* added — see the idempotence check in `BooleanValidator`.
+*/
+const formBooleanMutator = async (value) => {
+	if (ACCEPTED_VALUES.includes(value)) return true;
+	if (DECLINED_VALUES.includes(value)) return false;
+	return value;
+};
 
 //#endregion
 //#region ../seal/src/mutators/date-mutators.ts
@@ -5499,224 +5751,6 @@ var PrimitiveValidator = class extends BaseValidator {
 	}
 };
 
-//#endregion
-//#region ../seal/src/rules/scalar/accepted-rule.ts
-const isAcceptedValue = (value) => {
-	return [
-		"1",
-		"true",
-		"yes",
-		"y",
-		"on",
-		1,
-		true,
-		"Yes",
-		"Y",
-		"On"
-	].includes(value);
-};
-/**
-* Validate value as accepted if it equals:
-* 1 | "1" | true | "true" | "yes" | "y" | "on"
-*/
-const acceptedRule = {
-	name: "accepted",
-	defaultErrorMessage: "The :input must be accepted",
-	description: "The value must be accepted if it equals: 1 | '1' | true | 'true' | 'yes' | 'y' | 'on' | 1 | true | 'Yes' | 'Y' | 'On'",
-	async validate(value, context) {
-		if (isAcceptedValue(value)) return VALID_RULE;
-		return invalidRule(this, context);
-	}
-};
-/**
-* Accepted value if another field's value equals to a specific value
-*/
-const acceptedIfRule = {
-	name: "acceptedIf",
-	description: "The field must be accepted if :field's value equals to :value",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue !== expectedValue) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is not equal to the given value
-*/
-const acceptedUnlessRule = {
-	name: "acceptedUnless",
-	description: "The field must be accepted if :field's value is not equal to :value",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue === expectedValue) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is required
-*/
-const acceptedIfRequiredRule = {
-	name: "acceptedIfRequired",
-	description: "The field must be accepted if :field is required",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is present
-*/
-const acceptedIfPresentRule = {
-	name: "acceptedIfPresent",
-	description: "The field must be accepted if :field is present",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue === void 0) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Accepted if another field is missing
-*/
-const acceptedWithoutRule = {
-	name: "acceptedWithout",
-	description: "The field must be accepted if :field is missing",
-	defaultErrorMessage: "The :input must be accepted",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue !== void 0) return invalidRule(this, context);
-		if (!isAcceptedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-
-//#endregion
-//#region ../seal/src/rules/scalar/declined-rule.ts
-const isDeclinedValue = (value) => {
-	return [
-		"0",
-		"false",
-		"no",
-		"n",
-		"off",
-		0,
-		false,
-		"No",
-		"N",
-		"Off"
-	].includes(value);
-};
-/**
-* Validate value as declined if it equals:
-* 0 | "0" | false | "false" | "no" | "n" | "off" | 0 | false | "No" | "N" | "Off"
-*/
-const declinedRule = {
-	name: "declined",
-	defaultErrorMessage: "The :input must be declined",
-	description: "The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'",
-	async validate(value, context) {
-		if (isDeclinedValue(value)) return VALID_RULE;
-		return invalidRule(this, context);
-	}
-};
-/**
-* Declined value if another field's value equals to a specific value
-*/
-const declinedIfRule = {
-	name: "declinedIf",
-	description: "The field must be declined if :field's value equals to :value",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue !== expectedValue) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is not equal to the given value
-*/
-const declinedUnlessRule = {
-	name: "declinedUnless",
-	description: "The field must be declined if :field's value is not equal to :value",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		const { value: expectedValue } = this.context.options;
-		this.context.translatableParams.field = this.context.options.field;
-		this.context.translatableParams.value = this.context.options.value;
-		if (fieldValue === expectedValue) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is required
-*/
-const declinedIfRequiredRule = {
-	name: "declinedIfRequired",
-	description: "The field must be declined if :field is required",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (isEmptyValue(fieldValue)) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is present
-*/
-const declinedIfPresentRule = {
-	name: "declinedIfPresent",
-	description: "The field must be declined if :field is present",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue === void 0) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-/**
-* Declined if another field is missing
-*/
-const declinedWithoutRule = {
-	name: "declinedWithout",
-	description: "The field must be declined if :field is missing",
-	defaultErrorMessage: "The :input must be declined",
-	async validate(value, context) {
-		const fieldValue = getFieldValue(this, context);
-		this.context.translatableParams.field = this.context.options.field;
-		if (fieldValue !== void 0) return invalidRule(this, context);
-		if (!isDeclinedValue(value)) return invalidRule(this, context);
-		return VALID_RULE;
-	}
-};
-
 //#endregion
 //#region ../seal/src/validators/boolean-validator.ts
 /**
@@ -5737,65 +5771,89 @@ var BooleanValidator = class extends PrimitiveValidator {
 	matchesType(value) {
 		return typeof value === "boolean";
 	}
-	/** Value must be accepted (true, "yes", 1, "on", etc.) */
+	/**
+	* Add a rule from the accepted/declined family, opting the validator into
+	* form-boolean parsing.
+	*
+	* Calling ANY `accepted*`/`declined*` method on `v.boolean()` adds (once,
+	* idempotently — checked by mutator identity so chaining several of these
+	* methods never stacks duplicates) `formBooleanMutator`, which runs before
+	* the type rule and converts the accepted set (`1`, `"1"`, `true`,
+	* `"true"`, `"yes"`, `"y"`, `"on"`, `"Yes"`, `"Y"`, `"On"`) to `true` and
+	* the declined set (`0`, `"0"`, `false`, `"false"`, `"no"`, `"n"`, `"off"`,
+	* `"No"`, `"N"`, `"Off"`) to `false`; any other value passes through
+	* unchanged and is rejected by the strict type rule as before.
+	*
+	* The mutator and the rule are added to the SAME resolved instance in one
+	* pass — resolving `this.instance` twice (once per `addRule`/`addMutator`
+	* call) would clone twice on an immutable validator and silently drop one
+	* of the two additions.
+	*/
+	addFormBooleanRule(rule, errorMessage, options = {}) {
+		const instance = this.instance;
+		if (!instance.mutators.some((mutator) => mutator.mutate === formBooleanMutator)) instance.addMutableMutator(formBooleanMutator);
+		instance.addMutableRule(rule, errorMessage, options);
+		return instance;
+	}
+	/** Value must be accepted (true, "yes", 1, "on", etc. — form strings are parsed into a real boolean first) */
 	accepted(errorMessage) {
-		return this.addRule(acceptedRule, errorMessage);
+		return this.addFormBooleanRule(acceptedRule, errorMessage);
 	}
 	/** Value must be accepted if another field equals a value */
 	acceptedIf(field, value, errorMessage) {
-		return this.addRule(acceptedIfRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted unless another field equals a value */
 	acceptedUnless(field, value, errorMessage) {
-		return this.addRule(acceptedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(acceptedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be accepted if another field is required */
 	acceptedIfRequired(field, errorMessage) {
-		return this.addRule(acceptedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is present */
 	acceptedIfPresent(field, errorMessage) {
-		return this.addRule(acceptedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be accepted if another field is missing */
 	acceptedWithout(field, errorMessage) {
-		return this.addRule(acceptedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(acceptedWithoutRule, errorMessage, { field });
 	}
-	/** Value must be declined (false, "no", 0, "off", etc.) */
+	/** Value must be declined (false, "no", 0, "off", etc. — form strings are parsed into a real boolean first) */
 	declined(errorMessage) {
-		return this.addRule(declinedRule, errorMessage);
+		return this.addFormBooleanRule(declinedRule, errorMessage);
 	}
 	/** Value must be declined if another field equals a value */
 	declinedIf(field, value, errorMessage) {
-		return this.addRule(declinedIfRule, errorMessage, {
+		return this.addFormBooleanRule(declinedIfRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined unless another field equals a value */
 	declinedUnless(field, value, errorMessage) {
-		return this.addRule(declinedUnlessRule, errorMessage, {
+		return this.addFormBooleanRule(declinedUnlessRule, errorMessage, {
 			field,
 			value
 		});
 	}
 	/** Value must be declined if another field is required */
 	declinedIfRequired(field, errorMessage) {
-		return this.addRule(declinedIfRequiredRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfRequiredRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is present */
 	declinedIfPresent(field, errorMessage) {
-		return this.addRule(declinedIfPresentRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedIfPresentRule, errorMessage, { field });
 	}
 	/** Value must be declined if another field is missing */
 	declinedWithout(field, errorMessage) {
-		return this.addRule(declinedWithoutRule, errorMessage, { field });
+		return this.addFormBooleanRule(declinedWithoutRule, errorMessage, { field });
 	}
 	/**
 	* Opt in to coercion: an exact query-string-shaped boolean is converted to a
@@ -5807,7 +5865,9 @@ var BooleanValidator = class extends PrimitiveValidator {
 	* `2` all pass through unchanged and fail the type rule. `v.boolean()` does
 	* **not** coerce by default; this only takes effect when explicitly chained.
 	* For form-style truthy strings like `"yes"` / `"on"`, use `.accepted()` /
-	* `.declined()` instead — those are separate pass/fail rules, not coercion.
+	* `.declined()` instead — those methods opt into their own form-boolean
+	* parsing (a wider value set, case-insensitive on a few forms) and then
+	* apply the accepted/declined pass-fail rule on top of the parsed boolean.
 	*
 	* The output type is unchanged (`Infer<>` keys off the validator class), so
 	* `v.boolean().coerce()` still infers `boolean`.
@@ -8876,6 +8936,7 @@ exports.forbiddenIfNotRule = forbiddenIfNotRule;
 exports.forbiddenIfRule = forbiddenIfRule;
 exports.forbiddenMethodsApplied = forbiddenMethodsApplied;
 exports.forbiddenRule = forbiddenRule;
+exports.formBooleanMutator = formBooleanMutator;
 exports.fromHourRule = fromHourRule;
 exports.fromMinuteRule = fromMinuteRule;
 exports.fromTodayRule = fromTodayRule;