@wener/utils 1.1.27 → 1.1.30

package/lib/schema/typebox/gen/codegen/model/model-to-expression.js

@@ -1,363 +1,359 @@
 import * as Types from '@sinclair/typebox';
 import { TypeSystemPolicy } from '@sinclair/typebox/system';
-import { Formatter } from '../common/formatter.js';
-import '../expression/compiler.js';
-import '../expression/errors.js';
-import '../expression/evaluator.js';
-import { Expression } from '../expression/expression.js';
-
-class TypeTransformUnknownSchemaError extends Error {
-  constructor(schema) {
-    super("TypeTransformUnknownSchemaError: Unknown schema");
-    this.schema = schema;
-  }
+import { Formatter } from '../common/formatter';
+import { Expression } from '../expression/index';
+export class TypeTransformUnknownSchemaError extends Error {
+    schema;
+    constructor(schema){
+        super('TypeTransformUnknownSchemaError: Unknown schema');
+        this.schema = schema;
+    }
 }
-var TypeBoxToExpression;
-((TypeBoxToExpression2) => {
-  function IsArray(value) {
-    return globalThis.Array.isArray(value);
-  }
-  function IsObject(value) {
-    return typeof value === "object" && !IsArray(value);
-  }
-  function IsNumber(value) {
-    return typeof value === "number" && !isNaN(value);
-  }
-  function IsUndefined(value) {
-    return value === void 0;
-  }
-  function Any(schema, references) {
-    return Expression.True({ $id: schema.$id });
-  }
-  function Array(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsArray();
-        if (IsNumber(schema.maxItems))
-          yield Expression.Property("length", Expression.LessThanEqual(schema.maxItems));
-        if (IsNumber(schema.minItems))
-          yield Expression.Property("length", Expression.GreaterThanEqual(schema.minItems));
-        yield Expression.Elements(Visit(schema.items, references));
-        if (schema.uniqueItems === true)
-          yield Expression.ElementsDistinct();
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Boolean(schema, references) {
-    return Expression.IsBoolean({ $id: schema.$id });
-  }
-  function Constructor(schema, references) {
-    return Expression.Property("prototype", Visit(schema.returns, references), { $id: schema.$id });
-  }
-  function Date(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.InstanceOf("Date");
-        if (IsNumber(schema.maximumTimestamp))
-          yield Expression.Call("getTime", [], Expression.LessThanEqual(schema.maximumTimestamp));
-        if (IsNumber(schema.minimumTimestamp))
-          yield Expression.Call("getTime", [], Expression.GreaterThanEqual(schema.minimumTimestamp));
-        if (IsNumber(schema.exclusiveMaximumTimestamp))
-          yield Expression.Call("getTime", [], Expression.LessThan(schema.exclusiveMaximumTimestamp));
-        if (IsNumber(schema.exclusiveMinimumTimestamp))
-          yield Expression.Call("getTime", [], Expression.GreaterThan(schema.exclusiveMinimumTimestamp));
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Function(schema, references) {
-    return Expression.IsFunction({ $id: schema.$id });
-  }
-  function Intersect(schema, references) {
-    return Expression.And(
-      function* () {
-        for (const inner of schema.allOf) {
-          yield Visit(inner, references);
-        }
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Integer(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsInteger();
-        if (IsNumber(schema.multipleOf))
-          yield Expression.MultipleOf(schema.multipleOf);
-        if (IsNumber(schema.maximum))
-          yield Expression.LessThanEqual(schema.maximum);
-        if (IsNumber(schema.minimum))
-          yield Expression.GreaterThanEqual(schema.minimum);
-        if (IsNumber(schema.exclusiveMaximum))
-          yield Expression.LessThan(schema.exclusiveMaximum);
-        if (IsNumber(schema.exclusiveMinimum))
-          yield Expression.GreaterThan(schema.exclusiveMinimum);
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Literal(schema, references) {
-    return Expression.Equals(schema.const, { $id: schema.$id });
-  }
-  function Never(schema, references) {
-    return Expression.False({ $id: schema.$id });
-  }
-  function Null(schema, references) {
-    return Expression.IsNull({ $id: schema.$id });
-  }
-  function Number(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsNumber();
-        if (TypeSystemPolicy.AllowNaN === false)
-          yield Expression.IsFinite();
-        if (IsNumber(schema.multipleOf))
-          yield Expression.MultipleOf(schema.multipleOf);
-        if (IsNumber(schema.maximum))
-          yield Expression.LessThanEqual(schema.maximum);
-        if (IsNumber(schema.minimum))
-          yield Expression.GreaterThanEqual(schema.minimum);
-        if (IsNumber(schema.exclusiveMaximum))
-          yield Expression.LessThan(schema.exclusiveMaximum);
-        if (IsNumber(schema.exclusiveMinimum))
-          yield Expression.GreaterThan(schema.exclusiveMinimum);
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Object(schema, references) {
-    const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-    const requiredKeys = IsArray(schema.required) ? schema.required : [];
-    const optionalKeys = new Set(propertyKeys);
-    requiredKeys.forEach((key) => optionalKeys.delete(key));
-    return Expression.And(
-      function* () {
-        yield Expression.IsObject();
-        yield Expression.Not(Expression.IsNull());
-        if (TypeSystemPolicy.AllowArrayObject === false)
-          yield Expression.Not(Expression.IsArray());
-        if (IsNumber(schema.minProperties))
-          yield Expression.PropertiesMinimum(schema.minProperties);
-        if (IsNumber(schema.maxProperties))
-          yield Expression.PropertiesMaximum(schema.maxProperties);
-        if (schema.additionalProperties === false) {
-          if (schema.required && schema.required.length === propertyKeys.length) {
-            yield Expression.PropertiesLength(propertyKeys.length);
-          } else {
-            yield Expression.PropertiesExclude(propertyKeys, Expression.False());
-          }
-        }
-        if (IsObject(schema.additionalProperties)) {
-          yield Expression.PropertiesExclude(propertyKeys, Visit(schema.additionalProperties, references));
-        }
-        for (const propertyKey of requiredKeys) {
-          yield Expression.Property(propertyKey, Visit(schema.properties[propertyKey], references));
-        }
-        for (const propertyKey of optionalKeys) {
-          yield Expression.Or(function* () {
-            yield Expression.Not(Expression.KeyIn(propertyKey));
-            yield Expression.Property(
-              propertyKey,
-              Expression.Or(function* () {
-                yield Expression.Not(Expression.KeyIn(propertyKey));
-                yield Visit(schema.properties[propertyKey], references);
-              })
-            );
-          });
-        }
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Promise(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsObject();
-        yield Expression.Property("then", Expression.IsFunction());
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Record(schema, references) {
-    const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-    return Expression.And(
-      function* () {
-        yield Expression.IsObject();
-        yield Expression.Not(Expression.IsNull());
-        yield Expression.Not(Expression.InstanceOf("Date"));
-        if (IsNumber(schema.minProperties))
-          yield Expression.PropertiesMinimum(schema.minProperties);
-        if (IsNumber(schema.maxProperties))
-          yield Expression.PropertiesMaximum(schema.maxProperties);
-        yield Expression.PropertiesIncludePattern(keyPattern, Visit(valueSchema, references));
-        if (schema.additionalProperties === false) {
-          yield Expression.PropertiesExcludePattern(keyPattern, Expression.False());
-        }
-        if (IsObject(schema.additionalProperties)) {
-          yield Expression.PropertiesExcludePattern(keyPattern, Visit(schema.additionalProperties, references));
-        }
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Ref(schema, references) {
-    return Expression.Ref(schema.$ref);
-  }
-  function Self(schema, references) {
-    return Expression.Ref(schema.$ref, { $id: schema.$id });
-  }
-  function String(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsString();
-        if (IsNumber(schema.minLength))
-          yield Expression.Property("length", Expression.GreaterThanEqual(schema.minLength));
-        if (IsNumber(schema.maxLength))
-          yield Expression.Property("length", Expression.LessThanEqual(schema.maxLength));
-        if (!IsUndefined(schema.pattern))
-          yield Expression.IsPattern(schema.pattern);
-      },
-      { $id: schema.$id }
-    );
-  }
-  function TemplateLiteral(schema, references) {
-    return Expression.IsPattern(schema.pattern);
-  }
-  function Tuple(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.IsArray();
-        if (schema.items === void 0)
-          return yield Expression.Property("length", Expression.Equals(0));
-        if (schema.maxItems)
-          yield Expression.Property("length", Expression.Equals(schema.maxItems));
-        yield Expression.And(function* () {
-          for (let index = 0; index < schema.items.length; index++) {
-            yield Expression.Index(index, Visit(schema.items[index], references));
-          }
+export var TypeBoxToExpression;
+(function(TypeBoxToExpression) {
+    // --------------------------------------------------------------
+    // Guards
+    // --------------------------------------------------------------
+    function IsArray(value) {
+        return globalThis.Array.isArray(value);
+    }
+    function IsObject(value) {
+        return typeof value === 'object' && !IsArray(value);
+    }
+    function IsNumber(value) {
+        return typeof value === 'number' && !isNaN(value);
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsUndefined(value) {
+        return value === undefined;
+    }
+    // --------------------------------------------------------------
+    // Conditional: If Then Else
+    // --------------------------------------------------------------
+    // function* Conditional(schema: Types.TSchema, references: Types.TSchema[]): IterableIterator<Expression> {
+    //   if (IsUndefined(schema.if)) return
+    //   const if_expression = Visit(schema.if, references)
+    //   const then_expression = IsUndefined(schema.then) ? Expression.True() : Visit(schema.then, references)
+    //   const else_expression = IsUndefined(schema.else) ? Expression.True() : Visit(schema.else, references)
+    //   yield Expression.IfThenElse(if_expression, then_expression, else_expression)
+    // }
+    // --------------------------------------------------------------
+    // Transform
+    // --------------------------------------------------------------
+    function Any(schema, references) {
+        return Expression.True({
+            $id: schema.$id
+        });
+    }
+    function Array(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsArray();
+            if (IsNumber(schema.maxItems)) yield Expression.Property('length', Expression.LessThanEqual(schema.maxItems));
+            if (IsNumber(schema.minItems)) yield Expression.Property('length', Expression.GreaterThanEqual(schema.minItems));
+            yield Expression.Elements(Visit(schema.items, references));
+            if (schema.uniqueItems === true) yield Expression.ElementsDistinct();
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Boolean(schema, references) {
+        return Expression.IsBoolean({
+            $id: schema.$id
+        });
+    }
+    function Constructor(schema, references) {
+        return Expression.Property('prototype', Visit(schema.returns, references), {
+            $id: schema.$id
+        });
+    }
+    function Date(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.InstanceOf('Date');
+            if (IsNumber(schema.maximumTimestamp)) yield Expression.Call('getTime', [], Expression.LessThanEqual(schema.maximumTimestamp));
+            if (IsNumber(schema.minimumTimestamp)) yield Expression.Call('getTime', [], Expression.GreaterThanEqual(schema.minimumTimestamp));
+            if (IsNumber(schema.exclusiveMaximumTimestamp)) yield Expression.Call('getTime', [], Expression.LessThan(schema.exclusiveMaximumTimestamp));
+            if (IsNumber(schema.exclusiveMinimumTimestamp)) yield Expression.Call('getTime', [], Expression.GreaterThan(schema.exclusiveMinimumTimestamp));
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Function(schema, references) {
+        return Expression.IsFunction({
+            $id: schema.$id
+        });
+    }
+    function Intersect(schema, references) {
+        return Expression.And(function*() {
+            for (const inner of schema.allOf){
+                yield Visit(inner, references);
+            }
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Integer(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsInteger();
+            if (IsNumber(schema.multipleOf)) yield Expression.MultipleOf(schema.multipleOf);
+            if (IsNumber(schema.maximum)) yield Expression.LessThanEqual(schema.maximum);
+            if (IsNumber(schema.minimum)) yield Expression.GreaterThanEqual(schema.minimum);
+            if (IsNumber(schema.exclusiveMaximum)) yield Expression.LessThan(schema.exclusiveMaximum);
+            if (IsNumber(schema.exclusiveMinimum)) yield Expression.GreaterThan(schema.exclusiveMinimum);
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Literal(schema, references) {
+        return Expression.Equals(schema.const, {
+            $id: schema.$id
+        });
+    }
+    function Never(schema, references) {
+        return Expression.False({
+            $id: schema.$id
+        });
+    }
+    function Null(schema, references) {
+        return Expression.IsNull({
+            $id: schema.$id
+        });
+    }
+    function Number(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsNumber();
+            if (TypeSystemPolicy.AllowNaN === false) yield Expression.IsFinite();
+            if (IsNumber(schema.multipleOf)) yield Expression.MultipleOf(schema.multipleOf);
+            if (IsNumber(schema.maximum)) yield Expression.LessThanEqual(schema.maximum);
+            if (IsNumber(schema.minimum)) yield Expression.GreaterThanEqual(schema.minimum);
+            if (IsNumber(schema.exclusiveMaximum)) yield Expression.LessThan(schema.exclusiveMaximum);
+            if (IsNumber(schema.exclusiveMinimum)) yield Expression.GreaterThan(schema.exclusiveMinimum);
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Object(schema, references) {
+        const propertyKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
+        const requiredKeys = IsArray(schema.required) ? schema.required : [];
+        const optionalKeys = new Set(propertyKeys);
+        requiredKeys.forEach((key)=>optionalKeys.delete(key));
+        return Expression.And(function*() {
+            yield Expression.IsObject();
+            yield Expression.Not(Expression.IsNull());
+            if (TypeSystemPolicy.AllowArrayObject === false) yield Expression.Not(Expression.IsArray());
+            if (IsNumber(schema.minProperties)) yield Expression.PropertiesMinimum(schema.minProperties);
+            if (IsNumber(schema.maxProperties)) yield Expression.PropertiesMaximum(schema.maxProperties);
+            if (schema.additionalProperties === false) {
+                if (schema.required && schema.required.length === propertyKeys.length) {
+                    yield Expression.PropertiesLength(propertyKeys.length);
+                } else {
+                    yield Expression.PropertiesExclude(propertyKeys, Expression.False());
+                }
+            }
+            if (IsObject(schema.additionalProperties)) {
+                yield Expression.PropertiesExclude(propertyKeys, Visit(schema.additionalProperties, references));
+            }
+            for (const propertyKey of requiredKeys){
+                yield Expression.Property(propertyKey, Visit(schema.properties[propertyKey], references));
+            }
+            for (const propertyKey of optionalKeys){
+                yield Expression.Or(function*() {
+                    yield Expression.Not(Expression.KeyIn(propertyKey));
+                    yield Expression.Property(propertyKey, Expression.Or(function*() {
+                        yield Expression.Not(Expression.KeyIn(propertyKey));
+                        yield Visit(schema.properties[propertyKey], references);
+                    }));
+                });
+            }
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Promise(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsObject();
+            yield Expression.Property('then', Expression.IsFunction());
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Record(schema, references) {
+        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
+        return Expression.And(function*() {
+            yield Expression.IsObject();
+            yield Expression.Not(Expression.IsNull());
+            yield Expression.Not(Expression.InstanceOf('Date'));
+            if (IsNumber(schema.minProperties)) yield Expression.PropertiesMinimum(schema.minProperties);
+            if (IsNumber(schema.maxProperties)) yield Expression.PropertiesMaximum(schema.maxProperties);
+            yield Expression.PropertiesIncludePattern(keyPattern, Visit(valueSchema, references));
+            if (schema.additionalProperties === false) {
+                yield Expression.PropertiesExcludePattern(keyPattern, Expression.False());
+            }
+            if (IsObject(schema.additionalProperties)) {
+                yield Expression.PropertiesExcludePattern(keyPattern, Visit(schema.additionalProperties, references));
+            }
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Ref(schema, references) {
+        return Expression.Ref(schema.$ref);
+    }
+    function Self(schema, references) {
+        return Expression.Ref(schema.$ref, {
+            $id: schema.$id
+        });
+    }
+    function String(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsString();
+            if (IsNumber(schema.minLength)) yield Expression.Property('length', Expression.GreaterThanEqual(schema.minLength));
+            if (IsNumber(schema.maxLength)) yield Expression.Property('length', Expression.LessThanEqual(schema.maxLength));
+            if (!IsUndefined(schema.pattern)) yield Expression.IsPattern(schema.pattern);
+        }, {
+            $id: schema.$id
+        });
+    }
+    function TemplateLiteral(schema, references) {
+        return Expression.IsPattern(schema.pattern);
+    }
+    function Tuple(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.IsArray();
+            if (schema.items === undefined) return yield Expression.Property('length', Expression.Equals(0));
+            if (schema.maxItems) yield Expression.Property('length', Expression.Equals(schema.maxItems));
+            yield Expression.And(function*() {
+                for(let index = 0; index < schema.items.length; index++){
+                    yield Expression.Index(index, Visit(schema.items[index], references));
+                }
+            });
+        }, {
+            $id: schema.$id
         });
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Undefined(schema, references) {
-    return Expression.IsUndefined({ $id: schema.$id });
-  }
-  function Union(schema, references) {
-    return Expression.Or(
-      function* () {
-        for (const inner of schema.anyOf) {
-          yield Visit(inner, references);
+    }
+    function Undefined(schema, references) {
+        return Expression.IsUndefined({
+            $id: schema.$id
+        });
+    }
+    function Union(schema, references) {
+        return Expression.Or(function*() {
+            for (const inner of schema.anyOf){
+                yield Visit(inner, references);
+            }
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Uint8Array(schema, references) {
+        return Expression.And(function*() {
+            yield Expression.InstanceOf('Uint8Array');
+            if (IsNumber(schema.maxByteLength)) yield Expression.Property('length', Expression.LessThanEqual(schema.maxByteLength));
+            if (IsNumber(schema.minByteLength)) yield Expression.Property('length', Expression.GreaterThanEqual(schema.minByteLength));
+        }, {
+            $id: schema.$id
+        });
+    }
+    function Unknown(schema, references) {
+        return Expression.True({
+            $id: schema.$id
+        });
+    }
+    function Void(schema, references) {
+        return Expression.IsUndefined({
+            $id: schema.$id
+        });
+    }
+    function Unresolved(schema, references) {
+        return Expression.False({
+            unresolved: schema
+        });
+    }
+    function Visit(schema, references) {
+        const anyReferences = schema.$id === undefined ? references : [
+            schema,
+            ...references
+        ];
+        const anySchema = schema;
+        switch(anySchema[Types.Kind]){
+            case 'Any':
+                return Any(anySchema, anyReferences);
+            case 'Array':
+                return Array(anySchema, anyReferences);
+            case 'Boolean':
+                return Boolean(anySchema, anyReferences);
+            case 'Constructor':
+                return Constructor(anySchema, anyReferences);
+            case 'Date':
+                return Date(anySchema, anyReferences);
+            case 'Function':
+                return Function(anySchema, anyReferences);
+            case 'Integer':
+                return Integer(anySchema, anyReferences);
+            case 'Intersect':
+                return Intersect(anySchema, anyReferences);
+            case 'Literal':
+                return Literal(anySchema, anyReferences);
+            case 'Never':
+                return Never(anySchema, anyReferences);
+            case 'Null':
+                return Null(anySchema, anyReferences);
+            case 'Number':
+                return Number(anySchema, anyReferences);
+            case 'Object':
+                return Object(anySchema, anyReferences);
+            case 'Promise':
+                return Promise(anySchema, anyReferences);
+            case 'Record':
+                return Record(anySchema, anyReferences);
+            case 'Ref':
+                return Ref(anySchema, anyReferences);
+            case 'Self':
+                return Self(anySchema, anyReferences);
+            case 'String':
+                return String(anySchema, anyReferences);
+            case 'TemplateLiteral':
+                return TemplateLiteral(anySchema, anyReferences);
+            case 'Tuple':
+                return Tuple(anySchema, anyReferences);
+            case 'Undefined':
+                return Undefined(anySchema, anyReferences);
+            case 'Union':
+                return Union(anySchema, anyReferences);
+            case 'Uint8Array':
+                return Uint8Array(anySchema, anyReferences);
+            case 'Unknown':
+                return Unknown(anySchema, anyReferences);
+            case 'Void':
+                return Void(anySchema, anyReferences);
+            default:
+                return Unresolved(schema, anyReferences);
         }
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Uint8Array(schema, references) {
-    return Expression.And(
-      function* () {
-        yield Expression.InstanceOf("Uint8Array");
-        if (IsNumber(schema.maxByteLength))
-          yield Expression.Property("length", Expression.LessThanEqual(schema.maxByteLength));
-        if (IsNumber(schema.minByteLength))
-          yield Expression.Property("length", Expression.GreaterThanEqual(schema.minByteLength));
-      },
-      { $id: schema.$id }
-    );
-  }
-  function Unknown(schema, references) {
-    return Expression.True({ $id: schema.$id });
-  }
-  function Void(schema, references) {
-    return Expression.IsUndefined({ $id: schema.$id });
-  }
-  function Unresolved(schema, references) {
-    return Expression.False({ unresolved: schema });
-  }
-  function Visit(schema, references) {
-    const anyReferences = schema.$id === void 0 ? references : [schema, ...references];
-    const anySchema = schema;
-    switch (anySchema[Types.Kind]) {
-      case "Any":
-        return Any(anySchema);
-      case "Array":
-        return Array(anySchema, anyReferences);
-      case "Boolean":
-        return Boolean(anySchema);
-      case "Constructor":
-        return Constructor(anySchema, anyReferences);
-      case "Date":
-        return Date(anySchema);
-      case "Function":
-        return Function(anySchema);
-      case "Integer":
-        return Integer(anySchema);
-      case "Intersect":
-        return Intersect(anySchema, anyReferences);
-      case "Literal":
-        return Literal(anySchema);
-      case "Never":
-        return Never(anySchema);
-      case "Null":
-        return Null(anySchema);
-      case "Number":
-        return Number(anySchema);
-      case "Object":
-        return Object(anySchema, anyReferences);
-      case "Promise":
-        return Promise(anySchema);
-      case "Record":
-        return Record(anySchema, anyReferences);
-      case "Ref":
-        return Ref(anySchema);
-      case "Self":
-        return Self(anySchema);
-      case "String":
-        return String(anySchema);
-      case "TemplateLiteral":
-        return TemplateLiteral(anySchema);
-      case "Tuple":
-        return Tuple(anySchema, anyReferences);
-      case "Undefined":
-        return Undefined(anySchema);
-      case "Union":
-        return Union(anySchema, anyReferences);
-      case "Uint8Array":
-        return Uint8Array(anySchema);
-      case "Unknown":
-        return Unknown(anySchema);
-      case "Void":
-        return Void(anySchema);
-      default:
-        return Unresolved(schema);
-    }
-  }
-  function Transform(schema, references = []) {
-    const expression = Visit(schema, references);
-    return expression;
-  }
-  TypeBoxToExpression2.Transform = Transform;
+    }
+    function Transform(schema, references = []) {
+        const expression = Visit(schema, references);
+        return expression;
+    }
+    TypeBoxToExpression.Transform = Transform;
 })(TypeBoxToExpression || (TypeBoxToExpression = {}));
-var ModelToExpr;
-((ModelToExpr2) => {
-  function Generate(model) {
-    const definitions = [];
-    for (const type of model.types.filter((type2) => Types.TypeGuard.IsSchema(type2))) {
-      const expression = TypeBoxToExpression.Transform(
-        type,
-        model.types.filter((t) => t.$id !== type.$id)
-      );
-      delete expression.$id;
-      definitions.push(`
+export var ModelToExpr;
+(function(ModelToExpr) {
+    function Generate(model) {
+        const definitions = [];
+        for (const type of model.types.filter((type)=>Types.TypeGuard.IsSchema(type))){
+            const expression = TypeBoxToExpression.Transform(type, model.types.filter((t)=>t.$id !== type.$id));
+            delete expression.$id;
+            definitions.push(`
       export const ${type.$id} = ${JSON.stringify(expression)}
       `);
+        }
+        const output = [
+            ...definitions
+        ];
+        return Formatter.Format(output.join('\n\n'));
     }
-    const output = [...definitions];
-    return Formatter.Format(output.join("\n\n"));
-  }
-  ModelToExpr2.Generate = Generate;
+    ModelToExpr.Generate = Generate;
 })(ModelToExpr || (ModelToExpr = {}));
 
-export { ModelToExpr, TypeBoxToExpression, TypeTransformUnknownSchemaError };
-//# sourceMappingURL=model-to-expression.js.map
+//# sourceMappingURL=model-to-expression.js.map