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

package/readme.md

@@ -113,11 +113,11 @@ type User = Type.Static<typeof User>              // type User = {
 
 [Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvGZs4AXkREAdAGVBUYGBgAKAAaU4cQmjgA1VIJjQALLLgBvOGQBccEdxDFUUADRwkz1+6ePgBe-m4e3nAA7mGBUHAAvnoGRCZmFlAAzDb2Ti7hQb6xESHFnonJhuim5tAATDkOZZF++XEV2gCU1HRwAOJQTGCswIJiHDz8QqIS-YPDo+NyyGjKqupaUqw+uvpVabCoZDnJ+pBiwDDAos41GZZepy7QIEy8t+nQmY-6+twAbh9alA6skkntUn1UDhUDAoEgTr84P9PFdBKgxB9DmQANoAXR+v2AIk4owxzXxYMqqSknmAb0RvyY7mAqBEMCB90J+lJGAw3DEqE5Vm5cDEaEEfCYUGFUEsVIhRgYGPYclsTwA5tCQLD4c4oTC4UhRa8YHS3s5aWo3lSutR9sqxKr5KslDAWKMADxVCAYOZDEZjHF4R2sPB4gB8+l6DpVjKRCcTSeTKZTvX0WsNerscAUecSotTReLJfTcFN5veObzCgqJfrDeTvQSQA) | [Example 2](https://www.typescriptlang.org/play/?target=99&module=7#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgFkBDGAC0YgBMBXAG1WoBjCADsAzvABqqQTGgAWOAF5ERAHQB5YgCsZMABQBvOGQBcqtGoBy3EMVRR9ASgA0cJOeSWbdh87cAXp7qPvaOrnAA7sHetmHOcAC+TpTC4lJ60ADMyhaomjp6RiYx+aF+ER551nEVgaU1vuFJKWkScNKy0ABMuV75WrqyxWbV5eFuVf2N8U4t1HRwAOJQTGCswIJiHDz8QqLt0rCoZH3qg0WGlHBwkGLAMMCi5p1yUPIu13Ai0CBMvC9MlAsp8btwAG6ArpQbqUZKpA7wJaoHCoGBQJBnSwXYZXG7ghyPQSoMQNACCUFWSH0RxgJ1cX2AIk4mxJ5MpTGp03GzhS8La8GYdKgwH+WIGhVxXyYdmAqBEMChbw+XxZGAw3DEqCVClBcDEaEEfCYUB170+-MRjBJ7BU0xxBjxcAA5iiQGiMeZkaj0Ug9X9haKAYwWA4g3CUpRCGhrWJbdUAMowFibAA80ZRGFjrAAfDd8wXC4sM9nck7CxXK1XqzX84sbq6fZ64MY1G2knra13u1363AA2H-uZW+3El8exPJ3X6IkgA)
 
-TypeBox includes a runtime TypeScript engine that can transform TypeScript definitions to JSON Schema. The engine is fully type-safe and supports many programmable constructs including Conditional, Mapped, Indexed, Generics, Distributive Generics, and more.
+TypeBox includes a micro TypeScript engine that can transform TypeScript definitions to JSON Schema. The engine is fully type-safe and supports many programmable constructs including Conditional, Mapped, Indexed, Generics, Distributive Generics, and more.
 
 ### Example
 
-Syntax highlighting is available via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=sinclairzx81.typebox-script)
+Syntax highlighting is available via the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=sinclairzx81.typebox-script).
 
 ```typescript
 import Type from 'typebox'
@@ -229,9 +229,9 @@ const result = Vector.Parse({ x: 1, y: 0, z: 0 })  // const result: {
 
 ### Coverage
 
-The following table shows specification coverage implemented by TypeBox.
+[JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) | [JSON Schema Compliance Suite](https://github.com/sinclairzx81/json-schema-compliance-suite)
 
-[JSON Schema Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite) 
+TypeBox supports all major JSON Schema draft versions and tracks compliance against the official JSON Schema Test Suite. It also maintains a separate JavaScript compliance suite to track ecosystem adoption as JSON Schema moves toward the V1 candidate. The following table shows TypeBox specification coverage.
 
 | Spec | 3 | 4 | 6 | 7 | 2019-09 | 2020-12 | v1 |
 |:-----|:--|:--|:--|:--|:--|:--|:--|
@@ -248,7 +248,7 @@ The following table shows specification coverage implemented by TypeBox.
 | dependencies | 17/18 | ✅ | ✅ | ✅ | - | - | - |
 | dependentRequired | - | - | - | - | ✅ | ✅ | ✅ |
 | dependentSchemas | - | - | - | - | ✅ | ✅ | ✅ |
-| dynamicRef | - | - | - | - | - | 38/44 | 19/27 |
+| dynamicRef | - | - | - | - | - | 40/44 | 21/27 |
 | enum | 14/16 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMaximum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | exclusiveMinimum | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -274,50 +274,52 @@ The following table shows specification coverage implemented by TypeBox.
 | properties | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | propertyNames | - | - | ✅ | ✅ | ✅ | ✅ | ✅ |
 | recursiveRef | - | - | - | - | ✅ | - | - |
-| ref | 22/27 | 37/45 | 67/70 | 75/78 | 79/81 | 77/79 | 77/79 |
+| ref | 22/27 | 37/45 | 67/70 | 75/78 | 79/81 | 77/79 | 78/79 |
 | required | 3/4 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | type | 73/80 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 | unevaluatedItems | - | - | - | - | ✅ | ✅ | 70/71 |
 | unevaluatedProperties | - | - | - | - | ✅ | ✅ | 128/129 |
 | uniqueItems | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
 
-
 ### Performance
 
-The following table shows compile performance for various JSON Schema structures using AJV8 as a basis for comparison. 
+TypeBox tracks comparative performance against AJV8 as the de facto performance standard. For broader comparative benchmarks, refer to the community maintained projects below.
+
+[Runtime Benchmarks](https://moltar.github.io/typescript-runtime-type-benchmarks/) | [Schema Benchmarks](https://schemabenchmarks.dev/)
+
+The following table shows compilation performance for various JSON Schema structures. These benchmarks measure the time required to JIT compile schematics, with faster compilation resulting in faster application startup.
 
 ```python
