npm - @nestia/core - Versions diffs - 2.4.3 → 3.0.0-dev.20231209 - Mend

@nestia/core 2.4.3 → 3.0.0-dev.20231209

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/lib/decorators/EncryptedBody.js +13 -11
package/lib/decorators/EncryptedBody.js.map +1 -1
package/lib/decorators/EncryptedRoute.js +29 -12
package/lib/decorators/EncryptedRoute.js.map +1 -1
package/lib/decorators/internal/get_binary_body.d.ts +1 -0
package/lib/decorators/internal/get_binary_body.js +66 -0
package/lib/decorators/internal/get_binary_body.js.map +1 -0
package/package.json +3 -3
package/src/decorators/DynamicModule.ts +39 -39
package/src/decorators/EncryptedBody.ts +17 -12
package/src/decorators/EncryptedController.ts +38 -38
package/src/decorators/EncryptedModule.ts +79 -79
package/src/decorators/EncryptedRoute.ts +38 -14
package/src/decorators/PlainBody.ts +72 -72
package/src/decorators/TypedBody.ts +59 -59
package/src/decorators/TypedException.ts +89 -89
package/src/decorators/TypedHeaders.ts +69 -69
package/src/decorators/TypedParam.ts +65 -65
package/src/decorators/TypedQuery.ts +246 -246
package/src/decorators/TypedRoute.ts +144 -144
package/src/decorators/internal/EncryptedConstant.ts +4 -4
package/src/decorators/internal/NoTransformConfigureError.ts +8 -8
package/src/decorators/internal/get_binary_body.ts +18 -0
package/src/decorators/internal/get_path_and_querify.ts +103 -103
package/src/decorators/internal/get_path_and_stringify.ts +91 -91
package/src/decorators/internal/get_text_body.ts +20 -20
package/src/decorators/internal/headers_to_object.ts +13 -13
package/src/decorators/internal/load_controller.ts +51 -51
package/src/decorators/internal/route_error.ts +45 -45
package/src/decorators/internal/validate_request_body.ts +57 -57
package/src/decorators/internal/validate_request_headers.ts +68 -68
package/src/decorators/internal/validate_request_query.ts +56 -56
package/src/index.ts +5 -5
package/src/module.ts +14 -14
package/src/options/INestiaTransformOptions.ts +17 -17
package/src/options/INestiaTransformProject.ts +7 -7
package/src/options/IRequestBodyValidator.ts +20 -20
package/src/options/IRequestHeadersValidator.ts +22 -22
package/src/options/IRequestQueryValidator.ts +20 -20
package/src/options/IResponseBodyQuerifier.ts +25 -25
package/src/options/IResponseBodyStringifier.ts +25 -25
package/src/programmers/PlainBodyProgrammer.ts +52 -52
package/src/programmers/TypedBodyProgrammer.ts +108 -108
package/src/programmers/TypedExceptionProgrammer.ts +72 -72
package/src/programmers/TypedHeadersProgrammer.ts +56 -56
package/src/programmers/TypedParamProgrammer.ts +24 -24
package/src/programmers/TypedQueryBodyProgrammer.ts +56 -56
package/src/programmers/TypedQueryProgrammer.ts +56 -56
package/src/programmers/TypedQueryRouteProgrammer.ts +51 -51
package/src/programmers/TypedRouteProgrammer.ts +51 -51
package/src/programmers/http/HttpAssertQuerifyProgrammer.ts +58 -58
package/src/programmers/http/HttpIsQuerifyProgrammer.ts +62 -62
package/src/programmers/http/HttpQuerifyProgrammer.ts +96 -96
package/src/programmers/http/HttpValidateQuerifyProgrammer.ts +63 -63
package/src/programmers/internal/CoreMetadataUtil.ts +21 -21
package/src/transform.ts +35 -35
package/src/transformers/FileTransformer.ts +66 -66
package/src/transformers/MethodTransformer.ts +94 -94
package/src/transformers/NodeTransformer.ts +16 -16
package/src/transformers/ParameterDecoratorTransformer.ts +121 -121
package/src/transformers/ParameterTransformer.ts +48 -48
package/src/transformers/TypedExceptionTransformer.ts +49 -49
package/src/transformers/TypedRouteTransformer.ts +95 -95
package/src/typings/Creator.ts +3 -3
package/src/utils/ExceptionManager.ts +112 -112
package/src/utils/Singleton.ts +20 -20
package/src/utils/SourceFinder.ts +57 -57

