@depup/typebox 1.3.16-depup.0 → 1.3.27-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typebox
 
 | Field | Value |
 |-------|-------|
-| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.16 |
-| Processed | 2026-08-23 |
+| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.3.27 |
+| Processed | 2026-09-06 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/build/compile/validator.d.mts

@@ -18,7 +18,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     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. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;

package/build/compile/validator.mjs

@@ -53,7 +53,7 @@ export class Validator {
             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. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

package/build/format/email.mjs

@@ -1,4 +1,4 @@
-const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\.)*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
+const Email = /^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[^"\\]|\\[\x20-\x7e])*")@(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*|\[(?:IPv6:[a-f0-9:]+|(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])(?:\.(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3})\])$/i;
 /**
  * Returns true if the value is an Email
  * @specification https://datatracker.ietf.org/doc/html/rfc5322

package/build/format/idna/idn-hostname.mjs

@@ -1,6 +1,9 @@
 import * as FormatBidi from './format/bidi.mjs';
 import * as LabelUnicode from './label/unicode.mjs';
 import * as LabelPuny from './label/puny.mjs';
+// ------------------------------------------------------------------
+// IsLabel
+// ------------------------------------------------------------------
 function IsValidLabelLength(value) {
     return value.length > 0 && value.length <= 63;
 }
@@ -8,9 +11,26 @@ function IsLabel(value) {
     return IsValidLabelLength(value) && (LabelPuny.IsPunyLabel(value) ||
         LabelUnicode.IsUnicodeLabel(value));
 }
+// ------------------------------------------------------------------
+// NormalizeHostname
+//
+// Normalizes a hostname for label validation. Maps fullwidth
+// codepoints to their ASCII equivalent (e.g. 'ａ' U+FF41 maps to
+// 'a'), then normalizes for NFC such that equivalent codepoint
+// sequences can be uniformly compared. It also removes codepoints
+// that IDNA mapping ignores, and converts full stop variants to
+// ASCII '.' so the hostname can be split into labels.
+// ------------------------------------------------------------------
 function NormalizeHostname(value) {
-    return value.normalize('NFC').replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.');
+    return value
+        .replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0)) // RE_FULLWIDTH_MAPPING
+        .normalize('NFC')
+        .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
+        .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING
 }
+// ------------------------------------------------------------------
+// IsIdnHostname
+// ------------------------------------------------------------------
 export function IsIdnHostname(value) {
     if (value.length === 0 || value.includes(' '))
         return false;

package/build/format/iri.mjs

@@ -2,6 +2,7 @@
 const IpvFutureMatchMaxLength = 2048;
 const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
 // NarrowIpvFuture
 //
@@ -26,6 +27,9 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 2. Reject malformed percent-encoding triplets.
+    if (InvalidPercentEncoding.test(value))
+        return false;
+    // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
     return URL.canParse(NarrowIpvFuture(value));
 }

package/build/format/json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointer(value: string): boolean;

package/build/format/json_pointer.mjs

@@ -1,8 +1,8 @@
 const JsonPointer = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
 /**
  * Returns true if the value is a json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointer(value) {
     return JsonPointer.test(value);

package/build/format/json_pointer_uri_fragment.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsJsonPointerUriFragment(value: string): boolean;

package/build/format/json_pointer_uri_fragment.mjs

@@ -1,8 +1,8 @@
 const JsonPointerUriFragment = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
 /**
  * Returns true if the value is a json pointer uri fragment
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsJsonPointerUriFragment(value) {
     return JsonPointerUriFragment.test(value);

package/build/format/relative_json_pointer.d.mts

@@ -1,6 +1,6 @@
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export declare function IsRelativeJsonPointer(value: string): boolean;

package/build/format/relative_json_pointer.mjs

@@ -1,8 +1,8 @@
 const RelativeJsonPointer = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
 /**
  * Returns true if the value is a relative json pointer
- * @specification
- * @source ajv-formats
+ * @specification https://datatracker.ietf.org/doc/html/rfc6901
+ * @source https://github.com/ajv-validator/ajv-formats
  */
 export function IsRelativeJsonPointer(value) {
     return RelativeJsonPointer.test(value);

package/build/guard/emit.mjs

@@ -106,15 +106,13 @@ export function IsMaxLength(value, length) {
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, params, expression) {
-    return G.IsEqual(offset, '0')
-        ? `${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})`;
+    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${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})`;
+    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
 }
 export function Counted(value, params, expression) {
     return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;

package/build/guard/guard.mjs

@@ -140,36 +140,24 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            return false;
-    }
-    return true;
+    return value.every((item, index) => (index < offset) || callback(item, index));
 }
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            result = false;
-    }
+    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
+        result = false; });
     return result;
 }
 /** Returns true if some element satisfies the callback, short-circuiting on the first success */
 export function Some(value, callback) {
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            return true;
-    }
-    return false;
+    return value.some((value, index) => callback(value, index));
 }
 /** Returns true if some element satisfies the callback, using exhaustive enumeration */
 export function SomeAll(value, callback) {
     let result = false;
-    for (let index = 0; index < value.length; index++) {
-        if (callback(value[index], index))
-            result = true;
-    }
+    value.forEach((item, index) => { if (callback(item, index))
+        result = true; });
     return result;
 }
 /** Returns the count of elements that satisfy the callback */

package/build/guard/string.mjs

@@ -84,10 +84,11 @@ function NextGraphemeClusterIndex(value, clusterStart) {
 // IsGraphemeCodePoint
 // --------------------------------------------------------------------------
 function IsGraphemeCodePoint(value) {
-    return (IsHighSurrogate(value) ||
+    return ((value >= 0x0300) && ( // above special range
+    IsHighSurrogate(value) ||
         IsCombiningMark(value) ||
         IsVariationSelector(value) ||
-        IsZeroWidthJoiner(value));
+        IsZeroWidthJoiner(value)));
 }
 // --------------------------------------------------------------------------
 // GraphemeCount
@@ -103,30 +104,22 @@ export function GraphemeCount(value) {
     return count;
 }
 // --------------------------------------------------------------------------
-// IsMinLength
+// IsMinLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
-    // ----------------------------------------------------------------
-    // Inaccessible via public interface (review)
-    //
-    // deno-coverage-ignore-start
-    // ----------------------------------------------------------------
-    if (minLength === 0)
-        return true; // 0-length
-    // deno-coverage-ignore-stop
+    // if (minLength === 0) return true // 0-length (unreachable)
     let count = 0;
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count >= minLength)
+        if ((++count) >= minLength)
             return true;
     }
     return false;
 }
 // --------------------------------------------------------------------------
-// IsMaxLength
+// IsMaxLengthSegmented
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
@@ -134,8 +127,7 @@ function IsMaxLengthSegmented(value, maxLength) {
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count > maxLength)
+        if ((++count) > maxLength)
             return false;
     }
     return true;
@@ -147,30 +139,30 @@ function IsMaxLengthSegmented(value, maxLength) {
 export function IsMinLength(value, minLength) {
     if (minLength === 0)
         return true; // 0-length
+    if (value.length < minLength)
+        return false; // length is upper bound on grapheme count
     let index = 0;
-    while (index < value.length) {
+    while (true) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMinLengthSegmented(value, minLength);
         }
-        index++;
-        if (index >= minLength)
+        if ((++index) >= minLength)
             return true;
     }
-    return false;
 }
 // --------------------------------------------------------------------------
 // IsMaxLengthFast
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {
+    if (value.length <= maxLength)
+        return true; // length is upper bound on grapheme count
     let index = 0;
-    while (index < value.length) {
+    while (true) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMaxLengthSegmented(value, maxLength);
         }
-        index++;
-        if (index > maxLength)
+        if ((++index) > maxLength)
             return false;
     }
-    return true;
 }

package/build/schema/compile.d.mts

@@ -2,8 +2,9 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
-    private readonly buildResult;
     private readonly evaluateResult;
+    private readonly context;
+    private readonly schema;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
@@ -13,7 +14,7 @@ export declare class Validator<const Schema extends Schema.XSchema = Schema.XSch
     Check(value: unknown): value is Value;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Value;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/compile.mjs

@@ -3,14 +3,15 @@
 import { Arguments } from '../system/arguments/index.mjs';
 import * as Build from './build.mjs';
 import { Errors } from './errors.mjs';
-import { ParseError } from './parse.mjs';
+import { ThrowParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 // Validator
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.buildResult = Build.Build(context, schema);
-        this.evaluateResult = this.buildResult.Evaluate();
+        this.evaluateResult = Build.Build(context, schema).Evaluate();
+        this.context = context;
+        this.schema = schema;
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
@@ -18,7 +19,7 @@ export class Validator {
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.buildResult.Schema();
+        return this.schema;
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
@@ -28,12 +29,11 @@ export class Validator {
     Parse(value) {
         if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
-        throw new ParseError(this.buildResult.Schema(), value, errors);
+        ThrowParseError(this.context, this.schema, value);
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
-        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        return Errors(this.context, this.schema, value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/engine/_context.d.mts

@@ -21,15 +21,10 @@ export declare class CheckContext {
     GetKeys(): Set<string>;
     Merge(results: CheckContext[]): true;
 }
-export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
-    private readonly callback;
-    constructor(callback: ErrorContextCallback);
-    AddError(error: TValidationError): false;
-}
-export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
     constructor();
+    AtCapacity(): boolean;
     AddError(error: TValidationError): false;
     GetErrors(): TValidationError[];
 }

package/build/schema/engine/_context.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../system/settings/index.mjs';
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -101,26 +102,20 @@ export class CheckContext {
         return true;
     }
 }
-export class ErrorContext extends CheckContext {
-    constructor(callback) {
-        super();
-        this.callback = callback;
-    }
-    AddError(error) {
-        this.callback(error);
-        return false;
-    }
-}
 // ------------------------------------------------------------------
-// AccumulatedErrorContext
+// ErrorContext
 // ------------------------------------------------------------------
-export class AccumulatedErrorContext extends ErrorContext {
+export class ErrorContext extends CheckContext {
     constructor() {
-        super(error => this.errors.push(error));
+        super();
         this.errors = [];
     }
+    AtCapacity() {
+        return this.errors.length >= Settings.Get().maxErrors;
+    }
     AddError(error) {
-        this.errors.push(error);
+        if (!this.AtCapacity())
+            this.errors.push(error);
         return false;
     }
     GetErrors() {

package/build/schema/engine/_functions.mjs

@@ -55,7 +55,7 @@ export function GetFunctions() {
 // CreateFunction
 // ------------------------------------------------------------------
 export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.BaseURL().href);
+    const name = CreateName(schema, stack.LexicalBaseURL());
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

package/build/schema/engine/_stack.d.mts

@@ -4,12 +4,16 @@ export declare class Stack {
     private readonly context;
     private readonly schema;
     private readonly ids;
+    private readonly resourceIds;
     private readonly anchors;
     private readonly recursiveAnchors;
     private readonly dynamicAnchors;
+    private readonly retrievedResources;
+    private readonly retrievedFrames;
+    private readonly resolvedResources;
+    private pendingResource;
     constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    BaseURL(): URL;
-    Base(): Schema.XSchemaObject;
+    LexicalBaseURL(): string;
     Push(schema: Schema.XSchema): void;
     Pop(schema: Schema.XSchema): void;
     Ref(ref: Schema.XRef): Schema.XSchema | undefined;