-┌──────────────────────┬─────────────┬─────────────┐
-│ Compile              │ TB1X        │ AJV8        │
-├──────────────────────┼─────────────┼─────────────┤
-│ Boolean              │ 39.7K ops/s │  6.8K ops/s │
-│ Number               │ 86.2K ops/s │  7.5K ops/s │
-│ String               │ 82.6K ops/s │  8.2K ops/s │
-│ Null                 │   62K ops/s │  7.3K ops/s │
-│ Literal_String       │ 72.1K ops/s │  5.7K ops/s │
-│ Literal_Number       │ 72.7K ops/s │  6.9K ops/s │
-│ Literal_Boolean      │ 80.9K ops/s │    7K ops/s │
-│ Pattern              │ 38.7K ops/s │  5.7K ops/s │
-│ Object_Open          │ 16.3K ops/s │  1.3K ops/s │
-│ Object_Close         │ 15.7K ops/s │   952 ops/s │
-│ Object_Vector3       │ 40.2K ops/s │  3.2K ops/s │
-│ Object_Basis3        │ 16.1K ops/s │   834 ops/s │
-│ Intersect_And        │ 45.7K ops/s │  3.5K ops/s │
-│ Intersect_Structural │   21K ops/s │  1.6K ops/s │
-│ Union_Or             │ 45.1K ops/s │  3.4K ops/s │
-│ Union_Structural     │ 27.6K ops/s │    2K ops/s │
-│ Tuple_Values         │ 14.7K ops/s │    2K ops/s │
-│ Tuple_Objects        │  3.7K ops/s │   380 ops/s │
-│ Array_Numbers_4      │ 73.6K ops/s │  4.3K ops/s │
-│ Array_Numbers_8      │ 50.9K ops/s │  3.8K ops/s │
-│ Array_Numbers_16     │   85K ops/s │  3.9K ops/s │
-│ Array_Objects_Open   │ 18.9K ops/s │   789 ops/s │
-│ Array_Objects_Close  │ 17.9K ops/s │   909 ops/s │
-└──────────────────────┴─────────────┴─────────────┘
+┌──────────────────────┬──────────────┬──────────────┐
+│ Compile              │ TB1X         │ AJV8         │
+├──────────────────────┼──────────────┼──────────────┤
+│ Boolean              │  50.4K ops/s │   7.1K ops/s │
+│ Number               │ 129.9K ops/s │   7.9K ops/s │
+│ String               │ 128.9K ops/s │   9.1K ops/s │
+│ Null                 │  91.3K ops/s │   8.4K ops/s │
+│ Literal_String       │  63.1K ops/s │   7.4K ops/s │
+│ Literal_Number       │  74.5K ops/s │   7.6K ops/s │
+│ Literal_Boolean      │ 143.3K ops/s │   7.7K ops/s │
+│ Pattern              │  94.2K ops/s │   6.4K ops/s │
+│ Object_Open          │  19.4K ops/s │   1.3K ops/s │
+│ Object_Close         │  17.6K ops/s │    991 ops/s │
+│ Object_Vector3       │  46.1K ops/s │   3.3K ops/s │
+│ Object_Basis3        │    16K ops/s │    848 ops/s │
+│ Intersect_And        │  41.3K ops/s │   4.2K ops/s │
+│ Intersect_Structural │  25.3K ops/s │   1.5K ops/s │
+│ Union_Or             │  58.6K ops/s │   2.4K ops/s │
+│ Union_Structural     │  31.5K ops/s │   1.8K ops/s │
+│ Tuple_Values         │  18.2K ops/s │   1.9K ops/s │
+│ Tuple_Objects        │   3.9K ops/s │    437 ops/s │
+│ Array_Numbers_4      │ 114.5K ops/s │   4.2K ops/s │
+│ Array_Numbers_8      │ 128.3K ops/s │   3.9K ops/s │
+│ Array_Numbers_16     │ 128.4K ops/s │     4K ops/s │
+│ Array_Objects_Open   │    22K ops/s │    780 ops/s │
+│ Array_Objects_Close  │    22K ops/s │     1K ops/s │
+└──────────────────────┴──────────────┴──────────────┘
 ```
 
-
-The following tables shows validation performance for various JSON Schema structures using AJV8 as a basis for comparison.
+The following tables shows validation performance for various JSON Schema structures. These benchmarks measure overall validation throughput for JIT compiled schematics.
 
 ```python
 ┌──────────────────────┬──────────────┬──────────────┐