package/src/programmers/TypedQueryBodyProgrammer.ts CHANGED Viewed

@@ -1,56 +1,56 @@
-import ts from "typescript";
-import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
-import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
-import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
-export namespace TypedQueryBodyProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.ObjectLiteralExpression => {
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestQueryValidator<any>["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (type: ts.Type) => ts.ArrowFunction,
-        ) =>
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("type"),
-              ts.factory.createStringLiteral(key),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier(key),
-              programmer({
-                ...project,
-                options: {
-                  numeric: false,
-                  finite: false,
-                  functional: false,
-                },
-              })(modulo)(type),
-            ),
-          ]);
-      // RETURNS
-      const category = project.options.validate;
-      if (category === "is" || category === "equals")
-        return parameter("is")(HttpIsQueryProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateQueryProgrammer.write);
-      return parameter("assert")(HttpAssertQueryProgrammer.write);
-    };
-}
+import ts from "typescript";
+import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
+import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
+import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
+export namespace TypedQueryBodyProgrammer {
+  export const generate =
+    (project: INestiaTransformProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.ObjectLiteralExpression => {
+      // GENERATE VALIDATION PLAN
+      const parameter =
+        (key: IRequestQueryValidator<any>["type"]) =>
+        (
+          programmer: (
+            project: IProject,
+          ) => (
+            modulo: ts.LeftHandSideExpression,
+          ) => (type: ts.Type) => ts.ArrowFunction,
+        ) =>
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("type"),
+              ts.factory.createStringLiteral(key),
+            ),
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier(key),
+              programmer({
+                ...project,
+                options: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              })(modulo)(type),
+            ),
+          ]);
+      // RETURNS
+      const category = project.options.validate;
+      if (category === "is" || category === "equals")
+        return parameter("is")(HttpIsQueryProgrammer.write);
+      else if (
+        category === "validate" ||
+        category === "validateEquals" ||
+        category === "validateClone" ||
+        category === "validatePrune"
+      )
+        return parameter("validate")(HttpValidateQueryProgrammer.write);
+      return parameter("assert")(HttpAssertQueryProgrammer.write);
+    };
+}

package/src/programmers/TypedQueryProgrammer.ts CHANGED Viewed

@@ -1,56 +1,56 @@
-import ts from "typescript";
-import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
-import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
-import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
-export namespace TypedQueryProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE VALIDATION PLAN
-      const parameter =
-        (key: IRequestQueryValidator<any>["type"]) =>
-        (
-          programmer: (
-            project: IProject,
-          ) => (
-            modulo: ts.LeftHandSideExpression,
-          ) => (type: ts.Type) => ts.ArrowFunction,
-        ) =>
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier("type"),
-              ts.factory.createStringLiteral(key),
-            ),
-            ts.factory.createPropertyAssignment(
-              ts.factory.createIdentifier(key),
-              programmer({
-                ...project,
-                options: {
-                  numeric: false,
-                  finite: false,
-                  functional: false,
-                },
-              })(modulo)(type),
-            ),
-          ]);
-      // RETURNS
-      const category = project.options.validate;
-      if (category === "is" || category === "equals")
-        return parameter("is")(HttpIsQueryProgrammer.write);
-      else if (
-        category === "validate" ||
-        category === "validateEquals" ||
-        category === "validateClone" ||
-        category === "validatePrune"
-      )
-        return parameter("validate")(HttpValidateQueryProgrammer.write);
-      return parameter("assert")(HttpAssertQueryProgrammer.write);
-    };
-}
+import ts from "typescript";
+import { HttpAssertQueryProgrammer } from "typia/lib/programmers/http/HttpAssertQueryProgrammer";
+import { HttpIsQueryProgrammer } from "typia/lib/programmers/http/HttpIsQueryProgrammer";
+import { HttpValidateQueryProgrammer } from "typia/lib/programmers/http/HttpValidateQueryProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { IRequestQueryValidator } from "../options/IRequestQueryValidator";
+export namespace TypedQueryProgrammer {
+  export const generate =
+    (project: INestiaTransformProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.Expression => {
+      // GENERATE VALIDATION PLAN
+      const parameter =
+        (key: IRequestQueryValidator<any>["type"]) =>
+        (
+          programmer: (
+            project: IProject,
+          ) => (
+            modulo: ts.LeftHandSideExpression,
+          ) => (type: ts.Type) => ts.ArrowFunction,
+        ) =>
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier("type"),
+              ts.factory.createStringLiteral(key),
+            ),
+            ts.factory.createPropertyAssignment(
+              ts.factory.createIdentifier(key),
+              programmer({
+                ...project,
+                options: {
+                  numeric: false,
+                  finite: false,
+                  functional: false,
+                },
+              })(modulo)(type),
+            ),
+          ]);
+      // RETURNS
+      const category = project.options.validate;
+      if (category === "is" || category === "equals")
+        return parameter("is")(HttpIsQueryProgrammer.write);
+      else if (
+        category === "validate" ||
+        category === "validateEquals" ||
+        category === "validateClone" ||
+        category === "validatePrune"
+      )
+        return parameter("validate")(HttpValidateQueryProgrammer.write);
+      return parameter("assert")(HttpAssertQueryProgrammer.write);
+    };
+}

