@depup/typebox 1.1.23-depup.0 → 1.3.8-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typebox
 
 | Field | Value |
 |-------|-------|
-| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.1.23 |
-| Processed | 2026-04-09 |
+| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.8 |
+| Processed | 2026-07-26 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/build/compile/code.mjs

@@ -45,8 +45,8 @@ function FunctionSection(build) {
 // ------------------------------------------------------------------
 function ExportSection(build) {
     const body = build.UseUnevaluated()
-        ? `const context = new CheckContext({}, {}); return ${build.Call()}`
-        : `return ${build.Call()}`;
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
     return [
         Separator(),
         TsIgnore(),

package/build/compile/validator.d.mts

@@ -1,16 +1,11 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
-import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
-export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
-    private readonly context;
-    private readonly type;
-    private readonly isAccelerated;
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema } from '../type/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> {
     private readonly hasCodec;
-    private readonly code;
-    private readonly check;
-    /** Constructs a Validator with the given Context and Type. */
+    private readonly buildResult;
+    private readonly evaluateResult;
+    /** Constructs a Validator. */
     constructor(context: Context, type: Type);
-    /** Constructs a Validator with the given arguments. */
-    constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
     /** Returns the Context for this validator. */
@@ -21,6 +16,8 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Code(): string;
     /** Performs a type-guard check on the provided value. */
     Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
@@ -31,10 +28,6 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Create(): Encode;
     /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
-    /** Clones this validator. */
-    Clone(): Validator<Context, Type>;
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value: unknown): Encode;
     /** Decodes a value */
     Decode(value: unknown): Decode;
     /** Encodes a value */

package/build/compile/validator.mjs

@@ -1,116 +1,91 @@
 // deno-fmt-ignore-file
 import { Settings } from '../system/settings/index.mjs';
-import { Arguments } from '../system/arguments/index.mjs';
-import { Environment } from '../system/environment/index.mjs';
-import { Base } from '../type/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
 // ------------------------------------------------------------------
 // Validator<...>
 // ------------------------------------------------------------------
-export class Validator extends Base {
+export class Validator {
     /** Constructs a Validator. */
-    constructor(...args) {
-        super();
-        const matched = Arguments.Match(args, {
-            6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
-            2: (context, type) => [context, type]
-        });
-        if (matched.length === 6) {
-            const [context, type, isEvaluated, hasCodec, code, check] = matched;
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = isEvaluated;
-            this.hasCodec = hasCodec;
-            this.code = code;
-            this.check = check;
-        }
-        else {
-            const [context, type] = matched;
-            const result = Build(context, type).Evaluate();
-            this.hasCodec = HasCodec(context, type);
-            this.context = context;
-            this.type = type;
-            this.isAccelerated = result.IsAccelerated;
-            this.code = result.Code;
-            this.check = result.Check;
-        }
+    constructor(context, type) {
+        this.hasCodec = HasCodec(context, type);
+        this.buildResult = Build(context, type);
+        this.evaluateResult = this.buildResult.Evaluate();
     }
     // ----------------------------------------------------------------
     // IsAccelerated
     // ----------------------------------------------------------------
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.isAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     // ----------------------------------------------------------------
-    // Context | Type
+    // Context & Type
     // ----------------------------------------------------------------
     /** Returns the Context for this validator. */
     Context() {
-        return this.context;
+        return this.buildResult.Context();
     }
     /** Returns the underlying Type used to construct this Validator. */
     Type() {
-        return this.type;
+        return this.buildResult.Schema();
     }
     // ----------------------------------------------------------------
     // Code
     // ----------------------------------------------------------------
     /** Returns the generated code for this validator. */
     Code() {
-        return this.code;
+        return this.evaluateResult.Code();
     }
     // ----------------------------------------------------------------
-    // Base<...>
+    // Standard Validator
     // ----------------------------------------------------------------
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.check(value);
+        return this.evaluateResult.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.Context(), this.Type(), value);
+        throw new ParseError(value, this.Errors(value));
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        if (Environment.CanEvaluate() && this.check(value))
+        if (this.IsAccelerated() && this.Check(value))
             return [];
-        return Errors(this.context, this.type, value);
+        return Errors(this.Context(), this.Type(), value);
     }
+    // ----------------------------------------------------------------
+    // Value.* Operations
+    // ----------------------------------------------------------------
     /** Cleans a value using the Validator type. */
     Clean(value) {
-        return Clean(this.context, this.type, value);
+        return Clean(this.Context(), this.Type(), value);
     }
     /** Converts a value using the Validator type. */
     Convert(value) {
-        return Convert(this.context, this.type, value);
+        return Convert(this.Context(), this.Type(), value);
     }
     /** Creates a value using the Validator type. */
     Create() {
-        return Create(this.context, this.type);
+        return Create(this.Context(), this.Type());
     }
     /** Creates defaults using the Validator type. */
     Default(value) {
-        return Default(this.context, this.type, value);
-    }
-    /** Clones this validator. */
-    Clone() {
-        return new Validator(this.context, this.type, this.isAccelerated, this.hasCodec, this.code, this.check);
-    }
-    /** Validates a value and returns it. Will throw if invalid. */
-    Parse(value) {
-        const checked = this.Check(value);
-        if (checked)
-            return value;
-        if (Settings.Get().correctiveParse)
-            return Parser(this.context, this.type, value);
-        throw new ParseError(value, this.Errors(value));
+        return Default(this.Context(), this.Type(), value);
     }
     /** Decodes a value */
     Decode(value) {
-        const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Decode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
     /** Encodes a value */
     Encode(value) {
-        const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value);
+        const result = this.hasCodec ? Encode(this.Context(), this.Type(), value) : this.Parse(value);
         return result;
     }
 }

package/build/error/errors.d.mts

@@ -1,4 +1,4 @@
-export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TGuardError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
+export type TValidationError = TAdditionalPropertiesError | TAnyOfError | TBooleanError | TConstError | TContainsError | TDependenciesError | TDependentRequiredError | TEnumError | TExclusiveMaximumError | TExclusiveMinimumError | TFormatError | TIfError | TMaximumError | TMaxItemsError | TMaxLengthError | TMaxPropertiesError | TMinimumError | TMinItemsError | TMinLengthError | TMinPropertiesError | TMultipleOfError | TNotError | TOneOfError | TPatternError | TPropertyNamesError | TRefineError | TRequiredError | TTypeError | TUnevaluatedItemsError | TUnevaluatedPropertiesError | TUniqueItemsError;
 export declare function IsValidationError(value: unknown): value is TValidationError;
 export type TLocalizedValidationError = TValidationError & {
     message: string;
@@ -78,12 +78,6 @@ export interface TFormatError extends TValidationErrorBase {
         format: string;
     };
 }
-export interface TGuardError extends TValidationErrorBase {
-    keyword: '~guard';
-    params: {
-        errors: object[];
-    };
-}
 export interface TIfError extends TValidationErrorBase {
     keyword: 'if';
     params: {

package/build/format/_idna.mjs

@@ -1,3 +1,4 @@
+import { Unreachable } from '../system/unreachable/index.mjs';
 import * as Puny from './_puny.mjs';
 // ------------------------------------------------------------------
 // Unicode General Category Helper (RFC 5892)
@@ -34,7 +35,8 @@ const RFC5892_DISALLOWED = new Set([
 // ------------------------------------------------------------------
 // A set of Virama (halant) code points used to validate CONTEXTJ
 // rules (RFC 5892 Appendix A.1). These characters allow a subsequent
-// Zero Width Joiner (U+200D) to be valid in a label.
+// Zero Width Non-Joiner (U+200C) or Zero Width Joiner (U+200D) to
+// be valid in a label.
 // ------------------------------------------------------------------
 const VIRAMA_CPS = new Set([
     0x094d,
@@ -101,8 +103,10 @@ function IsVirama(cp) {
 // IsUnicodeLabel
 // ------------------------------------------------------------------
 function IsUnicodeLabel(value) {
+    // deno-coverage-ignore-start - unable to reach via format guards
     if (value.length === 0)
-        return false;
+        return Unreachable(); // false
+    // deno-coverage-ignore-stop
     // Use spread to handle surrogate pairs and provide O(1) neighbor access
     const cps = [...value].map((c) => c.codePointAt(0));
     const len = cps.length;
@@ -145,10 +149,17 @@ function IsUnicodeLabel(value) {
                 if (prev === undefined || !IsHebrew(prev))
                     return false;
                 break; // Hebrew GERESH
-            case 0x200d:
+            case 0x200c: // ZWNJ - RFC 5892 Appendix A.1
+                // Note: Full validation requires a Unicode joining type table. We reject
+                // only when preceded by ASCII (U+0000-U+007F), which can never satisfy
+                // the Virama or cursive-joining rules.
+                if (prev === undefined || (prev < 0x0080 && !IsVirama(prev)))
+                    return false;
+                break;
+            case 0x200d: // ZWJ  - RFC 5892 Appendix A.2
                 if (prev === undefined || !IsVirama(prev))
                     return false;
-                break; // ZWJ
+                break;
             case 0x30fb: /* Checked at end via hasJapanese */
                 break; // KATAKANA MIDDLE DOT
         }
@@ -192,10 +203,29 @@ function IsPuny(value) {
 }
 function IsPunyLabel(value) {
     try {
-        return IsUnicodeLabel(Puny.Decode(value.slice(4)));
+        const payload = value.slice(4).toLowerCase();
+        // 1. Structural Validation (RFC 3492 syntax)
+        //
+        // If the payload contains a hyphen, it MUST be a delimiter separating basic
+        // ASCII characters from the variable-length integers. A payload consisting
+        // of ONLY a hyphen or starting with multiple hyphens without basic ASCII
+        // characters (like "-9uc") is fundamentally malformed.
+        //
+        const lastHyphen = payload.lastIndexOf('-');
+        if (lastHyphen === 0) {
+            // Catches "-9uc" right here because the delimiter is at index 0, meaning 0
+            // basic ASCII characters preceded it, which is non-canonical.
+            return false;
+        }
+        // 2. Decode the payload
+        const decoded = Puny.Decode(payload);
+        if (!decoded)
+            return false;
+        // 3. Validate the output rules against RFC 5892
+        return IsUnicodeLabel(decoded);
     }
     catch {
-        return false; // invalid punycode encoding
+        return false;
     }
 }
 // ------------------------------------------------------------------

package/build/format/_puny.mjs

@@ -1,3 +1,4 @@
+import { Unreachable } from '../system/unreachable/index.mjs';
 // ------------------------------------------------------------------
 // PunyCode (RFC 3492)
 // ------------------------------------------------------------------
@@ -52,8 +53,10 @@ export function Decode(value) {
                 digit = ch - 0x61; // a-z => 0-25
             else if (ch >= 0x30 && ch <= 0x39)
                 digit = ch - 0x30 + 26; // 0-9 => 26-35
+            // deno-coverage-ignore-start - _idna.ts maps input to lowercase, so we can't reach here
             else if (ch >= 0x41 && ch <= 0x5a)
-                digit = ch - 0x41; // A-Z => 0-25
+                Unreachable(); // digit = ch - 0x41 // A-Z => 0-25
+            // deno-coverage-ignore-stop
             else
                 throw new Error('Invalid punycode: bad digit character');
             i += digit * w;

package/build/format/_registry.mjs

@@ -1,21 +1,21 @@
-import { IsDateTime } from './date-time.mjs';
+import { IsDateTime } from './date_time.mjs';
 import { IsDate } from './date.mjs';
 import { IsDuration } from './duration.mjs';
 import { IsEmail } from './email.mjs';
 import { IsHostname } from './hostname.mjs';
-import { IsIdnEmail } from './idn-email.mjs';
-import { IsIdnHostname } from './idn-hostname.mjs';
+import { IsIdnEmail } from './idn_email.mjs';
+import { IsIdnHostname } from './idn_hostname.mjs';
 import { IsIPv4 } from './ipv4.mjs';
 import { IsIPv6 } from './ipv6.mjs';
-import { IsIriReference } from './iri-reference.mjs';
+import { IsIriReference } from './iri_reference.mjs';
 import { IsIri } from './iri.mjs';
-import { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
-import { IsJsonPointer } from './json-pointer.mjs';
+import { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+import { IsJsonPointer } from './json_pointer.mjs';
 import { IsRegex } from './regex.mjs';
-import { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+import { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
 import { IsTime } from './time.mjs';
-import { IsUriReference } from './uri-reference.mjs';
-import { IsUriTemplate } from './uri-template.mjs';
+import { IsUriReference } from './uri_reference.mjs';
+import { IsUriTemplate } from './uri_template.mjs';
 import { IsUri } from './uri.mjs';
 import { IsUrl } from './url.mjs';
 import { IsUuid } from './uuid.mjs';

package/build/format/format.d.mts

@@ -1,22 +1,22 @@
 export * from './_registry.mjs';
-export { IsDateTime } from './date-time.mjs';
+export { IsDateTime } from './date_time.mjs';
 export { IsDate } from './date.mjs';
 export { IsDuration } from './duration.mjs';
 export { IsEmail } from './email.mjs';
 export { IsHostname } from './hostname.mjs';
-export { IsIdnEmail } from './idn-email.mjs';
-export { IsIdnHostname } from './idn-hostname.mjs';
+export { IsIdnEmail } from './idn_email.mjs';
+export { IsIdnHostname } from './idn_hostname.mjs';
 export { IsIPv4 } from './ipv4.mjs';
 export { IsIPv6 } from './ipv6.mjs';
-export { IsIriReference } from './iri-reference.mjs';
+export { IsIriReference } from './iri_reference.mjs';
 export { IsIri } from './iri.mjs';
-export { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
-export { IsJsonPointer } from './json-pointer.mjs';
+export { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+export { IsJsonPointer } from './json_pointer.mjs';
 export { IsRegex } from './regex.mjs';
-export { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+export { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
 export { IsTime } from './time.mjs';
-export { IsUriReference } from './uri-reference.mjs';
-export { IsUriTemplate } from './uri-template.mjs';
+export { IsUriReference } from './uri_reference.mjs';
+export { IsUriTemplate } from './uri_template.mjs';
 export { IsUri } from './uri.mjs';
 export { IsUrl } from './url.mjs';
 export { IsUuid } from './uuid.mjs';

package/build/format/format.mjs

@@ -1,22 +1,22 @@
 export * from './_registry.mjs';
-export { IsDateTime } from './date-time.mjs';
+export { IsDateTime } from './date_time.mjs';
 export { IsDate } from './date.mjs';
 export { IsDuration } from './duration.mjs';
 export { IsEmail } from './email.mjs';
 export { IsHostname } from './hostname.mjs';
-export { IsIdnEmail } from './idn-email.mjs';
-export { IsIdnHostname } from './idn-hostname.mjs';
+export { IsIdnEmail } from './idn_email.mjs';
+export { IsIdnHostname } from './idn_hostname.mjs';
 export { IsIPv4 } from './ipv4.mjs';
 export { IsIPv6 } from './ipv6.mjs';
-export { IsIriReference } from './iri-reference.mjs';
+export { IsIriReference } from './iri_reference.mjs';
 export { IsIri } from './iri.mjs';
-export { IsJsonPointerUriFragment } from './json-pointer-uri-fragment.mjs';
-export { IsJsonPointer } from './json-pointer.mjs';
+export { IsJsonPointerUriFragment } from './json_pointer_uri_fragment.mjs';
+export { IsJsonPointer } from './json_pointer.mjs';
 export { IsRegex } from './regex.mjs';
-export { IsRelativeJsonPointer } from './relative-json-pointer.mjs';
+export { IsRelativeJsonPointer } from './relative_json_pointer.mjs';
 export { IsTime } from './time.mjs';
-export { IsUriReference } from './uri-reference.mjs';
-export { IsUriTemplate } from './uri-template.mjs';
+export { IsUriReference } from './uri_reference.mjs';
+export { IsUriTemplate } from './uri_template.mjs';
 export { IsUri } from './uri.mjs';
 export { IsUrl } from './url.mjs';
 export { IsUuid } from './uuid.mjs';

package/build/format/uuid.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a uuid
- * @specification
- * @source ajv-formats
+ * @specification https://www.rfc-editor.org/info/rfc4122/
+ * @specification https://www.rfc-editor.org/info/rfc9562/
  */
 export declare function IsUuid(value: string): boolean;

package/build/format/uuid.mjs

@@ -1,8 +1,8 @@
-const Uuid = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+const Uuid = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
 /**
  * Returns true if the value is a uuid
- * @specification
- * @source ajv-formats
+ * @specification https://www.rfc-editor.org/info/rfc4122/
+ * @specification https://www.rfc-editor.org/info/rfc9562/
  */
 export function IsUuid(value) {
     return Uuid.test(value);

package/build/guard/emit.d.mts

@@ -3,16 +3,12 @@ export declare function Or(left: string, right: string): string;
 export declare function Not(expr: string): string;
 /** Returns true if this value is an array */
 export declare function IsArray(value: string): string;
-/** Returns true if this value is an async iterator */
-export declare function IsAsyncIterator(value: unknown): string;
 /** Returns true if this value is bigint */
 export declare function IsBigInt(value: string): string;
 /** Returns true if this value is a boolean */
 export declare function IsBoolean(value: string): string;
 /** Returns true if this value is integer */
 export declare function IsInteger(value: string): string;
-/** Returns true if this value is an iterator */
-export declare function IsIterator(value: unknown): string;
 /** Returns true if this value is null */
 export declare function IsNull(value: string): string;
 /** Returns true if this value is number */
@@ -37,6 +33,9 @@ export declare function IsGreaterEqualThan(left: string, right: string): string;
 export declare function IsMinLength(value: string, length: string): string;
 export declare function IsMaxLength(value: string, length: string): string;
 export declare function Every(value: string, offset: string, params: [value: string, index: string], expression: string): string;
+export declare function Some(value: string, params: [value: string, index: string], expression: string): string;
+export declare function SomeAll(value: string, params: [value: string, index: string], expression: string): string;
+export declare function Counted(value: string, params: [value: string, index: string], expression: string): string;
 export declare function Entries(value: string): string;
 export declare function Keys(value: string): string;
 export declare function HasPropertyKey(value: string, key: string): string;
@@ -54,5 +53,4 @@ export declare function If(condition: string, then: string): string;
 export declare function Return(expression: string): string;
 export declare function ReduceAnd(operands: string[]): string;
 export declare function ReduceOr(operands: string[]): string;
-export declare function PrefixIncrement(expression: string): string;
 export declare function MultipleOf(dividend: string, divisor: string): string;

package/build/guard/emit.mjs

@@ -26,10 +26,6 @@ export function Not(expr) {
 export function IsArray(value) {
     return `Array.isArray(${value})`;
 }
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-    return `Guard.IsAsyncIterator(${value})`;
-}
 /** Returns true if this value is bigint */
 export function IsBigInt(value) {
     return `typeof ${value} === "bigint"`;
@@ -42,10 +38,6 @@ export function IsBoolean(value) {
 export function IsInteger(value) {
     return `Number.isInteger(${value})`;
 }
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-    return `Guard.IsIterator(${value})`;
-}
 /** Returns true if this value is null */
 export function IsNull(value) {
     return `${value} === null`;
@@ -118,6 +110,15 @@ export function Every(value, offset, params, expression) {
         ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
         : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
 }
+export function Some(value, params, expression) {
+    return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
+}
+export function SomeAll(value, params, expression) {
+    return `((value, callback) => { let result = false; for(let index = 0; index < value.length; index++) if (callback(value[index], index)) result = true; return result })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+}
+export function Counted(value, params, expression) {
+    return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;
+}
 // --------------------------------------------------------------------------
 // Objects
 // --------------------------------------------------------------------------
@@ -153,6 +154,8 @@ export function Member(left, right) {
     return `${left}${IsIdentifier(right) ? `.${right}` : `[${Constant(right)}]`}`;
 }
 export function Constant(value) {
+    if (!G.IsValueLike(value))
+        throw Error('Unsupported Constant');
     return G.IsString(value) ? JSON.stringify(value) : `${value}`;
 }
 export function Ternary(condition, true_, false_) {
@@ -180,15 +183,11 @@ export function ReduceAnd(operands) {
     return G.IsEqual(operands.length, 0) ? 'true' : operands.reduce((left, right) => And(left, right));
 }
 export function ReduceOr(operands) {
-    // deno-coverage-ignore - we never observe 0 operands
     return G.IsEqual(operands.length, 0) ? 'false' : operands.reduce((left, right) => Or(left, right));
 }
 // --------------------------------------------------------------------------
-// Arithmetic
+// MultipleOf
 // --------------------------------------------------------------------------
-export function PrefixIncrement(expression) {
-    return `++${expression}`;
-}
 export function MultipleOf(dividend, divisor) {
     return `Guard.IsMultipleOf(${dividend}, ${divisor})`;
 }

package/build/guard/guard.d.mts

@@ -1,7 +1,5 @@
 /** Returns true if this value is an array */
 export declare function IsArray(value: unknown): value is unknown[];
-/** Returns true if this value is an async iterator */
-export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
 /** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
 /** Returns true if this value is a boolean */
@@ -12,8 +10,6 @@ export declare function IsConstructor(value: unknown): value is new (...args: ne
 export declare function IsFunction(value: unknown): value is globalThis.Function;
 /** Returns true if this value is integer */
 export declare function IsInteger(value: unknown): value is number;
-/** Returns true if this value is an iterator */
-export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
 /** Returns true if this value is null */
 export declare function IsNull(value: unknown): value is null;
 /** Returns true if this value is number */
@@ -43,8 +39,20 @@ export declare function GraphemeCount(value: string): number;
 export declare function IsMaxLength(value: string, length: number): boolean;
 /** Returns true if the string has at least the given number of graphemes */
 export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if some element satisfies the callback, short-circuiting on the first success */
+export declare function Some<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if some element satisfies the callback, using exhaustive enumeration */
+export declare function SomeAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+/** Returns the count of elements that satisfy the callback */
+export declare function Counted(value: unknown[], callback: (value: unknown, index: number) => boolean): number;
+/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export declare function ShiftLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;
@@ -53,11 +61,11 @@ export declare function HasPropertyKey<Key extends PropertyKey>(value: object, k
 export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
 /** Returns object entries as `[string, Value][]` */
 export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
 export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 /** Returns the property values for the given object via `Object.values()` */
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
-/** Tests values for deep equality */
+/** Returns true if left and right values are structurally equal */
 export declare function IsDeepEqual(left: unknown, right: unknown): boolean;