package/build/format/_idna.d.mts

@@ -1,2 +0,0 @@
-export declare function IsIdnLabel(value: string): boolean;
-export declare function IsLabel(value: string): boolean;

package/build/format/_idna.mjs

@@ -1,246 +0,0 @@
-import { Unreachable } from '../system/unreachable/index.mjs';
-import * as Puny from './_puny.mjs';
-// ------------------------------------------------------------------
-// Unicode General Category Helper (RFC 5892)
-// ------------------------------------------------------------------
-function IsNonspacingMark(cp) {
-    return /\p{Mn}/u.test(String.fromCodePoint(cp));
-}
-function IsSpacingCombiningMark(cp) {
-    return /\p{Mc}/u.test(String.fromCodePoint(cp));
-}
-function IsEnclosingMark(cp) {
-    return /\p{Me}/u.test(String.fromCodePoint(cp));
-}
-function IsCombiningMark(cp) {
-    return IsNonspacingMark(cp) || IsSpacingCombiningMark(cp) || IsEnclosingMark(cp);
-}
-// ------------------------------------------------------------------
-// RFC 5892 §2.6 DISALLOWED exceptions
-//
-// https://tools.ietf.org/html/rfc5892#section-2.6
-// ------------------------------------------------------------------
-const RFC5892_DISALLOWED = new Set([
-    0x0640, // ARABIC TATWEEL
-    0x07fa, // NKO LAJANYALAN
-    0x302e, // HANGUL SINGLE DOT TONE MARK
-    0x302f, // HANGUL DOUBLE DOT TONE MARK
-    0x3031, // VERTICAL KANA REPEAT MARK
-    0x3032, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK
-    0x3033, // VERTICAL KANA REPEAT MARK UPPER HALF
-    0x3034, // VERTICAL KANA REPEAT WITH VOICED ITERATION MARK UPPER HALF
-    0x3035, // VERTICAL KANA REPEAT MARK LOWER HALF
-    0x303b // VERTICAL IDEOGRAPHIC ITERATION MARK
-]);
-// ------------------------------------------------------------------
-// A set of Virama (halant) code points used to validate CONTEXTJ
-// rules (RFC 5892 Appendix A.1). These characters allow a subsequent
-// Zero Width Non-Joiner (U+200C) or Zero Width Joiner (U+200D) to
-// be valid in a label.
-// ------------------------------------------------------------------
-const VIRAMA_CPS = new Set([
-    0x094d,
-    0x09cd,
-    0x0a4d,
-    0x0acd,
-    0x0b4d,
-    0x0bcd,
-    0x0c4d,
-    0x0ccd,
-    0x0d3b,
-    0x0d3c,
-    0x0d4d,
-    0x0dca,
-    0x1b44,
-    0x1baa,
-    0x1bab,
-    0xa9c0,
-    0x11046,
-    0x1107f,
-    0x110b9,
-    0x11133,
-    0x11134,
-    0x111c0,
-    0x11235,
-    0x1134d,
-    0x11442,
-    0x114c2,
-    0x115bf,
-    0x1163f,
-    0x116b6,
-    0x11c3f,
-    0x11d44,
-    0x11d45
-]);
-// ------------------------------------------------------------------
-// Guards for CONTEXTO rules (RFC 5892 Appendix A)
-// ------------------------------------------------------------------
-function IsGreek(cp) {
-    return /\p{Script=Greek}/u.test(String.fromCodePoint(cp));
-}
-function IsHebrew(cp) {
-    return /\p{Script=Hebrew}/u.test(String.fromCodePoint(cp));
-}
-function IsHiragana(cp) {
-    return /\p{Script=Hiragana}/u.test(String.fromCodePoint(cp));
-}
-function IsKatakana(cp) {
-    return /\p{Script=Katakana}/u.test(String.fromCodePoint(cp));
-}
-function IsHan(cp) {
-    return /\p{Script=Han}/u.test(String.fromCodePoint(cp));
-}
-function IsArabicIndicDigit(cp) {
-    return cp >= 0x0660 && cp <= 0x0669;
-}
-function IsExtendedArabicIndicDigit(cp) {
-    return cp >= 0x06f0 && cp <= 0x06f9;
-}
-function IsVirama(cp) {
-    return VIRAMA_CPS.has(cp);
-}
-// ------------------------------------------------------------------
-// IsUnicodeLabel
-// ------------------------------------------------------------------
-function IsUnicodeLabel(value) {
-    // deno-coverage-ignore-start - unable to reach via format guards
-    if (value.length === 0)
-        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;
-    // RFC 5891 §4.2.3.2: Hyphen rules
-    if (cps[0] === 0x2d || cps[len - 1] === 0x2d)
-        return false;
-    if (len >= 4 && cps[2] === 0x2d && cps[3] === 0x2d)
-        return false;
-    // RFC 5891 §4.2.3.2 - Must not begin with a combining mark
-    if (IsCombiningMark(cps[0]))
-        return false;
-    let hasJapanese = false;
-    let hasArabicIndic = false;
-    let hasExtendedArabicIndic = false;
-    for (let i = 0; i < len; i++) {
-        const cp = cps[i];
-        // 1. DISALLOWED exceptions
-        if (RFC5892_DISALLOWED.has(cp))
-            return false;
-        // 2. Collect Flags
-        if (IsHiragana(cp) || IsKatakana(cp) || IsHan(cp))
-            hasJapanese = true;
-        if (IsArabicIndicDigit(cp))
-            hasArabicIndic = true;
-        if (IsExtendedArabicIndicDigit(cp))
-            hasExtendedArabicIndic = true;
-        // 3. CONTEXTO / CONTEXTJ Neighbor Rules
-        const prev = cps[i - 1], next = cps[i + 1];
-        switch (cp) {
-            case 0x00b7:
-                if (prev !== 0x006c || next !== 0x006c)
-                    return false;
-                break; // MIDDLE DOT (Catalan)
-            case 0x0375:
-                if (next === undefined || !IsGreek(next))
-                    return false;
-                break; // Greek KERAIA
-            case 0x05f3:
-            case 0x05f4:
-                if (prev === undefined || !IsHebrew(prev))
-                    return false;
-                break; // Hebrew GERESH
-            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;
-            case 0x30fb: /* Checked at end via hasJapanese */
-                break; // KATAKANA MIDDLE DOT
-        }
-    }
-    // 4. Global Context Validations (Post-loop)
-    // RFC 5892 Appendix A.7 - Katakana Middle Dot requirement
-    if (value.includes('\u30fb') && !hasJapanese)
-        return false;
-    // RFC 5892 Appendix A.8/A.9 - Mixing Arabic Digits
-    if (hasArabicIndic && hasExtendedArabicIndic)
-        return false;
-    return true;
-}
-// ------------------------------------------------------------------
-// IsAsciiLabel
-// ------------------------------------------------------------------
-function IsAsciiLabel(value) {
-    // Must not start or end with a hyphen
-    if (value.charCodeAt(0) === 45 || value.charCodeAt(value.length - 1) === 45)
-        return false;
-    // RFC 5891 §4.2.3.1 : "--" at positions 3-4 is reserved for A-labels only
-    if (value.length >= 4 && value.charCodeAt(2) === 45 && value.charCodeAt(3) === 45)
-        return false;
-    // All characters must be alphanumeric or hyphen
-    for (let i = 0; i < value.length; i++) {
-        const ch = value.charCodeAt(i);
-        if (!((ch >= 97 && ch <= 122) || // a-z
-            (ch >= 65 && ch <= 90) || // A-Z
-            (ch >= 48 && ch <= 57) || // 0-9
-            ch === 45 // '-'
-        ))
-            return false;
-    }
-    return true;
-}
-// ------------------------------------------------------------------
-// IsPunyLabel
-// ------------------------------------------------------------------
-function IsPuny(value) {
-    return value.toLowerCase().startsWith('xn--');
-}
-function IsPunyLabel(value) {
-    try {
-        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;
-    }
-}
-// ------------------------------------------------------------------
-// IsIdnLabel
-// ------------------------------------------------------------------
-export function IsIdnLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsUnicodeLabel(value);
-}
-// ------------------------------------------------------------------
-// IsLabel
-// ------------------------------------------------------------------
-export function IsLabel(value) {
-    if (value.length === 0 || value.length > 63)
-        return false;
-    return IsPuny(value) ? IsPunyLabel(value) : IsAsciiLabel(value);
-}

