typebox 1.0.41 → 1.0.43

package/build/guard/emit.mjs

@@ -153,7 +153,7 @@ export function Constant(value) {
     return G.IsString(value) ? JSON.stringify(value) : `${value}`;
 }
 export function Ternary(condition, true_, false_) {
-    return `${condition} ? ${true_} : ${false_}`;
+    return `(${condition} ? ${true_} : ${false_})`;
 }
 // ------------------------------------------------------------------
 // Statements

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

@@ -34,6 +34,7 @@ export * from './patternProperties.mjs';
 export * from './prefixItems.mjs';
 export * from './properties.mjs';
 export * from './propertyNames.mjs';
+export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './type.mjs';

package/build/schema/engine/index.mjs

@@ -40,6 +40,7 @@ export * from './patternProperties.mjs';
 export * from './prefixItems.mjs';
 export * from './properties.mjs';
 export * from './propertyNames.mjs';
+export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './type.mjs';

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildRecursiveRef(context: BuildContext, schema: S.XRecursiveRef, value: string): string;
+export declare function CheckRecursiveRef(context: CheckContext, schema: S.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRecursiveRef, value: unknown): boolean;

package/build/schema/engine/recursiveRef.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import * as F from './_functions.mjs';
+import * as S from '../types/index.mjs';
+import { CheckSchema, ErrorSchema } from './schema.mjs';
+import { Resolver } from '../resolver/index.mjs';
+// ------------------------------------------------------------------
+// Resolve
+// ------------------------------------------------------------------
+function Resolve(context, schema) {
+    // note: it is safe to coerce to XSchema here as it wouldn't be possible
+    // to enter a ref resolution if the root schema was boolean.
+    const schemaRoot = context.GetSchema();
+    const dereferenced = Resolver.RecursiveRef(schemaRoot, schema);
+    return S.IsSchema(dereferenced) ? dereferenced : false;
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildRecursiveRef(context, schema, value) {
+    const target = Resolve(context, schema);
+    return F.CreateFunction(context, target, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckRecursiveRef(context, schema, value) {
+    const target = Resolve(context, schema);
+    return (S.IsSchema(target) && CheckSchema(context, target, value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorRecursiveRef(context, schemaPath, instancePath, schema, value) {
+    const target = Resolve(context, schema);
+    return (S.IsSchema(target) && ErrorSchema(context, '#', instancePath, target, value));
+}

package/build/schema/engine/ref.mjs

@@ -3,7 +3,7 @@ import * as F from './_functions.mjs';
 import * as S from '../types/index.mjs';
 import { Guard as G } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
-import { Deref } from '../deref/index.mjs';
+import { Resolver } from '../resolver/index.mjs';
 // ------------------------------------------------------------------
 // Resolve
 // ------------------------------------------------------------------
@@ -16,8 +16,8 @@ function Resolve(context, schema) {
     if (G.HasPropertyKey(schemaContext, schema.$ref)) {
         return schemaContext[schema.$ref];
     }
-    // inline referential schema
-    const dereferenced = Deref(schemaRoot, { $ref: schema.$ref });
+    // referential schema
+    const dereferenced = Resolver.Ref(schemaRoot, schema.$ref);
     return S.IsSchema(dereferenced) ? dereferenced : false;
 }
 // ------------------------------------------------------------------

package/build/schema/engine/schema.mjs

@@ -37,6 +37,7 @@ import { BuildPatternProperties, CheckPatternProperties, ErrorPatternProperties
 import { BuildPrefixItems, CheckPrefixItems, ErrorPrefixItems } from './prefixItems.mjs';
 import { BuildProperties, CheckProperties, ErrorProperties } from './properties.mjs';
 import { BuildPropertyNames, CheckPropertyNames, ErrorPropertyNames } from './propertyNames.mjs';
+import { BuildRecursiveRef, CheckRecursiveRef, ErrorRecursiveRef } from './recursiveRef.mjs';
 import { BuildRef, CheckRef, ErrorRef } from './ref.mjs';
 import { BuildRequired, CheckRequired, ErrorRequired } from './required.mjs';
 import { BuildType, CheckType, ErrorType } from './type.mjs';
@@ -202,6 +203,8 @@ export function BuildSchema(context, schema, value) {
         const guarded = E.Or(E.Not(E.Or(E.IsNumber(value), E.IsBigInt(value))), reduced);
         conditions.push(HasNumberType(schema) ? reduced : guarded);
     }
+    if (S.IsRecursiveRef(schema))
+        conditions.push(BuildRecursiveRef(context, schema, value));
     if (S.IsRef(schema))
         conditions.push(BuildRef(context, schema, value));
     if (S.IsGuard(schema))
@@ -261,6 +264,7 @@ export function CheckSchema(context, schema, value) {
             (!S.IsMaximum(schema) || CheckMaximum(context, schema, value)) &&
             (!S.IsMinimum(schema) || CheckMinimum(context, schema, value)) &&
             (!S.IsMultipleOf(schema) || CheckMultipleOf(context, schema, value)))) &&
+        (!S.IsRecursiveRef(schema) || CheckRecursiveRef(context, schema, value)) &&
         (!S.IsRef(schema) || CheckRef(context, schema, value)) &&
         (!S.IsGuard(schema) || CheckGuard(context, schema, value)) &&
         (!S.IsConst(schema) || CheckConst(context, schema, value)) &&
@@ -307,6 +311,7 @@ export function ErrorSchema(context, schemaPath, instancePath, schema, value) {
             +(!S.IsMaximum(schema) || ErrorMaximum(context, schemaPath, instancePath, schema, value)) &
             +(!S.IsMinimum(schema) || ErrorMinimum(context, schemaPath, instancePath, schema, value)) &
             +(!S.IsMultipleOf(schema) || ErrorMultipleOf(context, schemaPath, instancePath, schema, value)))) &
+        +(!S.IsRecursiveRef(schema) || ErrorRecursiveRef(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsRef(schema) || ErrorRef(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsGuard(schema) || ErrorGuard(context, schemaPath, instancePath, schema, value)) &
         +(!S.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &

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

@@ -0,0 +1 @@
+export * as Pointer from './pointer.mjs';

package/build/schema/pointer/index.mjs

@@ -0,0 +1 @@
+export * as Pointer from './pointer.mjs';

package/build/schema/pointer/pointer.d.mts

@@ -0,0 +1,10 @@
+/** Returns an array of path indices for the given pointer */
+export declare function Indices(pointer: string): string[];
+/** Returns true if a value exists at the current pointer */
+export declare function Has(value: unknown, pointer: string): unknown;
+/** Gets a value at the pointer, or undefined if not exists */
+export declare function Get(value: unknown, pointer: string): unknown;
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export declare function Delete(value: unknown, pointer: string): unknown;

package/build/schema/pointer/pointer.mjs

@@ -0,0 +1,96 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Asserts
+// ------------------------------------------------------------------
+function AssertNotRoot(indices) {
+    if (indices.length === 0)
+        throw Error('Cannot set root');
+}
+function AssertCanSet(value) {
+    if (!Guard.IsObject(value))
+        throw Error('Cannot set value');
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+function IsNumericIndex(index) {
+    return /^(0|[1-9]\d*)$/.test(index);
+}
+function TakeIndexRight(indices) {
+    return [
+        indices.slice(0, indices.length - 1),
+        indices.slice(indices.length - 1)[0]
+    ];
+}
+function HasIndex(index, value) {
+    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
+}
+function GetIndex(index, value) {
+    return Guard.IsObject(value) ? value[index] : undefined;
+}
+function GetIndices(indices, value) {
+    return indices.reduce((value, index) => GetIndex(index, value), value);
+}
+// ------------------------------------------------------------------
+// Indices
+// ------------------------------------------------------------------
+/** Returns an array of path indices for the given pointer */
+export function Indices(pointer) {
+    if (Guard.IsEqual(pointer.length, 0))
+        return [];
+    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
+}
+// ------------------------------------------------------------------
+// Has
+// ------------------------------------------------------------------
+/** Returns true if a value exists at the current pointer */
+export function Has(value, pointer) {
+    let current = value;
+    return Indices(pointer).every(index => {
+        if (!HasIndex(index, current))
+            return false;
+        current = current[index];
+        return true;
+    });
+}
+// ------------------------------------------------------------------
+// Get
+// ------------------------------------------------------------------
+/** Gets a value at the pointer, or undefined if not exists */
+export function Get(value, pointer) {
+    const indices = Indices(pointer);
+    return GetIndices(indices, value);
+}
+// ------------------------------------------------------------------
+// Set
+// ------------------------------------------------------------------
+/** Sets a value at the given pointer. May throw if the target value is not indexable */
+export function Set(value, pointer, next) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    parent[index] = next;
+    return value;
+}
+// ------------------------------------------------------------------
+// Delete
+// ------------------------------------------------------------------
+/** Deletes the value at the given pointer. May throw if the target value is not indexable */
+export function Delete(value, pointer) {
+    const indices = Indices(pointer);
+    AssertNotRoot(indices);
+    const [head, index] = TakeIndexRight(indices);
+    const parent = GetIndices(head, value);
+    AssertCanSet(parent);
+    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
+        parent.splice(+index, 1);
+    }
+    else {
+        delete parent[index];
+    }
+    return value;
+}

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

@@ -0,0 +1 @@
+export * as Resolver from './resolver.mjs';

package/build/schema/resolver/index.mjs

@@ -0,0 +1 @@
+export * as Resolver from './resolver.mjs';

package/build/schema/resolver/recursiveRef.d.mts

@@ -0,0 +1,2 @@
+import * as S from '../types/index.mjs';
+export declare function RecursiveRef(schema: unknown, ref: S.XRecursiveRef): unknown;

package/build/schema/resolver/recursiveRef.mjs

@@ -0,0 +1,47 @@
+import { Guard } from '../../guard/index.mjs';
+import * as S from '../types/index.mjs';
+import { Ref } from './ref.mjs';
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(value, anchor, ref) {
+    for (const item of value) {
+        const resolved = FromValue(item, anchor, ref);
+        if (!Guard.IsUndefined(resolved))
+            return resolved;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function FromObject(value, anchor, ref) {
+    for (const key of Guard.Keys(value)) {
+        const resolved = FromValue(value[key], anchor, ref);
+        if (!Guard.IsUndefined(resolved))
+            return resolved;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(value, anchor, ref) {
+    if (Guard.IsObjectNotArray(value) && S.IsRecursiveAnchor(value)) {
+        anchor = value;
+    }
+    if (value === ref)
+        return Ref(anchor, ref.$recursiveRef);
+    if (Guard.IsArray(value))
+        return FromArray(value, anchor, ref);
+    if (Guard.IsObject(value))
+        return FromObject(value, anchor, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// RecursiveRef
+// ------------------------------------------------------------------
+export function RecursiveRef(schema, ref) {
+    const anchor = schema;
+    return FromValue(schema, anchor, ref);
+}

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

@@ -0,0 +1 @@
+export declare function Ref(schema: unknown, ref: string): unknown;

package/build/schema/resolver/ref.mjs

@@ -0,0 +1,98 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Pointer } from '../pointer/index.mjs';
+import * as S from '../types/index.mjs';
+// ------------------------------------------------------------------
+// MatchId
+// ------------------------------------------------------------------
+function MatchId(value, base, ref) {
+    if (value.$id === ref.hash)
+        return value;
+    const absoluteId = new URL(value.$id, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
+        return ref.hash.startsWith('#') ? MatchHash(value, base, ref) : value;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// MatchAnchor
+// ------------------------------------------------------------------
+function MatchAnchor(value, base, ref) {
+    const absoluteAnchor = new URL(`#${value.$anchor}`, base.href);
+    const absoluteRef = new URL(ref.href, base.href);
+    if (Guard.IsEqual(absoluteAnchor.href, absoluteRef.href))
+        return value;
+    return undefined;
+}
+// ------------------------------------------------------------------
+// MatchHash
+// ------------------------------------------------------------------
+function MatchHash(value, base, ref) {
+    if (ref.href.endsWith('#'))
+        return value;
+    return ref.hash.startsWith('#')
+        ? Pointer.Get(value, decodeURIComponent(ref.hash.slice(1)))
+        : undefined;
+}
+// ------------------------------------------------------------------
+// Match
+// ------------------------------------------------------------------
+function Match(value, base, ref) {
+    if (S.IsId(value)) {
+        const result = MatchId(value, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (S.IsAnchor(value)) {
+        const result = MatchAnchor(value, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return MatchHash(value, base, ref);
+}
+// ------------------------------------------------------------------
+// FromArray
+// ------------------------------------------------------------------
+function FromArray(value, base, ref) {
+    for (const item of value) {
+        const result = FromValue(item, base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// FromObject
+// ------------------------------------------------------------------
+function FromObject(value, base, ref) {
+    for (const key of Guard.Keys(value)) {
+        const result = FromValue(value[key], base, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// FromValue
+// ------------------------------------------------------------------
+function FromValue(value, base, ref) {
+    const newbase = S.IsSchemaObject(value) && S.IsId(value) ? new URL(value.$id, ref.href) : base;
+    if (S.IsSchemaObject(value)) {
+        const result = Match(value, newbase, ref);
+        if (!Guard.IsUndefined(result))
+            return result;
+    }
+    if (Guard.IsArray(value))
+        return FromArray(value, newbase, ref);
+    if (Guard.IsObject(value))
+        return FromObject(value, newbase, ref);
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Ref
+// ------------------------------------------------------------------
+export function Ref(schema, ref) {
+    const base = new URL('', 'http://domain.com');
+    return FromValue(schema, base, new URL(ref, 'http://domain.com'));
+}

package/build/schema/resolver/resolver.d.mts

@@ -0,0 +1,2 @@
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';

package/build/schema/resolver/resolver.mjs

@@ -0,0 +1,2 @@
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';

package/build/schema/schema.d.mts

@@ -1,4 +1,6 @@
 export * from './engine/index.mjs';
+export * from './pointer/index.mjs';
+export * from './resolver/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';

package/build/schema/schema.mjs

@@ -1,4 +1,6 @@
 export * from './engine/index.mjs';
+export * from './pointer/index.mjs';
+export * from './resolver/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';

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

@@ -42,6 +42,8 @@ export * from './patternProperties.mjs';
 export * from './prefixItems.mjs';
 export * from './properties.mjs';
 export * from './propertyNames.mjs';
+export * from './recursiveAnchor.mjs';
+export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';

package/build/schema/types/index.mjs

@@ -48,6 +48,8 @@ export * from './patternProperties.mjs';
 export * from './prefixItems.mjs';
 export * from './properties.mjs';
 export * from './propertyNames.mjs';
+export * from './recursiveAnchor.mjs';
+export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';

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

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRecursiveAnchor<Anchor extends string = string> {
+    $recursiveAnchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property
+ */
+export declare function IsRecursiveAnchor(schema: XSchemaObject): schema is XRecursiveAnchor;

package/build/schema/types/recursiveAnchor.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property
+ */
+export function IsRecursiveAnchor(schema) {
+    return Guard.HasPropertyKey(schema, '$recursiveAnchor')
+        && Guard.IsBoolean(schema.$recursiveAnchor);
+}

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

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRecursiveRef<Ref extends string = string> {
+    $recursiveRef: Ref;
+}
+/**
+ * Returns true if the schema contains a valid $recursiveRef property
+ */
+export declare function IsRecursiveRef(schema: XSchemaObject): schema is XRecursiveRef;

package/build/schema/types/recursiveRef.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $recursiveRef property
+ */
+export function IsRecursiveRef(schema) {
+    return Guard.HasPropertyKey(schema, '$recursiveRef')
+        && Guard.IsString(schema.$recursiveRef);
+}

package/build/system/system.d.mts

@@ -2,5 +2,5 @@ export * from './arguments/index.mjs';
 export * from './environment/index.mjs';
 export * from './hashing/index.mjs';
 export * from './locale/index.mjs';
-export * from './settings/index.mjs';
 export * from './memory/index.mjs';
+export * from './settings/index.mjs';

package/build/system/system.mjs

@@ -2,5 +2,5 @@ export * from './arguments/index.mjs';
 export * from './environment/index.mjs';
 export * from './hashing/index.mjs';
 export * from './locale/index.mjs';
-export * from './settings/index.mjs';
 export * from './memory/index.mjs';
+export * from './settings/index.mjs';

package/build/value/pointer/index.d.mts

@@ -1 +1 @@
-export * as Pointer from './pointer.mjs';
+export * from '../../schema/pointer/index.mjs';

package/build/value/pointer/index.mjs

@@ -1 +1 @@
-export * as Pointer from './pointer.mjs';
+export * from '../../schema/pointer/index.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "keywords": [
     "typescript",
     "jsonschema"
@@ -16,38 +16,38 @@
   "types": "./build/index.d.mts",
   "module": "./build/index.mjs",
   "exports": {
-    "./error": {
-      "import": "./build/error/index.mjs",
-      "default": "./build/error/index.mjs"
+    "./guard": {
+      "import": "./build/guard/index.mjs",
+      "default": "./build/guard/index.mjs"
     },
     "./schema": {
       "import": "./build/schema/index.mjs",
       "default": "./build/schema/index.mjs"
     },
-    "./format": {
-      "import": "./build/format/index.mjs",
-      "default": "./build/format/index.mjs"
-    },
-    "./compile": {
-      "import": "./build/compile/index.mjs",
-      "default": "./build/compile/index.mjs"
-    },
-    "./guard": {
-      "import": "./build/guard/index.mjs",
-      "default": "./build/guard/index.mjs"
-    },
     "./value": {
       "import": "./build/value/index.mjs",
       "default": "./build/value/index.mjs"
     },
+    "./format": {
+      "import": "./build/format/index.mjs",
+      "default": "./build/format/index.mjs"
+    },
     "./type": {
       "import": "./build/type/index.mjs",
       "default": "./build/type/index.mjs"
     },
+    "./error": {
+      "import": "./build/error/index.mjs",
+      "default": "./build/error/index.mjs"
+    },
     "./system": {
       "import": "./build/system/index.mjs",
       "default": "./build/system/index.mjs"
     },
+    "./compile": {
+      "import": "./build/compile/index.mjs",
+      "default": "./build/compile/index.mjs"
+    },
     ".": {
       "import": "./build/index.mjs",
       "default": "./build/index.mjs"
@@ -55,30 +55,30 @@
   },
   "typesVersions": {
     "*": {
-      "error": [
-        "./build/error/index.d.mts"
+      "guard": [
+        "./build/guard/index.d.mts"
       ],
       "schema": [
         "./build/schema/index.d.mts"
       ],
-      "format": [
-        "./build/format/index.d.mts"
-      ],
-      "compile": [
-        "./build/compile/index.d.mts"
-      ],
-      "guard": [
-        "./build/guard/index.d.mts"
-      ],
       "value": [
         "./build/value/index.d.mts"
       ],
+      "format": [
+        "./build/format/index.d.mts"
+      ],
       "type": [
         "./build/type/index.d.mts"
       ],
+      "error": [
+        "./build/error/index.d.mts"
+      ],
       "system": [
         "./build/system/index.d.mts"
       ],
+      "compile": [
+        "./build/compile/index.d.mts"
+      ],
       ".": [
         "./build/index.d.mts"
       ]

package/readme.md

@@ -102,6 +102,30 @@ type T = Type.Static<typeof T>                      // type T = {
                                                     // }
 ```
 
+Constraints and metadata can be passed on the last argument of any given type.
+
+```typescript
+const T = Type.Number({                            // const T = {
+  minimum: 0,                                      //   type: 'number',
+  maximum: 100                                     //   minimum: 0,
+})                                                 //   maximum: 100
+                                                   // }
+
+const S = Type.String({                            // const S = {
+  format: 'email'                                  //   type: 'string',
+})                                                 //   format: 'email'
+                                                   // }
+
+const M = Type.Object({                            // const M = {
+  id: Type.String(),                               //   type: 'object',
+  message: Type.String()                           //   required: ['id', 'message'],
+}, {                                               //   properties: {
+  description: 'A protocol message'                //     id: { type: 'string' },
+})                                                 //     message: { type: 'string' }
+                                                   //   },
+                                                   //   description: 'A protocol message'
+                                                   // }
+```
 
 
 <a name="Script"></a>

package/build/schema/deref/deref.d.mts

@@ -1,4 +0,0 @@
-import * as S from '../types/index.mjs';
-export declare function Rebase(baseUri: string, schema: S.XSchemaObject): string;
-/** Deferences a schema with the given Ref */
-export declare function Deref(schema: object, ref: S.XRef): unknown | undefined;

package/build/schema/deref/deref.mjs

@@ -1,77 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-import { IsJsonPointer, IsUri } from '../../format/index.mjs';
-import { Pointer } from '../../value/pointer/index.mjs';
-import * as S from '../types/index.mjs';
-// ------------------------------------------------------------------
-// Rebase
-// ------------------------------------------------------------------
-export function Rebase(baseUri, schema) {
-    if (!S.IsId(schema))
-        return baseUri;
-    if (IsUri(schema.$id))
-        return schema.$id;
-    if (!IsUri(schema.$id) && IsUri(baseUri)) {
-        return new URL(schema.$id, baseUri).href;
-    }
-    return baseUri;
-}
-// ------------------------------------------------------------------
-// Select
-// ------------------------------------------------------------------
-function IsHashPointer(value) {
-    return IsHash(value) && IsJsonPointer(value.slice(1));
-}
-function IsHash(value) {
-    return value.length > 0 && value[0] === '#';
-}
-function Select(schema, baseUri, $ref) {
-    if (IsUri(baseUri)) {
-        const [base, ref] = [new URL(baseUri), new URL($ref, baseUri)];
-        const matched = base.pathname === ref.pathname;
-        const withHash = IsHash(ref.hash);
-        if (matched && !withHash) {
-            return schema;
-        }
-    }
-    if (IsHashPointer($ref)) {
-        const target = Pointer.Get(schema, $ref.slice(1));
-        if (S.IsSchema(target))
-            return target;
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Traversal
-// ------------------------------------------------------------------
-function FromObject(schema, baseUrl, ref) {
-    // ----------------------------------------------------------------
-    // TypeBox: Fast TCyclic Deref
-    // ----------------------------------------------------------------
-    if (S.IsDefs(schema) && Guard.HasPropertyKey(schema.$defs, ref.$ref)) {
-        return schema.$defs[ref.$ref];
-    }
-    // ----------------------------------------------------------------
-    // Json Schema
-    // ----------------------------------------------------------------
-    const rebase = Rebase(baseUrl, schema);
-    const target = Select(schema, rebase, ref.$ref);
-    if (S.IsSchema(target))
-        return target;
-    // Keep searching ...
-    return Object.values(schema).reduce((result, subschema) => result || FromValue(subschema, rebase, ref), undefined);
-}
-function FromArray(schema, baseUri, ref) {
-    return schema.reduce((result, value) => result || FromValue(value, baseUri, ref), undefined);
-}
-function FromValue(schema, base, ref) {
-    return ((Guard.IsObject(schema) && FromObject(schema, base, ref)) ||
-        (Guard.IsArray(schema) && FromArray(schema, base, ref)) ||
-        undefined);
-}
-// ------------------------------------------------------------------
-// Deref
-// ------------------------------------------------------------------
-/** Deferences a schema with the given Ref */
-export function Deref(schema, ref) {
-    return FromValue(schema, '', ref);
-}

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

@@ -1 +0,0 @@
-export { Deref } from './deref.mjs';

package/build/schema/deref/index.mjs

@@ -1 +0,0 @@
-export { Deref } from './deref.mjs';

package/build/value/pointer/pointer.d.mts

@@ -1,17 +0,0 @@
-type ObjectLike = Record<PropertyKey, any>;
-/** Transforms a pointer into navigable key components */
-export declare function Format(pointer: string): IterableIterator<string>;
-/**
- * Sets the value at the given pointer and returns the updated value. If the pointer
- * path does not exist, the path will be created.
- */
-export declare function Set(value: ObjectLike, pointer: string, update: unknown): ObjectLike;
-/**
- * Deletes a value at the given pointer and returns the updated value.
- */
-export declare function Delete(value: ObjectLike, pointer: string): ObjectLike;
-/** Returns true if a property or element exists at the given pointer */
-export declare function Has(value: ObjectLike, pointer: string): boolean;
-/** Gets the value at the given pointer or undefined if not exists. */
-export declare function Get(value: ObjectLike, pointer: string): unknown | undefined;
-export {};

package/build/value/pointer/pointer.mjs

@@ -1,137 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-class ValuePointerRootSetError extends Error {
-    constructor(value, path, update) {
-        super('Cannot set root value');
-        this.value = value;
-        this.path = path;
-        this.update = update;
-    }
-}
-class ValuePointerRootDeleteError extends Error {
-    constructor(value, path) {
-        super('Cannot delete root value');
-        this.value = value;
-        this.path = path;
-    }
-}
-// ------------------------------------------------------------------
-// ValuePointer
-// ------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-function Escape(component) {
-    const decoded = decodeURIComponent(component);
-    return decoded.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-// ------------------------------------------------------------------
-// Format
-// ------------------------------------------------------------------
-/** Transforms a pointer into navigable key components */
-export function* Format(pointer) {
-    if (pointer === '')
-        return;
-    let [start, end] = [0, 0];
-    for (let i = 0; i < pointer.length; i++) {
-        const char = pointer.charAt(i);
-        if (char === '/') {
-            if (i === 0) {
-                start = i + 1;
-            }
-            else {
-                end = i;
-                yield Escape(pointer.slice(start, end));
-                start = i + 1;
-            }
-        }
-        else {
-            end = i;
-        }
-    }
-    yield Escape(pointer.slice(start));
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-/**
- * Sets the value at the given pointer and returns the updated value. If the pointer
- * path does not exist, the path will be created.
- */
-export function Set(value, pointer, update) {
-    if (pointer === '')
-        throw new ValuePointerRootSetError(value, pointer, update);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (Guard.IsUndefined(next[component]))
-            next[component] = {};
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (Guard.IsObject(owner)) {
-        owner[key] = update;
-    }
-    return value;
-}
-// ------------------------------------------------------------------
-// Delete
-// ------------------------------------------------------------------
-/**
- * Deletes a value at the given pointer and returns the updated value.
- */
-export function Delete(value, pointer) {
-    if (pointer === '')
-        throw new ValuePointerRootDeleteError(value, pointer);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (Guard.IsUndefined(next[component]) || Guard.IsNull(next[component])) {
-            return value;
-        }
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (Guard.IsArray(owner)) {
-        const index = parseInt(key);
-        owner.splice(index, 1);
-    }
-    else if (Guard.IsObject(owner)) {
-        delete owner[key];
-    }
-    return value;
-}
-// ------------------------------------------------------------------
-// Has
-// ------------------------------------------------------------------
-/** Returns true if a property or element exists at the given pointer */
-export function Has(value, pointer) {
-    if (pointer === '')
-        return true;
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (Guard.IsUndefined(next[component]) || Guard.IsNull(next[component])) {
-            return false;
-        }
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    return Object.getOwnPropertyNames(owner).includes(key);
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-/** Gets the value at the given pointer or undefined if not exists. */
-export function Get(value, pointer) {
-    if (pointer === '')
-        return value;
-    let current = value;
-    for (const component of Format(pointer)) {
-        if (current[component] === undefined)
-            return undefined;
-        current = current[component];
-    }
-    return current;
-}