typebox 1.0.31 → 1.0.33

package/build/cjs/value/convert/try/try-null.js

@@ -0,0 +1,64 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryNull = TryNull;
+const index_1 = require("../../../guard/index");
+const try_result_1 = require("./try-result");
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return index_1.Guard.IsEqual(value, BigInt(0)) ? (0, try_result_1.Ok)(null) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return index_1.Guard.IsEqual(value, false) ? (0, try_result_1.Ok)(null) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return index_1.Guard.IsEqual(value, 0) ? (0, try_result_1.Ok)(null) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromNull(value) {
+    return (0, try_result_1.Ok)(null);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const lowercase = value.toLowerCase();
+    const predicate = index_1.Guard.IsEqual(lowercase, 'undefined')
+        || index_1.Guard.IsEqual(lowercase, 'null')
+        || index_1.Guard.IsEqual(value, '')
+        || index_1.Guard.IsEqual(value, '0');
+    return predicate ? (0, try_result_1.Ok)(null) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(value) {
+    return (0, try_result_1.Ok)(null);
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function TryNull(value) {
+    return (index_1.Guard.IsBigInt(value) ? FromBigInt(value) :
+        index_1.Guard.IsBoolean(value) ? FromBoolean(value) :
+            index_1.Guard.IsNumber(value) ? FromNumber(value) :
+                index_1.Guard.IsNull(value) ? FromNull(value) :
+                    index_1.Guard.IsString(value) ? FromString(value) :
+                        index_1.Guard.IsUndefined(value) ? FromUndefined(value) :
+                            (0, try_result_1.Fail)());
+}
+// deno-coverage-ignore-stop

package/build/cjs/value/convert/try/try-number.d.ts

@@ -0,0 +1,2 @@
+import { TResult } from './try-result';
+export declare function TryNumber(value: unknown): TResult<number>;

package/build/cjs/value/convert/try/try-number.js

@@ -0,0 +1,79 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryNumber = TryNumber;
+const index_1 = require("../../../guard/index");
+const try_result_1 = require("./try-result");
+// ------------------------------------------------------------------
+// Two-Phase
+// ------------------------------------------------------------------
+const try_bigint_1 = require("./try-bigint");
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+const maxBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+const minBigInt = BigInt(Number.MIN_SAFE_INTEGER);
+function CanBigIntDowncast(value) {
+    return (value <= maxBigInt && value >= minBigInt);
+}
+function FromBigInt(value) {
+    return CanBigIntDowncast(value) ? (0, try_result_1.Ok)(Number(value)) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return value ? (0, try_result_1.Ok)(1) : (0, try_result_1.Ok)(0);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromNumber(value) {
+    return (0, try_result_1.Ok)(value);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return (0, try_result_1.Ok)(0);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const coerced = +value;
+    if (index_1.Guard.IsNumber(coerced))
+        return (0, try_result_1.Ok)(coerced);
+    const lowercase = value.toLowerCase();
+    if (index_1.Guard.IsEqual(lowercase, 'false'))
+        return (0, try_result_1.Ok)(0);
+    if (index_1.Guard.IsEqual(lowercase, 'true'))
+        return (0, try_result_1.Ok)(1);
+    const result = (0, try_bigint_1.TryBigInt)(value);
+    if ((0, try_result_1.IsOk)(result))
+        return FromBigInt(result.value);
+    return (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(value) {
+    return (0, try_result_1.Ok)(0);
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function TryNumber(value) {
+    return (index_1.Guard.IsBigInt(value) ? FromBigInt(value) :
+        index_1.Guard.IsBoolean(value) ? FromBoolean(value) :
+            index_1.Guard.IsNumber(value) ? FromNumber(value) :
+                index_1.Guard.IsNull(value) ? FromNull(value) :
+                    index_1.Guard.IsString(value) ? FromString(value) :
+                        index_1.Guard.IsUndefined(value) ? FromUndefined(value) :
+                            (0, try_result_1.Fail)());
+}
+// deno-coverage-ignore-stop

package/build/cjs/value/convert/try/try-result.js

@@ -0,0 +1,23 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsOk = IsOk;
+exports.Ok = Ok;
+exports.Fail = Fail;
+const index_1 = require("../../../guard/index");
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+function IsOk(value) {
+    return index_1.Guard.IsObject(value) && index_1.Guard.HasPropertyKey(value, 'value');
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+function Ok(value) {
+    return { value };
+}
+function Fail() {
+    return undefined;
+}

package/build/cjs/value/convert/try/try-string.d.ts

@@ -0,0 +1,2 @@
+import { TResult } from './try-result';
+export declare function TryString(value: unknown): TResult;

package/build/cjs/value/convert/try/try-string.js

@@ -0,0 +1,59 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryString = TryString;
+const index_1 = require("../../../guard/index");
+const try_result_1 = require("./try-result");
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return (0, try_result_1.Ok)(value.toString());
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return (0, try_result_1.Ok)(value.toString());
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return (0, try_result_1.Ok)(value.toString());
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return (0, try_result_1.Ok)('null');
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromString(value) {
+    return (0, try_result_1.Ok)(value);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+function FromUndefined(value) {
+    return (0, try_result_1.Ok)('');
+}
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function TryString(value) {
+    return (index_1.Guard.IsBigInt(value) ? FromBigInt(value) :
+        index_1.Guard.IsBoolean(value) ? FromBoolean(value) :
+            index_1.Guard.IsNumber(value) ? FromNumber(value) :
+                index_1.Guard.IsNull(value) ? FromNull(value) :
+                    index_1.Guard.IsString(value) ? FromString(value) :
+                        index_1.Guard.IsUndefined(value) ? FromUndefined(value) :
+                            (0, try_result_1.Fail)());
+}
+// deno-coverage-ignore-stop

package/build/cjs/value/convert/try/try-undefined.d.ts

@@ -0,0 +1,2 @@
+import { TResult } from './try-result';
+export declare function TryUndefined(value: unknown): TResult<undefined>;

package/build/cjs/value/convert/try/try-undefined.js

@@ -0,0 +1,64 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryUndefined = TryUndefined;
+const index_1 = require("../../../guard/index");
+const try_result_1 = require("./try-result");
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+function FromBigInt(value) {
+    return index_1.Guard.IsEqual(value, BigInt(0)) ? (0, try_result_1.Ok)(undefined) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+function FromBoolean(value) {
+    return index_1.Guard.IsEqual(value, false) ? (0, try_result_1.Ok)(undefined) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+function FromNumber(value) {
+    return index_1.Guard.IsEqual(value, 0) ? (0, try_result_1.Ok)(undefined) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+function FromNull(value) {
+    return (0, try_result_1.Ok)(undefined);
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+function FromString(value) {
+    const lowercase = value.toLowerCase();
+    const predicate = index_1.Guard.IsEqual(lowercase, 'undefined')
+        || index_1.Guard.IsEqual(lowercase, 'null')
+        || index_1.Guard.IsEqual(value, '')
+        || index_1.Guard.IsEqual(value, '0');
+    return predicate ? (0, try_result_1.Ok)(undefined) : (0, try_result_1.Fail)();
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function FromUndefined(value) {
+    return (0, try_result_1.Ok)(undefined);
+}
+// deno-coverage-ignore-stop
+// ------------------------------------------------------------------
+// Try
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - unreachable | guarded
+function TryUndefined(value) {
+    return (index_1.Guard.IsBigInt(value) ? FromBigInt(value) :
+        index_1.Guard.IsBoolean(value) ? FromBoolean(value) :
+            index_1.Guard.IsNumber(value) ? FromNumber(value) :
+                index_1.Guard.IsNull(value) ? FromNull(value) :
+                    index_1.Guard.IsString(value) ? FromString(value) :
+                        index_1.Guard.IsUndefined(value) ? FromUndefined(value) :
+                            (0, try_result_1.Fail)());
+}
+// deno-coverage-ignore-stop

package/build/cjs/value/convert/try/try.d.ts

@@ -0,0 +1,7 @@
+export * from './try-bigint';
+export * from './try-boolean';
+export * from './try-null';
+export * from './try-number';
+export * from './try-result';
+export * from './try-string';
+export * from './try-undefined';

package/build/cjs/value/convert/try/try.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./try-bigint"), exports);
+__exportStar(require("./try-boolean"), exports);
+__exportStar(require("./try-null"), exports);
+__exportStar(require("./try-number"), exports);
+__exportStar(require("./try-result"), exports);
+__exportStar(require("./try-string"), exports);
+__exportStar(require("./try-undefined"), exports);

package/build/cjs/value/create/create.d.ts

@@ -0,0 +1,5 @@
+import type { TProperties, TSchema, Static } from '../../type/index';
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+export declare function Create<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type): Result;
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+export declare function Create<const Context extends TProperties, Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type): Result;

package/build/cjs/value/create/create.js

@@ -0,0 +1,14 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Create = Create;
+const index_1 = require("../../system/arguments/index");
+const from_type_1 = require("./from-type");
+/** Creates a value from the provided type. This function will use `default` annotations if present. */
+function Create(...args) {
+    const [context, type] = index_1.Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type],
+    });
+    return (0, from_type_1.FromType)(context, type);
+}

package/build/cjs/value/create/error.d.ts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../../type/index';
+export declare class CreateError extends Error {
+    readonly type: TSchema;
+    constructor(type: TSchema, message: string);
+}

package/build/cjs/value/create/error.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateError = void 0;
+class CreateError extends Error {
+    constructor(type, message) {
+        super(message);
+        this.type = type;
+    }
+}
+exports.CreateError = CreateError;

package/build/cjs/value/create/from-array.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TArray } from '../../type/index';
+export declare function FromArray(context: TProperties, type: TArray): unknown;

package/build/cjs/value/create/from-array.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromArray = FromArray;
+const index_1 = require("../../schema/types/index");
+const from_type_1 = require("./from-type");
+const error_1 = require("./error");
+function FromArray(context, type) {
+    if ((0, index_1.IsUniqueItems)(type) && !(0, index_1.IsDefault)(type))
+        throw new error_1.CreateError(type, 'Arrays with uniqueItems constraints must specify a default annotation');
+    const length = (0, index_1.IsMinItems)(type) ? type.minItems : 0;
+    return Array.from({ length }, () => (0, from_type_1.FromType)(context, type.items));
+}

package/build/cjs/value/create/from-async-iterator.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TAsyncIterator } from '../../type/index';
+export declare function FromAsyncIterator(context: TProperties, type: TAsyncIterator): unknown;

package/build/cjs/value/create/from-async-iterator.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromAsyncIterator = FromAsyncIterator;
+async function* CreateAsyncIterator() { }
+function FromAsyncIterator(context, type) {
+    return CreateAsyncIterator();
+}

package/build/cjs/value/create/from-base.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, Base } from '../../type/index';
+export declare function FromBase(context: TProperties, type: Base): unknown;

package/build/cjs/value/create/from-base.js

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBase = FromBase;
+function FromBase(context, type) {
+    return type.Create();
+}

package/build/cjs/value/create/from-bigint.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TBigInt } from '../../type/index';
+export declare function FromBigInt(context: TProperties, type: TBigInt): unknown;

package/build/cjs/value/create/from-bigint.js

@@ -0,0 +1,10 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBigInt = FromBigInt;
+const index_1 = require("../../schema/types/index");
+function FromBigInt(context, type) {
+    return ((0, index_1.IsExclusiveMinimum)(type) ? BigInt(type.exclusiveMinimum) + BigInt(1) :
+        (0, index_1.IsMinimum)(type) ? BigInt(type.minimum) :
+            BigInt(0));
+}

package/build/cjs/value/create/from-boolean.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TBoolean } from '../../type/index';
+export declare function FromBoolean(context: TProperties, type: TBoolean): unknown;

package/build/cjs/value/create/from-boolean.js

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromBoolean = FromBoolean;
+function FromBoolean(context, type) {
+    return false;
+}

package/build/cjs/value/create/from-constructor.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TConstructor } from '../../type/index';
+export declare function FromConstructor(context: TProperties, type: TConstructor): unknown;

package/build/cjs/value/create/from-constructor.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromConstructor = FromConstructor;
+const from_type_1 = require("./from-type");
+function FromConstructor(context, type) {
+    const instanceType = (0, from_type_1.FromType)(context, type.instanceType);
+    return class {
+        constructor() {
+            Object.assign(this, instanceType);
+        }
+    };
+}

package/build/cjs/value/create/from-cyclic.d.ts

@@ -0,0 +1,2 @@
+import { type TProperties, type TCyclic } from '../../type/index';
+export declare function FromCyclic(context: TProperties, type: TCyclic): unknown;

package/build/cjs/value/create/from-cyclic.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromCyclic = FromCyclic;
+const index_1 = require("../../type/index");
+const from_type_1 = require("./from-type");
+function FromCyclic(context, type) {
+    return (0, from_type_1.FromType)({ ...context, ...type.$defs }, (0, index_1.Ref)(type.$ref));
+}

package/build/cjs/value/create/from-default.d.ts

@@ -0,0 +1,3 @@
+import { type TProperties } from '../../type/index';
+import { type XDefault } from '../../schema/types/index';
+export declare function FromDefault(context: TProperties, schema: XDefault): unknown;

package/build/cjs/value/create/from-default.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromDefault = FromDefault;
+const index_1 = require("../../guard/index");
+const index_2 = require("../clone/index");
+function FromDefault(context, schema) {
+    return index_1.Guard.IsFunction(schema.default)
+        ? schema.default(schema)
+        : index_1.Guard.IsObject(schema.default)
+            ? (0, index_2.Clone)(schema.default)
+            : schema.default;
+}

package/build/cjs/value/create/from-enum.d.ts

@@ -0,0 +1,2 @@
+import { type TProperties, type TEnum } from '../../type/index';
+export declare function FromEnum(context: TProperties, type: TEnum): unknown;

package/build/cjs/value/create/from-enum.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromEnum = FromEnum;
+const index_1 = require("../../type/engine/enum/index");
+const from_type_1 = require("./from-type");
+function FromEnum(context, type) {
+    return (0, from_type_1.FromType)(context, (0, index_1.EnumToUnion)(type));
+}

package/build/cjs/value/create/from-function.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TFunction } from '../../type/index';
+export declare function FromFunction(context: TProperties, type: TFunction): unknown;

package/build/cjs/value/create/from-function.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromFunction = FromFunction;
+const from_type_1 = require("./from-type");
+function FromFunction(context, type) {
+    const returnType = (0, from_type_1.FromType)(context, type.returnType);
+    return () => returnType;
+}

package/build/cjs/value/create/from-integer.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TInteger } from '../../type/index';
+export declare function FromInteger(context: TProperties, type: TInteger): unknown;

