typia 13.1.19 → 13.3.0

package/src/internal/private/__randomEpoch.ts

@@ -0,0 +1,34 @@
+import { _randomInteger } from "../_randomInteger";
+
+export interface __IEpochProps {
+  minimum?: number;
+  maximum?: number;
+}
+
+/**
+ * Draws an epoch millisecond inside the requested bounds.
+ *
+ * Shared by the `date` and `date-time` generators, which had the same bound
+ * expression written twice: `props?.maximum ?? props?.minimum === undefined`
+ * parses as `props?.maximum ?? (props?.minimum === undefined)` because `??`
+ * binds looser than `===`, so any supplied `maximum` made the condition truthy
+ * and was replaced by `Date.now()`, while `maximum: 0` fell through to
+ * `undefined + one year` and produced `NaN` (issue #2287). Keeping the
+ * resolution in one place is what stops the two copies from drifting again.
+ *
+ * With no bound at all the window ends at the present instant; with only a
+ * lower bound it spans one year from there.
+ */
+export const __randomEpoch = (props?: __IEpochProps): number => {
+  const minimum: number = props?.minimum ?? 0;
+  const maximum: number =
+    props?.maximum ??
+    (props?.minimum === undefined ? Date.now() : props.minimum + YEAR);
+  return _randomInteger({
+    type: "integer",
+    minimum,
+    maximum,
+  });
+};
+
+const YEAR = 365 * 24 * 60 * 60 * 1_000;

package/src/json.ts

@@ -431,10 +431,16 @@ export function createAssertParse(
  */
 export function createAssertParse<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: string) => Primitive<T>;
+): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T>;
 
 /** @internal */
