typebox 1.1.20 → 1.1.22

package/build/schema/engine/minProperties.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMinProperties(stack, context, schema, value) {
+export function BuildMinProperties(_stack, _context, schema, value) {
     return E.IsGreaterEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.minProperties));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinProperties(stack, context, schema, value) {
+export function CheckMinProperties(_stack, _context, schema, value) {
     return G.IsGreaterEqualThan(G.Keys(value).length, schema.minProperties);
 }
 // ------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMinimum(stack: Stack, context: BuildContext, schema: Schema.XMinimum, value: string): string;
-export declare function CheckMinimum(stack: Stack, context: CheckContext, schema: Schema.XMinimum, value: number | bigint): boolean;
+export declare function BuildMinimum(_stack: Stack, _context: BuildContext, schema: Schema.XMinimum, value: string): string;
+export declare function CheckMinimum(_stack: Stack, _context: CheckContext, schema: Schema.XMinimum, value: number | bigint): boolean;
 export declare function ErrorMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinimum, value: number | bigint): boolean;

package/build/schema/engine/minimum.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMinimum(stack, context, schema, value) {
+export function BuildMinimum(_stack, _context, schema, value) {
     return E.IsGreaterEqualThan(value, E.Constant(schema.minimum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinimum(stack, context, schema, value) {
+export function CheckMinimum(_stack, _context, schema, value) {
     return G.IsGreaterEqualThan(value, schema.minimum);
 }
 // ------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMultipleOf(stack: Stack, context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
-export declare function CheckMultipleOf(stack: Stack, context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
+export declare function BuildMultipleOf(_stack: Stack, _context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
+export declare function CheckMultipleOf(_stack: Stack, _context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
 export declare function ErrorMultipleOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMultipleOf, value: number | bigint): boolean;

package/build/schema/engine/multipleOf.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMultipleOf(stack, context, schema, value) {
+export function BuildMultipleOf(_stack, _context, schema, value) {
     return E.MultipleOf(value, E.Constant(schema.multipleOf));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMultipleOf(stack, context, schema, value) {
+export function CheckMultipleOf(_stack, _context, schema, value) {
     return G.IsMultipleOf(value, schema.multipleOf);
 }
 // ------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPattern(stack: Stack, context: BuildContext, schema: Schema.XPattern, value: string): string;
-export declare function CheckPattern(stack: Stack, context: CheckContext, schema: Schema.XPattern, value: string): boolean;
+export declare function BuildPattern(_stack: Stack, _context: BuildContext, schema: Schema.XPattern, value: string): string;
+export declare function CheckPattern(_stack: Stack, _context: CheckContext, schema: Schema.XPattern, value: string): boolean;
 export declare function ErrorPattern(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPattern, value: string): boolean;

package/build/schema/engine/pattern.mjs

@@ -4,14 +4,14 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildPattern(stack, context, schema, value) {
+export function BuildPattern(_stack, _context, schema, value) {
     const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern);
     return E.Call(E.Member(regexp, 'test'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckPattern(stack, context, schema, value) {
+export function CheckPattern(_stack, _context, schema, value) {
     const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern, 'u') : schema.pattern;
     return regexp.test(value);
 }

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

@@ -3,4 +3,4 @@ import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
 export declare function BuildRecursiveRef(stack: Stack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
 export declare function CheckRecursiveRef(stack: Stack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

package/build/schema/engine/recursiveRef.mjs

@@ -19,7 +19,7 @@ export function CheckRecursiveRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
     const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
     return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
 }

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

@@ -3,4 +3,4 @@ import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
 export declare function BuildRef(stack: Stack, context: BuildContext, schema: Schema.XRef, value: string): string;
 export declare function CheckRef(stack: Stack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
-export declare function ErrorRef(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;
+export declare function ErrorRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

package/build/schema/engine/ref.mjs

@@ -46,7 +46,7 @@ export function CheckRef(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
     const target = stack.Ref(schema.$ref) ?? false;
     const nextContext = new AccumulatedErrorContext();
     const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRequired(stack: Stack, context: BuildContext, schema: Schema.XRequired, value: string): string;
-export declare function CheckRequired(stack: Stack, context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorRequired(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildRequired(_stack: Stack, _context: BuildContext, schema: Schema.XRequired, value: string): string;
+export declare function CheckRequired(_stack: Stack, _context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/required.mjs

@@ -3,19 +3,19 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildRequired(stack, context, schema, value) {
+export function BuildRequired(_stack, _context, schema, value) {
     return E.ReduceAnd(schema.required.map((key) => E.HasPropertyKey(value, E.Constant(key))));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckRequired(stack, context, schema, value) {
+export function CheckRequired(_stack, _context, schema, value) {
     return G.Every(schema.required, 0, (key) => G.HasPropertyKey(value, key));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRequired(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorRequired(_stack, context, schemaPath, instancePath, schema, value) {
     const requiredProperties = [];
     const isRequired = G.EveryAll(schema.required, 0, (key) => {
         const hasKey = G.HasPropertyKey(value, key);

package/build/schema/engine/type.mjs

@@ -3,7 +3,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeName
 // ------------------------------------------------------------------
-function BuildTypeName(stack, context, type, value) {
+function BuildTypeName(_stack, _context, type, value) {
     return (
     // jsonschema
     G.IsEqual(type, 'object') ? E.IsObjectNotArray(value) :
@@ -24,7 +24,7 @@ function BuildTypeName(stack, context, type, value) {
                                                             G.IsEqual(type, 'void') ? E.IsUndefined(value) :
                                                                 E.Constant(true));
 }
-function CheckTypeName(stack, context, type, schema, value) {
+function CheckTypeName(_stack, _context, type, _schema, value) {
     return (
     // jsonschema
     G.IsEqual(type, 'object') ? G.IsObjectNotArray(value) :

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildUniqueItems(stack: Stack, context: BuildContext, schema: Schema.XUniqueItems, value: string): string;
-export declare function CheckUniqueItems(stack: Stack, context: CheckContext, schema: Schema.XUniqueItems, value: unknown[]): boolean;
-export declare function ErrorUniqueItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUniqueItems, value: unknown[]): boolean;
+export declare function BuildUniqueItems(_stack: Stack, _context: BuildContext, schema: Schema.XUniqueItems, value: string): string;
+export declare function CheckUniqueItems(_stack: Stack, _context: CheckContext, schema: Schema.XUniqueItems, value: unknown[]): boolean;
+export declare function ErrorUniqueItems(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUniqueItems, value: unknown[]): boolean;

package/build/schema/engine/uniqueItems.mjs

@@ -10,7 +10,7 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildUniqueItems(stack, context, schema, value) {
+export function BuildUniqueItems(_stack, _context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
     const set = E.Member(E.New('Set', [E.Call(E.Member(value, 'map'), [E.Member('Hashing', 'Hash')])]), 'size');
@@ -20,7 +20,7 @@ export function BuildUniqueItems(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckUniqueItems(stack, context, schema, value) {
+export function CheckUniqueItems(_stack, _context, schema, value) {
     if (!IsValid(schema))
         return true;
     const set = new Set(value.map(Hashing.Hash)).size;
@@ -30,7 +30,7 @@ export function CheckUniqueItems(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorUniqueItems(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorUniqueItems(_stack, context, schemaPath, instancePath, schema, value) {
     if (!IsValid(schema))
         return true;
     const set = new Set();

package/build/schema/resolve/ref.mjs

@@ -28,7 +28,7 @@ function MatchAnchor(schema, base, ref) {
 // ------------------------------------------------------------------
 // Match: Hash
 // ------------------------------------------------------------------
-function MatchHash(schema, base, ref) {
+function MatchHash(schema, _base, ref) {
     if (ref.href.endsWith('#'))
         return schema;
     return ref.hash.startsWith('#')

package/build/schema/static/additionalProperties.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 export {};

package/build/schema/static/ref.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types no-explicit-any
 // deno-fmt-ignore-file
 export {};

package/build/schema/static/required.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 export {};

package/build/schema/static/static.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 export {};

package/build/schema/static/type.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 export {};

package/build/schema/static/unevaluatedProperties.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 export {};

package/build/system/environment/environment.d.mts

@@ -1 +1 @@
-export * from './can-evaluate.mjs';
+export * from './evaluate.mjs';

package/build/system/environment/environment.mjs

@@ -1 +1 @@
-export * from './can-evaluate.mjs';
+export * from './evaluate.mjs';

package/build/system/environment/evaluate.d.mts

@@ -0,0 +1,9 @@
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export declare function CanEvaluate(): boolean;
+/**
+ * Evaluates code in the current environment. This function will throw if the
+ * environment Content-Security-Policy does not support `unsafe-eval`. Use the
+ * Environment.CanEvaluate() to determine if the environment supports Evaluate
+ * before calling this function.
+ */
+export declare function Evaluate(...args: string[]): globalThis.Function;

package/build/system/environment/evaluate.mjs

@@ -0,0 +1,37 @@
+import { Settings } from '../settings/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+let supported = undefined;
+// ------------------------------------------------------------------
+// TryEvaluate
+// ------------------------------------------------------------------
+function TryEvaluate() {
+    try {
+        Evaluate('null')();
+        return true;
+    } // deno-coverage-ignore-start - unreachable in test-suite
+    catch {
+        return false;
+    }
+    // deno-coverage-ignore-stop
+}
+// ------------------------------------------------------------------
+// CanEvaluate
+// ------------------------------------------------------------------
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export function CanEvaluate() {
+    if (Guard.IsUndefined(supported))
+        supported = TryEvaluate();
+    return supported && Settings.Get().useAcceleration;
+}
+// ------------------------------------------------------------------
+// Evaluate
+// ------------------------------------------------------------------
+/**
+ * Evaluates code in the current environment. This function will throw if the
+ * environment Content-Security-Policy does not support `unsafe-eval`. Use the
+ * Environment.CanEvaluate() to determine if the environment supports Evaluate
+ * before calling this function.
+ */
+export function Evaluate(...args) {
+    return new (globalThis.Function)(...args);
+}

package/build/system/memory/assign.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types no-explicit-any
 // deno-fmt-ignore-file
 import { Metrics } from './metrics.mjs';
 /**

package/build/system/memory/create.mjs

@@ -1,7 +1,8 @@
+// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
 import { Settings } from '../settings/index.mjs';
 import { Metrics } from './metrics.mjs';
-function MergeHidden(left, right, configuration = {}) {
+function MergeHidden(left, right) {
     for (const key of Object.keys(right)) {
         Object.defineProperty(left, key, {
             configurable: true,

package/build/system/memory/discard.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
 import { Metrics } from './metrics.mjs';
 import { Clone } from './clone.mjs';

package/build/type/action/awaited.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/capitalize.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/conditional.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/constructor-parameters.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/evaluate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/exclude.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/extract.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/indexed.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Deferred } from '../types/deferred.mjs';

package/build/type/action/instance-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/interface.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { IsSchema } from '../types/schema.mjs';

package/build/type/action/keyof.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/lowercase.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/mapped.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/module.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/non-nullable.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/omit.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Deferred } from '../types/deferred.mjs';

package/build/type/action/options.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/parameters.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/partial.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/pick.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Deferred } from '../types/deferred.mjs';

package/build/type/action/readonly-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/required.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/return-type.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/uncapitalize.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/action/uppercase.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Deferred } from '../types/deferred.mjs';
 import { Instantiate } from '../engine/instantiate.mjs';

package/build/type/engine/constructor-parameters/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';

package/build/type/engine/cyclic/extends.mjs

@@ -1,10 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Any } from '../../types/any.mjs';
-import { Array, IsArray, ArrayOptions } from '../../types/array.mjs';
+import { Array as _Array_, IsArray, ArrayOptions } from '../../types/array.mjs';
 import { AsyncIterator, IsAsyncIterator } from '../../types/async-iterator.mjs';
 import { Constructor, IsConstructor } from '../../types/constructor.mjs';
-import { Function as _Function, IsFunction } from '../../types/function.mjs';
+import { Function as _Function_, IsFunction } from '../../types/function.mjs';
 import { Intersect, IsIntersect } from '../../types/intersect.mjs';
 import { Iterator, IsIterator } from '../../types/iterator.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
@@ -29,10 +29,10 @@ function FromTypes(types) {
 }
 function FromType(type) {
     return (IsRef(type) ? FromRef(type.$ref) :
-        IsArray(type) ? Array(FromType(type.items), ArrayOptions(type)) :
+        IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
             IsAsyncIterator(type) ? AsyncIterator(FromType(type.iteratorItems)) :
                 IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
-                    IsFunction(type) ? _Function(FromTypes(type.parameters), FromType(type.returnType)) :
+                    IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
                         IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
                             IsIterator(type) ? Iterator(FromType(type.iteratorItems)) :
                                 IsObject(type) ? Object(FromProperties(type.properties)) :

package/build/type/engine/cyclic/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Cyclic } from '../../types/cyclic.mjs';

package/build/type/engine/evaluate/broaden.mjs

@@ -28,7 +28,7 @@ function BroadenType(type, types) {
             ? [...BroadFilter(evaluated, types), evaluated]
             : types);
 }
-function BroadenTypes(types, result = []) {
+function BroadenTypes(types) {
     return types.reduce((result, left) => {
         return (IsObject(left) ? [...result, left] : // push
             IsNever(left) ? result : // ignore

package/build/type/engine/evaluate/compare.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { IsUnknown } from '../../types/unknown.mjs';
 import { Extends, ExtendsResult } from "../../extends/index.mjs";

package/build/type/engine/exclude/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsEnum } from '../../types/enum.mjs';

package/build/type/engine/extract/instantiate.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Memory } from '../../../system/memory/index.mjs';
 import { IsEnum } from '../../types/enum.mjs';

package/build/type/engine/helpers/union.mjs

@@ -1,2 +1,3 @@
+// deno-lint-ignore-file no-explicit-any
 // deno-fmt-ignore-file
 export {};

package/build/type/engine/indexed/from-array.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Intersect, IsIntersect } from '../../types/intersect.mjs';

package/build/type/engine/indexed/from-tuple.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { Literal, IsLiteral } from '../../types/literal.mjs';

package/build/type/engine/interface/instantiate.mjs

@@ -6,7 +6,7 @@ import { InterfaceDeferred } from '../../action/index.mjs';
 import { CanInstantiate } from '../instantiate.mjs';
 import { InstantiateProperties } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
-function InterfaceImmediate(context, state, heritage, properties, options) {
+function InterfaceImmediate(context, _state, heritage, properties, options) {
     const instantiatedHeritage = InstantiateTypes(context, { callstack: [] }, heritage);
     const instantiatedProperties = InstantiateProperties(context, { callstack: [] }, properties);
     const evaluatedInterface = EvaluateIntersect([...instantiatedHeritage, Object(instantiatedProperties)]);