package/src/programmers/TypedQueryRouteProgrammer.ts CHANGED Viewed

@@ -1,51 +1,51 @@
-import ts from "typescript";
-import { IProject } from "typia/lib/transformers/IProject";
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
-import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
-import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
-import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
-export namespace TypedQueryRouteProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE STRINGIFY PLAN
-      const parameter = (
-        key: string,
-        programmer: (
-          project: IProject,
-        ) => (
-          modulo: ts.LeftHandSideExpression,
-        ) => (type: ts.Type) => ts.ArrowFunction,
-      ) =>
-        ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier("type"),
-            ts.factory.createStringLiteral(key),
-          ),
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier(key),
-            programmer({
-              ...project,
-              options: {}, // use default option
-            })(modulo)(type),
-          ),
-        ]);
-      // RETURNS
-      if (project.options.stringify === "is")
-        return parameter("is", HttpIsQuerifyProgrammer.write);
-      else if (project.options.stringify === "validate")
-        return parameter("validate", HttpValidateQuerifyProgrammer.write);
-      else if (project.options.stringify === "stringify")
-        return parameter("stringify", HttpQuerifyProgrammer.write);
-      else if (project.options.stringify === null)
-        return ts.factory.createNull();
-      // ASSERT IS DEFAULT
-      return parameter("assert", HttpAssertQuerifyProgrammer.write);
-    };
-}
+import ts from "typescript";
+import { IProject } from "typia/lib/transformers/IProject";
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { HttpAssertQuerifyProgrammer } from "./http/HttpAssertQuerifyProgrammer";
+import { HttpIsQuerifyProgrammer } from "./http/HttpIsQuerifyProgrammer";
+import { HttpQuerifyProgrammer } from "./http/HttpQuerifyProgrammer";
+import { HttpValidateQuerifyProgrammer } from "./http/HttpValidateQuerifyProgrammer";
+export namespace TypedQueryRouteProgrammer {
+  export const generate =
+    (project: INestiaTransformProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.Expression => {
+      // GENERATE STRINGIFY PLAN
+      const parameter = (
+        key: string,
+        programmer: (
+          project: IProject,
+        ) => (
+          modulo: ts.LeftHandSideExpression,
+        ) => (type: ts.Type) => ts.ArrowFunction,
+      ) =>
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier("type"),
+            ts.factory.createStringLiteral(key),
+          ),
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier(key),
+            programmer({
+              ...project,
+              options: {}, // use default option
+            })(modulo)(type),
+          ),
+        ]);
+      // RETURNS
+      if (project.options.stringify === "is")
+        return parameter("is", HttpIsQuerifyProgrammer.write);
+      else if (project.options.stringify === "validate")
+        return parameter("validate", HttpValidateQuerifyProgrammer.write);
+      else if (project.options.stringify === "stringify")
+        return parameter("stringify", HttpQuerifyProgrammer.write);
+      else if (project.options.stringify === null)
+        return ts.factory.createNull();
+      // ASSERT IS DEFAULT
+      return parameter("assert", HttpAssertQuerifyProgrammer.write);
+    };
+}

package/src/programmers/TypedRouteProgrammer.ts CHANGED Viewed