package/build/format/_puny.d.mts

@@ -1 +0,0 @@
-export declare function Decode(value: string): string;

package/build/format/_puny.mjs

@@ -1,77 +0,0 @@
-import { Unreachable } from '../system/unreachable/index.mjs';
-// ------------------------------------------------------------------
-// PunyCode (RFC 3492)
-// ------------------------------------------------------------------
-const PUNYCODE_BASE = 36;
-const PUNYCODE_TMIN = 1;
-const PUNYCODE_TMAX = 26;
-const PUNYCODE_SKEW = 38;
-const PUNYCODE_DAMP = 700;
-const PUNYCODE_INITIAL_BIAS = 72;
-const PUNYCODE_INITIAL_N = 128;
-// ------------------------------------------------------------------
-// Adapt
-// ------------------------------------------------------------------
-function Adapt(delta, numPoints, firstTime) {
-    delta = firstTime ? Math.floor(delta / PUNYCODE_DAMP) : delta >> 1;
-    delta += Math.floor(delta / numPoints);
-    let k = 0;
-    while (delta > (((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) >> 1)) {
-        delta = Math.floor(delta / (PUNYCODE_BASE - PUNYCODE_TMIN));
-        k += PUNYCODE_BASE;
-    }
-    return k + Math.floor(((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta) / (delta + PUNYCODE_SKEW));
-}
-// ------------------------------------------------------------------
-// Decode
-// ------------------------------------------------------------------
-export function Decode(value) {
-    const output = [];
-    let n = PUNYCODE_INITIAL_N;
-    let i = 0;
-    let bias = PUNYCODE_INITIAL_BIAS;
-    const delimIdx = value.lastIndexOf('-');
-    if (delimIdx > 0) {
-        for (let j = 0; j < delimIdx; j++) {
-            const cp = value.charCodeAt(j);
-            if (cp >= 128)
-                throw new Error('Invalid punycode: non-basic before delimiter');
-            output.push(cp);
-        }
-    }
-    let inIdx = delimIdx < 0 ? 0 : delimIdx + 1;
-    while (inIdx < value.length) {
-        const oldi = i;
-        let w = 1;
-        let k = PUNYCODE_BASE;
-        while (true) {
-            if (inIdx >= value.length)
-                throw new Error('Invalid punycode: unexpected end of input');
-            const ch = value.charCodeAt(inIdx++);
-            let digit;
-            if (ch >= 0x61 && ch <= 0x7a)
-                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)
-                Unreachable(); // digit = ch - 0x41 // A-Z => 0-25
-            // deno-coverage-ignore-stop
-            else
-                throw new Error('Invalid punycode: bad digit character');
-            i += digit * w;
-            const t = k <= bias ? PUNYCODE_TMIN : k >= bias + PUNYCODE_TMAX ? PUNYCODE_TMAX : k - bias;
-            if (digit < t)
-                break;
-            w *= PUNYCODE_BASE - t;
-            k += PUNYCODE_BASE;
-        }
-        const outLen = output.length + 1;
-        bias = Adapt(i - oldi, outLen, oldi === 0);
-        n += Math.floor(i / outLen);
-        i %= outLen;
-        output.splice(i, 0, n);
-        i++;
-    }
-    return globalThis.String.fromCodePoint(...output);
-}

package/build/schema/resolve/ref.d.mts

@@ -1,3 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;
-export declare function DynamicRef(root: Schema.XSchemaObject, base: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;

package/build/schema/resolve/ref.mjs

@@ -1,146 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import * as Schema from '../types/index.mjs';
-// ------------------------------------------------------------------
-// Match: Id
-// ------------------------------------------------------------------
-function MatchId(schema, base, ref) {
-    if (schema.$id === ref.hash)
-        return schema;
-    const absoluteId = new URL(schema.$id, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
-        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Match: Anchor
-// ------------------------------------------------------------------
-function MatchAnchor(schema, base, ref) {
-    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
-}
-// ------------------------------------------------------------------
-// Match: DynamicAnchor
-// ------------------------------------------------------------------
-function MatchDynamicAnchor(schema, base, ref) {
-    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
-}
-// ------------------------------------------------------------------
-// Match: Hash
-//
-// Resolves JSON Pointer fragments only. Plain anchor-style fragments
-// (no leading '/') are handled exclusively by MatchAnchor and
-// MatchDynamicAnchor to prevent accidentally resolving an anchor name
-// as a pointer into the schema tree.
-//
-// ------------------------------------------------------------------
-function MatchHash(schema, _base, ref) {
-    if (ref.href.endsWith('#'))
-        return schema;
-    if (!ref.hash.startsWith('#'))
-        return undefined;
-    const fragment = decodeURIComponent(ref.hash.slice(1));
-    if (!fragment.startsWith('/'))
-        return undefined;
-    return Pointer.Get(schema, fragment);
-}
-// ------------------------------------------------------------------
-// Match
-// ------------------------------------------------------------------
-function Match(schema, base, ref) {
-    if (Schema.IsId(schema)) {
-        const result = MatchId(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsAnchor(schema)) {
-        const result = MatchAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsDynamicAnchor(schema)) {
-        const result = MatchDynamicAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    return MatchHash(schema, base, ref);
-}
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(schema, base, ref) {
-    return schema.reduce((result, item) => {
-        const match = FromValue(item, base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-// ------------------------------------------------------------------
-// FromObject
-// ------------------------------------------------------------------
-function FromObject(schema, base, ref) {
-    return Guard.Keys(schema).reduce((result, key) => {
-        const match = FromValue(schema[key], base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-// ------------------------------------------------------------------
-// FromValue
-// ------------------------------------------------------------------
-function FromValue(schema, base, ref) {
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema)
-        ? new URL(schema.$id, base.href)
-        : base;
-    if (Schema.IsSchemaObject(schema)) {
-        const result = Match(schema, nextBase, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Guard.IsArray(schema))
-        return FromArray(schema, nextBase, ref);
-    if (Guard.IsObject(schema))
-        return FromObject(schema, nextBase, ref);
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Ref
-// ------------------------------------------------------------------
-export function Ref(schema, ref) {
-    const defaultBase = new URL('http://unknown/');
-    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, defaultBase.href) : defaultBase;
-    const initialRef = new URL(ref, initialBase.href);
-    return FromValue(schema, initialBase, initialRef);
-}
-// ------------------------------------------------------------------
-// DynamicRef
-// ------------------------------------------------------------------
-export function DynamicRef(root, base, dynamicRef, dynamicAnchors) {
-    // Resolve the static target using either the local base (for fragment‑only references)
-    // or the document root (for absolute URI references).
-    const fragmentTarget = dynamicRef.$dynamicRef.startsWith('#')
-        ? Ref(base, dynamicRef.$dynamicRef)
-        : Ref(root, dynamicRef.$dynamicRef);
-    if (Guard.IsUndefined(fragmentTarget))
-        return undefined;
-    // Dynamic override only applies if the resolved target itself declares a $dynamicAnchor.
-    // If it does not, return the static target unchanged.
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    // Extract the fragment portion of the reference. According to the test suite,
-    // only plain fragment names (e.g., "#foo") trigger the dynamic scope; JSON 
-    // Pointer fragments (e.g., "#/definitions/foo") bypass dynamic resolution.
-    const fragment = new URL(dynamicRef.$dynamicRef, 'http://unknown/').hash;
-    if (fragment.startsWith('#/'))
-        return fragmentTarget;
-    // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the
-    // target's $dynamicAnchor. The stack reflects the current evaluation path, and
-    // find() returns the outermost (first encountered) match, which is the correct
-    // lexical scope per the specification.
-    const anchorTarget = dynamicAnchors.find(anchor => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor);
-    return anchorTarget ?? fragmentTarget;
-}

package/build/schema/types/contentEncoding.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XContentEncoding<ContentEncoding extends string = string> {
-    contentEncoding: ContentEncoding;
-}
-/**
- * Returns true if the schema contains a valid contentEncoding property
- * @specification Json Schema 7
- */
-export declare function IsContentEncoding(schema: XSchemaObject): schema is XContentEncoding;

package/build/schema/types/contentEncoding.mjs

@@ -1,13 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid contentEncoding property
- * @specification Json Schema 7
- */
-export function IsContentEncoding(schema) {
-    return Guard.HasPropertyKey(schema, 'contentEncoding')
-        && Guard.IsString(schema.contentEncoding);
-}

package/build/schema/types/contentMediaType.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XContentMediaType<ContentMediaType extends string = string> {
-    contentMediaType: ContentMediaType;
-}
-/**
- * Returns true if the schema contains a valid contentMediaType property
- * @specification Json Schema 7
- */
-export declare function IsContentMediaType(schema: XSchemaObject): schema is XContentMediaType;

package/build/schema/types/contentMediaType.mjs

@@ -1,13 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid contentMediaType property
- * @specification Json Schema 7
- */
-export function IsContentMediaType(schema) {
-    return Guard.HasPropertyKey(schema, 'contentMediaType')
-        && Guard.IsString(schema.contentMediaType);
-}