typebox 1.3.11 → 1.3.12

package/build/schema/engine/additionalProperties.mjs

@@ -3,6 +3,7 @@ import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -58,7 +59,7 @@ export function BuildAdditionalPropertiesFast(_context, schema, value) {
 // ------------------------------------------------------------------
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
+    const regexp = V.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
@@ -78,7 +79,7 @@ export function BuildAdditionalProperties(stack, context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckAdditionalProperties(stack, context, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
         return regexp.test(key) ||
             (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
@@ -89,7 +90,7 @@ export function CheckAdditionalProperties(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
     const additionalProperties = [];
     const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;

package/build/schema/engine/pattern.mjs

@@ -1,18 +1,19 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildPattern(_stack, _context, schema, value) {
-    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern);
+    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern);
     return E.Call(E.Member(regexp, 'test'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckPattern(_stack, _context, schema, value) {
-    const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern;
+    const regexp = G.IsString(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern;
     return regexp.test(value);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/patternProperties.mjs

@@ -1,6 +1,7 @@
 // deno-fmt-ignore-file
 import * as Externals from './_externals.mjs';
 import { Unique } from './_unique.mjs';
+import { UnicodeRegExp } from './_regexp.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
 // ------------------------------------------------------------------
@@ -9,7 +10,7 @@ import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from
 export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
         const [key, prop] = [Unique(), Unique()];
-        const regexp = Externals.CreateVariable(new RegExp(pattern, 'u'));
+        const regexp = Externals.CreateVariable(UnicodeRegExp(pattern));
         const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
         const isSchema = BuildSchemaPushStack(stack, context, schema, prop);
         const addKey = context.AddKey(key);
@@ -22,7 +23,7 @@ export function BuildPatternProperties(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function CheckPatternProperties(stack, context, schema, value) {
     return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.Every(G.Entries(value), 0, ([key, prop]) => {
             return !regexp.test(key) || CheckSchemaPushStack(stack, context, schema, prop) && context.AddKey(key);
         });
@@ -34,7 +35,7 @@ export function CheckPatternProperties(stack, context, schema, value) {
 export function ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
-        const regexp = new RegExp(pattern, 'u');
+        const regexp = UnicodeRegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);

package/build/schema/engine/schema.mjs

@@ -45,12 +45,21 @@ import { BuildUnevaluatedItems, CheckUnevaluatedItems, ErrorUnevaluatedItems } f
 import { BuildUnevaluatedProperties, CheckUnevaluatedProperties, ErrorUnevaluatedProperties } from './unevaluatedProperties.mjs';
 import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueItems.mjs';
 // ----------------------------------------------------------------
-// HasTypeName
+// HasTypeName (Optimization)
+//
+// We only consider a schema as having a type name when the schema 
+// has a single type string, or when every element in the type 
+// array is the same. For a type array, we must treat multi-variant 
+// types as unions and therefore can NOT use an optimized forward 
+// type check.
+//
 // ----------------------------------------------------------------
 function HasTypeName(schema, typename) {
-    return Schema.IsType(schema) &&
-        (G.IsArray(schema.type) && G.IsGreaterThan(schema.type.length, 0) && G.Every(schema.type, 0, type => G.IsEqual(type, typename)) ||
-            G.IsEqual(schema.type, typename));
+    return (Schema.IsType(schema) &&
+        ((G.IsArray(schema.type) &&
+            G.IsGreaterThan(schema.type.length, 0) &&
+            G.Every(schema.type, 0, type => G.IsEqual(type, typename))) ||
+            G.IsEqual(schema.type, typename)));
 }
 // ----------------------------------------------------------------
 // HasObject

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

@@ -1,3 +1,4 @@
 import * as Schema from '../types/index.mjs';
+export declare const DefaultBase: URL;
 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

@@ -3,6 +3,10 @@ import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
 import * as Schema from '../types/index.mjs';
 // ------------------------------------------------------------------
+// DefaultBase
+// ------------------------------------------------------------------
+export const DefaultBase = new URL('https://json-schema.org');
+// ------------------------------------------------------------------
 // Match: Id
 // ------------------------------------------------------------------
 function MatchId(schema, base, ref) {
@@ -83,8 +87,15 @@ function FromArray(schema, base, ref) {
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
+function SkipProperty(key) {
+    // these are explicit data encoded in a schema, they should not
+    // be considered valid targets used for de-referencing.
+    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
+}
 function FromObject(schema, base, ref) {
     return Guard.Keys(schema).reduce((result, key) => {
+        if (SkipProperty(key))
+            return result;
         const match = FromValue(schema[key], base, ref);
         return !Guard.IsUndefined(match) ? match : result;
     }, undefined);
@@ -111,8 +122,7 @@ function FromValue(schema, base, ref) {
 // 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 initialBase = Schema.IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
     const initialRef = new URL(ref, initialBase.href);
     return FromValue(schema, initialBase, initialRef);
 }
@@ -134,7 +144,7 @@ export function DynamicRef(root, base, dynamicRef, dynamicAnchors) {
     // 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;
+    const fragment = new URL(dynamicRef.$dynamicRef, DefaultBase).hash;
     if (fragment.startsWith('#/'))
         return fragmentTarget;
     // Search the live dynamic anchor stack for a schema whose $dynamicAnchor matches the

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

@@ -6,8 +6,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';

package/build/schema/types/index.mjs

@@ -12,8 +12,6 @@ export * from './anchor.mjs';
 export * from './anyOf.mjs';
 export * from './const.mjs';
 export * from './contains.mjs';
-export * from './contentEncoding.mjs';
-export * from './contentMediaType.mjs';
 export * from './default.mjs';
 export * from './defs.mjs';
 export * from './dependencies.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.3.11",
+  "version": "1.3.12",
   "keywords": [
     "typescript",
     "jsonschema"

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/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);
-}