@@ -1,51 +1,51 @@
-import ts from "typescript";
-import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
-import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
-import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
-import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-export namespace TypedRouteProgrammer {
-  export const generate =
-    (project: INestiaTransformProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type): ts.Expression => {
-      // GENERATE STRINGIFY PLAN
-      const parameter = (
-        key: string,
-        programmer: (
-          project: IProject,
-        ) => (
-          modulo: ts.LeftHandSideExpression,
-        ) => (type: ts.Type) => ts.ArrowFunction,
-      ) =>
-        ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier("type"),
-            ts.factory.createStringLiteral(key),
-          ),
-          ts.factory.createPropertyAssignment(
-            ts.factory.createIdentifier(key),
-            programmer({
-              ...project,
-              options: {}, // use default option
-            })(modulo)(type),
-          ),
-        ]);
-      // RETURNS
-      if (project.options.stringify === "is")
-        return parameter("is", JsonIsStringifyProgrammer.write);
-      else if (project.options.stringify === "validate")
-        return parameter("validate", JsonValidateStringifyProgrammer.write);
-      else if (project.options.stringify === "stringify")
-        return parameter("stringify", JsonStringifyProgrammer.write);
-      else if (project.options.stringify === null)
-        return ts.factory.createNull();
-      // ASSERT IS DEFAULT
-      return parameter("assert", JsonAssertStringifyProgrammer.write);
-    };
-}
+import ts from "typescript";
+import { JsonAssertStringifyProgrammer } from "typia/lib/programmers/json/JsonAssertStringifyProgrammer";
+import { JsonIsStringifyProgrammer } from "typia/lib/programmers/json/JsonIsStringifyProgrammer";
+import { JsonStringifyProgrammer } from "typia/lib/programmers/json/JsonStringifyProgrammer";
+import { JsonValidateStringifyProgrammer } from "typia/lib/programmers/json/JsonValidateStringifyProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+export namespace TypedRouteProgrammer {
+  export const generate =
+    (project: INestiaTransformProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type): ts.Expression => {
+      // GENERATE STRINGIFY PLAN
+      const parameter = (
+        key: string,
+        programmer: (
+          project: IProject,
+        ) => (
+          modulo: ts.LeftHandSideExpression,
+        ) => (type: ts.Type) => ts.ArrowFunction,
+      ) =>
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier("type"),
+            ts.factory.createStringLiteral(key),
+          ),
+          ts.factory.createPropertyAssignment(
+            ts.factory.createIdentifier(key),
+            programmer({
+              ...project,
+              options: {}, // use default option
+            })(modulo)(type),
+          ),
+        ]);
+      // RETURNS
+      if (project.options.stringify === "is")
+        return parameter("is", JsonIsStringifyProgrammer.write);
+      else if (project.options.stringify === "validate")
+        return parameter("validate", JsonValidateStringifyProgrammer.write);
+      else if (project.options.stringify === "stringify")
+        return parameter("stringify", JsonStringifyProgrammer.write);
+      else if (project.options.stringify === null)
+        return ts.factory.createNull();
+      // ASSERT IS DEFAULT
+      return parameter("assert", JsonAssertStringifyProgrammer.write);
+    };
+}

package/src/programmers/http/HttpAssertQuerifyProgrammer.ts CHANGED Viewed

@@ -1,58 +1,58 @@
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
-export namespace HttpAssertQuerifyProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.ArrowFunction =>
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input")],
-        undefined,
-        undefined,
-        ts.factory.createBlock([
-          StatementFactory.constant(
-            "assert",
-            AssertProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(false)(type, name),
-          ),
-          StatementFactory.constant(
-            "stringify",
-            HttpQuerifyProgrammer.write({
-              ...project,
-              options: {
-                ...project.options,
-                functional: false,
-                numeric: false,
-              },
-            })(modulo)(type),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("stringify"),
-              undefined,
-              [
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("assert"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-              ],
-            ),
-          ),
-        ]),
-      );
-}
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+import { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+import { HttpQuerifyProgrammer } from "./HttpQuerifyProgrammer";
+export namespace HttpAssertQuerifyProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (type: ts.Type, name?: string): ts.ArrowFunction =>
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input")],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "assert",
+            AssertProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(false)(type, name),
+          ),
+          StatementFactory.constant(
+            "stringify",
+            HttpQuerifyProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(modulo)(type),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("stringify"),
+              undefined,
+              [
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("assert"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+              ],
+            ),
+          ),
+        ]),
+      );
+}