-export function createAssertParse<T>(): (input: string) => Primitive<T> {
+export function createAssertParse<T>(): (
+  input: string,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Primitive<T> {
   NoTransformConfigurationError("json.createAssertParse");
 }
 
@@ -501,10 +507,16 @@ export function createAssertStringify(
  */
 export function createAssertStringify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => string;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string;
 
 /** @internal */
-export function createAssertStringify(): (input: unknown) => string {
+export function createAssertStringify(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => string {
   NoTransformConfigurationError("json.createAssertStringify");
 }
 

package/src/module.ts

@@ -1,10 +1,5 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import {
-  AssertionGuard,
-  IRandomGenerator,
-  IValidation,
-  Resolved,
-} from "@typia/interface";
+import { IRandomGenerator, IValidation, Resolved } from "@typia/interface";
 
 import { TypeGuardError } from "./TypeGuardError";
 import { NoTransformConfigurationError } from "./transformers/NoTransformConfigurationError";
@@ -577,7 +572,7 @@ export function random(): never {
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssert(
@@ -593,14 +588,21 @@ export function createAssert(
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assert function `(input: unknown) => T`
+ * @returns Reusable assert function `(input: unknown, errorFactory?) => T`,
+ *   whose own `errorFactory` overrides this one for that single call
  */
 export function createAssert<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssert<T>(): (input: unknown) => T {
+export function createAssert<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssert");
 }
 
@@ -611,6 +613,9 @@ export function createAssert<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
@@ -629,18 +634,28 @@ export function createAssertGuard(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuard<T>()` — otherwise compile error.
+ * That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type to validate against
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuard<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuard<T>(): AssertionGuard<T> {
+export function createAssertGuard<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuard");
 }
 
@@ -747,7 +762,8 @@ export function createValidate(): ((input: unknown) => IValidation) &
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`
  * @danger You must configure the generic argument `T`
  */
 export function createAssertEquals(
@@ -763,14 +779,21 @@ export function createAssertEquals(
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertEquals function `(input: unknown) => T`
+ * @returns Reusable assertEquals function `(input: unknown, errorFactory?) =>
+ *   T`, whose own `errorFactory` overrides this one for that single call
  */
 export function createAssertEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
-export function createAssertEquals<T>(): (input: unknown) => T {
+export function createAssertEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T {
   NoTransformConfigurationError("createAssertEquals");
 }
 
@@ -781,7 +804,9 @@ export function createAssertEquals<T>(): (input: unknown) => T {
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
@@ -800,19 +825,28 @@ export function createAssertGuardEquals(
  *
  * TypeScript requirement: You must declare the variable type explicitly. `const
  * fn: AssertionGuard<T> = createAssertGuardEquals<T>()` — otherwise compile
- * error.
+ * error. That annotation is one parameter wide, so it also hides the call-time
+ * `errorFactory`; annotate with `(input: unknown, errorFactory?: (props:
+ * TypeGuardError.IProps) => Error) => asserts input is T` when you need it.
  *
  * @template T Target type for exact match
  * @param errorFactory Custom error factory receiving
  *   {@link TypeGuardError.IProps}
- * @returns Reusable assertion guard function
+ * @returns Reusable assertion guard function, whose own `errorFactory`
+ *   overrides this one for that single call
  */
 export function createAssertGuardEquals<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): AssertionGuard<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T;
 
 /** @internal */
-export function createAssertGuardEquals<T>(): AssertionGuard<T> {
+export function createAssertGuardEquals<T>(): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => asserts input is T {
   NoTransformConfigurationError("createAssertGuardEquals");
 }
 

package/src/notations.ts

@@ -530,7 +530,10 @@ export function createAssertCamel(
  */
 export function createAssertCamel<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => CamelCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => CamelCase<T>;
 
 /** @internal */
 export function createAssertCamel(): never {
@@ -618,7 +621,10 @@ export function createAssertPascal(
  */
 export function createAssertPascal<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => PascalCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => PascalCase<T>;
 
 /** @internal */
 export function createAssertPascal(): never {
@@ -706,7 +712,10 @@ export function createAssertSnake(
  */
 export function createAssertSnake<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => SnakeCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => SnakeCase<T>;
 
 /** @internal */
 export function createAssertSnake(): never {
@@ -794,7 +803,10 @@ export function createAssertKebab(
  */
 export function createAssertKebab<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => KebabCase<T>;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => KebabCase<T>;
 
 /** @internal */
 export function createAssertKebab(): never {

package/src/plain.ts

@@ -383,7 +383,10 @@ export function createAssertClone(
  */
 export function createAssertClone<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => Resolved<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
 export function createAssertClone(): never {
@@ -471,7 +474,10 @@ export function createAssertPrune(
  */
 export function createAssertPrune<T extends object>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => T;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => T;
 
 /** @internal */
 export function createAssertPrune(): never {
@@ -563,7 +569,10 @@ export function createAssertClassify(
  */
 export function createAssertClassify<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: unknown) => ClassifyResult<T>;
+): (
+  input: unknown,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => ClassifyResult<T>;
 
 /** @internal */
 export function createAssertClassify(): never {

package/src/protobuf.ts

@@ -377,10 +377,16 @@ export function createAssertDecode(
  */
 export function createAssertDecode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: Uint8Array) => Resolved<T>;
+): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T>;
 
 /** @internal */
-export function createAssertDecode<T>(): (input: Uint8Array) => Resolved<T> {
+export function createAssertDecode<T>(): (
+  input: Uint8Array,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Resolved<T> {
   NoTransformConfigurationError("protobuf.createAssertDecode");
 }
 
@@ -467,10 +473,16 @@ export function createAssertEncode(
  */
 export function createAssertEncode<T>(
   errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
-): (input: T) => Uint8Array;
+): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array;
 
 /** @internal */
-export function createAssertEncode<T>(): (input: T) => Uint8Array {
+export function createAssertEncode<T>(): (
+  input: T,
+  errorFactory?: undefined | ((props: TypeGuardError.IProps) => Error),
+) => Uint8Array {
   NoTransformConfigurationError("protobuf.createAssertEncode");
 }
 

package/native/adapter/visit.go

@@ -1,173 +0,0 @@
-package adapter
-
-import (
-  "path/filepath"
-  "strings"
-
-  shimast "github.com/microsoft/typescript-go/shim/ast"
-  shimchecker "github.com/microsoft/typescript-go/shim/checker"
-)
-
-type CallSite struct {
-  File       *shimast.SourceFile
-  FilePath   string
-  Module     string
-  Method     string
-  Call       *shimast.CallExpression
-  RootName   string
-  Namespaces []string
-}
-
-func CollectCallSites(files []*shimast.SourceFile, checker *shimchecker.Checker) []CallSite {
-  sites := []CallSite{}
-  for _, file := range files {
-    if file == nil || file.IsDeclarationFile {
-      continue
-    }
-    file.ForEachChild(func(node *shimast.Node) bool {
-      visitCallSite(file, checker, node, &sites)
-      return false
-    })
-  }
-  return sites
-}
-
-func visitCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node, sites *[]CallSite) {
-  if node == nil {
-    return
-  }
-  if node.Kind == shimast.KindCallExpression {
-    if site, ok := tryCallSite(file, checker, node); ok {
-      *sites = append(*sites, site)
-    }
-  }
-  node.ForEachChild(func(child *shimast.Node) bool {
-    visitCallSite(file, checker, child, sites)
-    return false
-  })
-}
-
-func tryCallSite(file *shimast.SourceFile, checker *shimchecker.Checker, node *shimast.Node) (CallSite, bool) {
-  if checker == nil {
-    return CallSite{}, false
-  }
-  if node.Kind != shimast.KindCallExpression {
-    return CallSite{}, false
-  }
-  call := node.AsCallExpression()
-  if call == nil {
-    return CallSite{}, false
-  }
-  signature := checker.GetResolvedSignature(node)
-  if signature == nil {
-    return CallSite{}, false
-  }
-  declaration := signature.Declaration()
-  if declaration == nil {
-    return CallSite{}, false
-  }
-  sourceFile := shimast.GetSourceFileOfNode(declaration)
-  if sourceFile == nil {
-    return CallSite{}, false
-  }
-  module, ok := matchTypiaModule(sourceFile.FileName())
-  if !ok {
-    return CallSite{}, false
-  }
-  method := callSiteMethodName(checker, declaration, call)
-  if method == "" {
-    return CallSite{}, false
-  }
-  root, namespaces, ok := extractRootAndNamespaces(call, method)
-  if !ok {
-    return CallSite{}, false
-  }
-  return CallSite{
-    File:       file,
-    FilePath:   file.FileName(),
-    Module:     module,
-    Method:     method,
-    Call:       call,
-    RootName:   root,
-    Namespaces: namespaces,
-  }, true
-}
-
-func matchTypiaModule(location string) (string, bool) {
-  location = filepath.ToSlash(location)
-  for _, suffix := range []string{".d.ts", ".ts"} {
-    for _, middle := range []string{"typia/lib/", "typia/src/", "packages/typia/src/"} {
-      index := strings.LastIndex(location, middle)
-      if index < 0 {
-        continue
-      }
-      name := location[index+len(middle):]
-      if !strings.HasSuffix(name, suffix) {
-        continue
-      }
-      name = strings.TrimSuffix(name, suffix)
-      if strings.Contains(name, "/") {
-        continue
-      }
-      return name, true
-    }
-  }
-  return "", false
-}
-
-func callSiteMethodName(checker *shimchecker.Checker, declaration *shimast.Node, call *shimast.CallExpression) string {
-  if name := declaration.Name(); name != nil {
-    if checker != nil {
-      if symbol := checker.GetSymbolAtLocation(name); symbol != nil && symbol.Name != "" {
-        return symbol.Name
-      }
-    }
-    if name.Kind == shimast.KindIdentifier {
-      if id := name.AsIdentifier(); id != nil {
-        return id.Text
-      }
-    }
-  }
-  if call.Expression != nil && call.Expression.Kind == shimast.KindPropertyAccessExpression {
-    if property := call.Expression.AsPropertyAccessExpression(); property != nil {
-      if name := property.Name(); name != nil && name.Kind == shimast.KindIdentifier {
-        if id := name.AsIdentifier(); id != nil {
-          return id.Text
-        }
-      }
-    }
-  }
-  return ""
-}
-
-func extractRootAndNamespaces(call *shimast.CallExpression, method string) (string, []string, bool) {
-  expression := call.Expression
-  segments := []string{}
-  for expression != nil && expression.Kind == shimast.KindPropertyAccessExpression {
-    property := expression.AsPropertyAccessExpression()
-    if property == nil {
-      break
-    }
-    name := property.Name()
-    if name == nil || name.Kind != shimast.KindIdentifier {
-      return "", nil, false
-    }
-    id := name.AsIdentifier()
-    if id == nil || id.Text == "" {
-      return "", nil, false
-    }
-    segments = append([]string{id.Text}, segments...)
-    expression = property.Expression
-  }
-  if expression == nil || expression.Kind != shimast.KindIdentifier {
-    return "", nil, false
-  }
-  root := expression.AsIdentifier()
-  if root == nil || root.Text == "" || len(segments) == 0 {
-    return "", nil, false
-  }
-  if segments[len(segments)-1] != method {
-    return "", nil, false
-  }
-  return root.Text, segments[:len(segments)-1], true
-}

package/native/adapter/visit_property_chain_edges_test.go

@@ -1,129 +0,0 @@
-//go:build typia_native_internal
-// +build typia_native_internal
-
-package adapter
-
-import (
-	"path/filepath"
-	"testing"
-
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimchecker "github.com/microsoft/typescript-go/shim/checker"
-	shimcore "github.com/microsoft/typescript-go/shim/core"
-	shimparser "github.com/microsoft/typescript-go/shim/parser"
-)
-
-// TestVisitPropertyChainEdges verifies call-site property-chain parsing.
-//
-// Call-site discovery peels a TypeScript expression like
-// `typia.json.stringify()` into a root import name, namespace chain, and method.
-// Malformed or mismatched chains must be rejected without producing a site.
-//
-// 1. Build a nested property-access call expression.
-// 2. Extract the root name, namespace, and terminal method.
-// 3. Reject a method mismatch, a non-property call, and an empty member name.
-// 4. Verify nil nodes do not append call sites.
-func TestVisitPropertyChainEdges(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	namespace := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier("json"),
-		shimast.NodeFlagsNone,
-	)
-	method := factory.NewPropertyAccessExpression(
-		namespace,
-		nil,
-		factory.NewIdentifier("stringify"),
-		shimast.NodeFlagsNone,
-	)
-	call := factory.NewCallExpression(method, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-
-	root, namespaces, ok := extractRootAndNamespaces(call, "stringify")
-	if !ok || root != "typia" || len(namespaces) != 1 || namespaces[0] != "json" {
-		t.Fatalf("unexpected property-chain extraction: root=%q namespaces=%#v ok=%v", root, namespaces, ok)
-	}
-	if _, _, ok := extractRootAndNamespaces(call, "is"); ok {
-		t.Fatal("method mismatch should reject the call chain")
-	}
-	statement := factory.NewExpressionStatement(factory.NewIdentifier("noop"))
-	if method := callSiteMethodName(nil, statement, call); method != "stringify" {
-		t.Fatalf("property-access method fallback mismatch: %q", method)
-	}
-	declaration := factory.NewFunctionDeclaration(
-		nil,
-		nil,
-		factory.NewIdentifier("declared"),
-		nil,
-		nil,
-		nil,
-		nil,
-		nil,
-	)
-	if method := callSiteMethodName(nil, declaration, call); method != "declared" {
-		t.Fatalf("declaration-name fallback mismatch: %q", method)
-	}
-
-	plain := factory.NewCallExpression(
-		factory.NewIdentifier("plain"),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(plain, "plain"); ok {
-		t.Fatal("plain calls without a property chain should be rejected")
-	}
-	literal := factory.NewCallExpression(
-		factory.NewStringLiteral("call", shimast.TokenFlagsNone),
-		nil,
-		nil,
-		factory.NewNodeList(nil),
-		shimast.NodeFlagsNone,
-	).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(literal, "call"); ok {
-		t.Fatal("non-identifier root expressions should be rejected")
-	}
-
-	emptyMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewIdentifier(""),
-		shimast.NodeFlagsNone,
-	)
-	emptyCall := factory.NewCallExpression(emptyMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(emptyCall, ""); ok {
-		t.Fatal("empty property name should be rejected")
-	}
-	stringMember := factory.NewPropertyAccessExpression(
-		factory.NewIdentifier("typia"),
-		nil,
-		factory.NewStringLiteral("is", shimast.TokenFlagsNone),
-		shimast.NodeFlagsNone,
-	)
-	stringMemberCall := factory.NewCallExpression(stringMember, nil, nil, factory.NewNodeList(nil), shimast.NodeFlagsNone).AsCallExpression()
-	if _, _, ok := extractRootAndNamespaces(stringMemberCall, "is"); ok {
-		t.Fatal("non-identifier property names should be rejected")
-	}
-	sites := []CallSite{}
-	visitCallSite(nil, nil, nil, &sites)
-	if len(sites) != 0 {
-		t.Fatalf("nil node should not append call sites: %#v", sites)
-	}
-	file := shimparser.ParseSourceFile(
-		shimast.SourceFileParseOptions{FileName: filepath.ToSlash(filepath.Join(t.TempDir(), "visit.ts"))},
-		`typia.is(input);`,
-		shimcore.ScriptKindTS,
-	)
-	declFile := *file
-	declFile.IsDeclarationFile = true
-	if sites := CollectCallSites([]*shimast.SourceFile{nil, &declFile}, nil); len(sites) != 0 {
-		t.Fatalf("nil and declaration files should not produce call sites: %#v", sites)
-	}
-	if _, ok := tryCallSite(file, nil, call.AsNode()); ok {
-		t.Fatal("nil checker should reject call-site probing")
-	}
-	if _, ok := tryCallSite(file, &shimchecker.Checker{}, statement); ok {
-		t.Fatal("non-call nodes should reject call-site probing")
-	}
-}

package/native/core/programmers/helpers/disable_function_programmer_declare.go

@@ -1,10 +0,0 @@
-package helpers
-
-func Disable_function_programmer_declare(functor *FunctionProgrammer) *FunctionProgrammer {
-  if functor == nil {
-    return nil
-  }
-  disabled := *functor
-  disabled.disableDeclare = true
-  return &disabled
-}