@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-17

package/build/require/value/mutate/mutate.js

@@ -1,9 +1,39 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mutate = exports.ValueMutateInvalidRootMutationError = exports.ValueMutateTypeMismatchError = void 0;
 const index_1 = require("../guard/index");
 const index_2 = require("../pointer/index");
 const index_3 = require("../clone/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValueMutateTypeMismatchError extends Error {
     constructor() {
         super('Cannot assign due type mismatch of assignable values');
@@ -74,13 +104,21 @@ function Visit(root, path, current, next) {
     if ((0, index_1.IsValueType)(next))
         return ValueType(root, path, current, next);
 }
+// ------------------------------------------------------------------
+// IsNonMutableValue
+// ------------------------------------------------------------------
 function IsNonMutableValue(value) {
     return (0, index_1.IsTypedArray)(value) || (0, index_1.IsValueType)(value);
 }
 function IsMismatchedValue(current, next) {
+    // prettier-ignore
     return (((0, index_1.IsPlainObject)(current) && (0, index_1.IsArray)(next)) ||
         ((0, index_1.IsArray)(current) && (0, index_1.IsPlainObject)(next)));
 }
+// ------------------------------------------------------------------
+// Mutate
+// ------------------------------------------------------------------
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
 function Mutate(current, next) {
     if (IsNonMutableValue(current) || IsNonMutableValue(next))
         throw new ValueMutateInvalidRootMutationError();

package/build/require/value/pointer/index.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValuePointer = void 0;
 exports.ValuePointer = require("./pointer");

package/build/require/value/pointer/pointer.d.ts

@@ -9,8 +9,13 @@ export declare class ValuePointerRootDeleteError extends Error {
     readonly path: string;
     constructor(value: unknown, path: string);
 }
+/** Formats the given pointer into navigable key components */
 export declare function Format(pointer: string): IterableIterator<string>;
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
 export declare function Set(value: any, pointer: string, update: unknown): void;
+/** Deletes a value at the given pointer */
 export declare function Delete(value: any, pointer: string): void;
+/** Returns true if a value exists at the given pointer */
 export declare function Has(value: any, pointer: string): boolean;
+/** Gets the value at the given pointer */
 export declare function Get(value: any, pointer: string): any;

package/build/require/value/pointer/pointer.js

@@ -1,6 +1,36 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Get = exports.Has = exports.Delete = exports.Set = exports.Format = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class ValuePointerRootSetError extends Error {
     constructor(value, path, update) {
         super('Cannot set root value');
@@ -18,9 +48,16 @@ class ValuePointerRootDeleteError extends Error {
     }
 }
 exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+// ------------------------------------------------------------------
+// ValuePointer
+// ------------------------------------------------------------------
+/** Provides functionality to update values through RFC6901 string pointers */
+// prettier-ignore
 function Escape(component) {
     return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
 }
+/** Formats the given pointer into navigable key components */
+// prettier-ignore
 function* Format(pointer) {
     if (pointer === '')
         return;
@@ -44,6 +81,8 @@ function* Format(pointer) {
     yield Escape(pointer.slice(start));
 }
 exports.Format = Format;
+/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
+// prettier-ignore
 function Set(value, pointer, update) {
     if (pointer === '')
         throw new ValuePointerRootSetError(value, pointer, update);
@@ -58,6 +97,8 @@ function Set(value, pointer, update) {
     owner[key] = update;
 }
 exports.Set = Set;
+/** Deletes a value at the given pointer */
+// prettier-ignore
 function Delete(value, pointer) {
     if (pointer === '')
         throw new ValuePointerRootDeleteError(value, pointer);
@@ -78,6 +119,8 @@ function Delete(value, pointer) {
     }
 }
 exports.Delete = Delete;
+/** Returns true if a value exists at the given pointer */
+// prettier-ignore
 function Has(value, pointer) {
     if (pointer === '')
         return true;
@@ -92,6 +135,8 @@ function Has(value, pointer) {
     return Object.getOwnPropertyNames(owner).includes(key);
 }
 exports.Has = Has;
+/** Gets the value at the given pointer */
+// prettier-ignore
 function Get(value, pointer) {
     if (pointer === '')
         return value;

package/build/require/value/transform/decode.d.ts

@@ -11,4 +11,9 @@ export declare class TransformDecodeError extends Error {
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);
 }
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
 export declare function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/require/value/transform/decode.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformDecode = exports.TransformDecodeError = exports.TransformDecodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +35,10 @@ const index_3 = require("../../type/keyof/index");
 const index_4 = require("../../type/indexed/index");
 const index_5 = require("../deref/index");
 const index_6 = require("../check/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// thrown externally
 class TransformDecodeCheckError extends Error {
     constructor(schema, value, error) {
         super(`Unable to decode due to invalid value`);
@@ -25,6 +56,10 @@ class TransformDecodeError extends Error {
     }
 }
 exports.TransformDecodeError = TransformDecodeError;
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Decode(value) : value;
@@ -33,11 +68,13 @@ function Default(schema, value) {
         throw new TransformDecodeError(schema, value, error);
     }
 }
+// prettier-ignore
 function TArray(schema, references, value) {
     return ((0, index_2.IsArray)(value))
         ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
         : Default(schema, value);
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
         return Default(schema, value);
@@ -62,6 +99,7 @@ function TIntersect(schema, references, value) {
 function TNot(schema, references, value) {
     return Default(schema, Visit(schema.not, references, value));
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
@@ -83,6 +121,7 @@ function TObject(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     if (!(0, index_2.IsPlainObject)(value))
         return Default(schema, value);
@@ -105,28 +144,34 @@ function TRecord(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
+// prettier-ignore
 function TRef(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
+// prettier-ignore
 function TThis(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     return ((0, index_2.IsArray)(value) && (0, index_2.IsArray)(schema.items))
         ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
         : Default(schema, value);
 }
+// prettier-ignore
 function TUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
+        // note: ensure interior is decoded first
         const decoded = Visit(subschema, references, value);
         return Default(schema, decoded);
     }
     return Default(schema, value);
 }
+// prettier-ignore
 function Visit(schema, references, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
@@ -155,6 +200,11 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
 function TransformDecode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/encode.d.ts

@@ -11,4 +11,10 @@ export declare class TransformEncodeError extends Error {
     readonly value: unknown;
     constructor(schema: TSchema, value: unknown, error: any);
 }
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
 export declare function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/build/require/value/transform/encode.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransformEncode = exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
 const type_1 = require("../../type/guard/type");
@@ -8,6 +35,9 @@ const index_3 = require("../../type/keyof/index");
 const index_4 = require("../../type/indexed/index");
 const index_5 = require("../deref/index");
 const index_6 = require("../check/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
 class TransformEncodeCheckError extends Error {
     constructor(schema, value, error) {
         super(`Unable to encode due to invalid value`);
@@ -25,6 +55,10 @@ class TransformEncodeError extends Error {
     }
 }
 exports.TransformEncodeError = TransformEncodeError;
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+// prettier-ignore
 function Default(schema, value) {
     try {
         return (0, type_1.TTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
@@ -33,12 +67,14 @@ function Default(schema, value) {
         throw new TransformEncodeError(schema, value, error);
     }
 }
+// prettier-ignore
 function TArray(schema, references, value) {
     const defaulted = Default(schema, value);
     return (0, index_2.IsArray)(defaulted)
         ? defaulted.map((value) => Visit(schema.items, references, value))
         : defaulted;
 }
+// prettier-ignore
 function TIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value) || (0, index_2.IsValueType)(value))
@@ -60,9 +96,11 @@ function TIntersect(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TNot(schema, references, value) {
     return Default(schema.not, Default(schema, value));
 }
+// prettier-ignore
 function TObject(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
@@ -84,6 +122,7 @@ function TObject(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRecord(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_2.IsPlainObject)(value))
@@ -106,27 +145,33 @@ function TRecord(schema, references, value) {
             : value;
     }, knownProperties);
 }
+// prettier-ignore
 function TRef(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
+// prettier-ignore
 function TThis(schema, references, value) {
     const target = (0, index_5.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
+// prettier-ignore
 function TTuple(schema, references, value) {
     const value1 = Default(schema, value);
     return (0, index_2.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
 }
+// prettier-ignore
 function TUnion(schema, references, value) {
+    // test value against union variants
     for (const subschema of schema.anyOf) {
         if (!(0, index_6.Check)(subschema, references, value))
             continue;
         const value1 = Visit(subschema, references, value);
         return Default(schema, value1);
     }
+    // test transformed value against union variants
     for (const subschema of schema.anyOf) {
         const value1 = Visit(subschema, references, value);
         if (!(0, index_6.Check)(schema, references, value1))
@@ -135,6 +180,7 @@ function TUnion(schema, references, value) {
     }
     return Default(schema, value);
 }
+// prettier-ignore
 function Visit(schema, references, value) {
     const references_ = typeof schema.$id === 'string' ? [...references, schema] : references;
     const schema_ = schema;
@@ -161,6 +207,12 @@ function Visit(schema, references, value) {
             return Default(schema_, value);
     }
 }
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
 function TransformEncode(schema, references, value) {
     return Visit(schema, references, value);
 }

package/build/require/value/transform/has.d.ts

@@ -1,2 +1,3 @@
 import type { TSchema } from '../../type/schema/index';
+/** Returns true if this schema contains a transform codec */
 export declare function HasTransform(schema: TSchema, references: TSchema[]): boolean;

package/build/require/value/transform/has.js

@@ -1,60 +1,102 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasTransform = void 0;
 const type_1 = require("../../type/guard/type");
 const index_1 = require("../guard/index");
 const index_2 = require("../deref/index");
 const index_3 = require("../../type/symbols/index");
+// prettier-ignore
 function TArray(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TAsyncIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TConstructor(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TFunction(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIntersect(schema, references) {
     return (0, type_1.TTransform)(schema) || (0, type_1.TTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function TIterator(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.items, references);
 }
+// prettier-ignore
 function TNot(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.not, references);
 }
+// prettier-ignore
 function TObject(schema, references) {
     return ((0, type_1.TTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
         ((0, type_1.TSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
+// prettier-ignore
 function TPromise(schema, references) {
     return (0, type_1.TTransform)(schema) || Visit(schema.item, references);
 }
+// prettier-ignore
 function TRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
     return (0, type_1.TTransform)(schema) || Visit(property, references) || ((0, type_1.TSchema)(schema.additionalProperties) && (0, type_1.TTransform)(schema.additionalProperties));
 }
+// prettier-ignore
 function TRef(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TThis(schema, references) {
     if ((0, type_1.TTransform)(schema))
         return true;
     return Visit((0, index_2.Deref)(schema, references), references);
 }
+// prettier-ignore
 function TTuple(schema, references) {
     return (0, type_1.TTransform)(schema) || (!(0, index_1.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
+// prettier-ignore
 function TUnion(schema, references) {
     return (0, type_1.TTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
+// prettier-ignore
 function Visit(schema, references) {
     const references_ = (0, index_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
@@ -96,6 +138,7 @@ function Visit(schema, references) {
     }
 }
 const visited = new Set();
+/** Returns true if this schema contains a transform codec */
 function HasTransform(schema, references) {
     visited.clear();
     return Visit(schema, references);

package/build/require/value/transform/index.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/value/value/index.js

@@ -1,4 +1,31 @@
 "use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Value = void 0;
 exports.Value = require("./value");