package/build/cjs/value/create/from-integer.js

@@ -0,0 +1,11 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromInteger = FromInteger;
+const index_1 = require("../../guard/index");
+const index_2 = require("../../schema/types/index");
+function FromInteger(context, type) {
+    return (((0, index_2.IsExclusiveMinimum)(type) && index_1.Guard.IsNumber(type.exclusiveMinimum)) ? type.exclusiveMinimum + 1 :
+        (0, index_2.IsMinimum)(type) ? type.minimum :
+            0);
+}

package/build/cjs/value/create/from-intersect.d.ts

@@ -0,0 +1,2 @@
+import { type TProperties, type TIntersect } from '../../type/index';
+export declare function FromIntersect(context: TProperties, type: TIntersect): unknown;

package/build/cjs/value/create/from-intersect.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromIntersect = FromIntersect;
+const index_1 = require("../../type/index");
+const from_type_1 = require("./from-type");
+function FromIntersect(context, type) {
+    return (0, from_type_1.FromType)(context, (0, index_1.Evaluate)(type));
+}

package/build/cjs/value/create/from-iterator.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TIterator } from '../../type/index';
+export declare function FromIterator(context: TProperties, type: TIterator): unknown;

package/build/cjs/value/create/from-iterator.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromIterator = FromIterator;
+function* CreateIterator() { }
+function FromIterator(context, type) {
+    return CreateIterator();
+}

package/build/cjs/value/create/from-literal.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TLiteral } from '../../type/index';
+export declare function FromLiteral(context: TProperties, type: TLiteral): unknown;

package/build/cjs/value/create/from-literal.js

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromLiteral = FromLiteral;
+function FromLiteral(context, type) {
+    return type.const;
+}

package/build/cjs/value/create/from-never.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TNever } from '../../type/index';
+export declare function FromNever(context: TProperties, type: TNever): unknown;

package/build/cjs/value/create/from-never.js

@@ -0,0 +1,8 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromNever = FromNever;
+const error_1 = require("./error");
+function FromNever(context, type) {
+    throw new error_1.CreateError(type, 'Cannot create TNever types');
+}

package/build/cjs/value/create/from-null.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TNull } from '../../type/index';
+export declare function FromNull(context: TProperties, type: TNull): unknown;

package/build/cjs/value/create/from-null.js

@@ -0,0 +1,7 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromNull = FromNull;
+function FromNull(context, type) {
+    return null;
+}

package/build/cjs/value/create/from-number.d.ts

@@ -0,0 +1,2 @@
+import type { TProperties, TNumber } from '../../type/index';
+export declare function FromNumber(context: TProperties, type: TNumber): unknown;