@ttsc/factory 0.15.8 → 0.15.9

package/lib/factory/types/createConditionalTypeNode.mjs

@@ -1,28 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConditionalTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional
- * type.
- *
- * The four type arms print in order, joined by `extends`, `?`, and `:`. The
- * printer emits each arm as-is without adding parentheses, so the caller is
- * responsible for wrapping any arm that needs grouping.
- *
- * Given check `T`, extends `U`, true `string`, and false `number`, the printer
- * renders:
- *
- * ```ts
- * T extends U ? string : number
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param checkType The type being tested.
- * @param extendsType The type tested against.
- * @param trueType The branch type when the test passes.
- * @param falseType The branch type when the test fails.
- * @returns The created {@link ConditionalTypeNode}.
- */
-const createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => (0, make_1.make)("ConditionalTypeNode", { checkType, extendsType, trueType, falseType });
-exports.createConditionalTypeNode = createConditionalTypeNode;
-//# sourceMappingURL=createConditionalTypeNode.mjs.map

package/lib/factory/types/createConditionalTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createConditionalTypeNode.mjs","sources":["createConditionalTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConditionalTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConditionalTypeNode}: a `C extends E ? X : Y` conditional\n * type.\n *\n * The four type arms print in order, joined by `extends`, `?`, and `:`. The\n * printer emits each arm as-is without adding parentheses, so the caller is\n * responsible for wrapping any arm that needs grouping.\n *\n * Given check `T`, extends `U`, true `string`, and false `number`, the printer\n * renders:\n *\n * ```ts\n * T extends U ? string : number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param checkType The type being tested.\n * @param extendsType The type tested against.\n * @param trueType The branch type when the test passes.\n * @param falseType The branch type when the test fails.\n * @returns The created {@link ConditionalTypeNode}.\n */\nconst createConditionalTypeNode = (checkType, extendsType, trueType, falseType) => (0, make_1.make)(\"ConditionalTypeNode\", { checkType, extendsType, trueType, falseType });\nexports.createConditionalTypeNode = createConditionalTypeNode;\n//# sourceMappingURL=createConditionalTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;AAC3K,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}

package/lib/factory/types/createConstructSignature.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConstructSignature = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ConstructSignature}: a `new (params): T` construct signature
- * for an interface or type literal.
- *
- * The `new ` keyword prints first, then optional type parameters as `<...>`,
- * the parameter list, and the return type as `: Type` when present.
- *
- * Given one `x: number` parameter and a `Foo` return type, the printer renders:
- *
- * ```ts
- * new (x: number): Foo
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param typeParameters The generic type parameters, if any.
- * @param parameters The parameters.
- * @param type The return type, if any.
- * @returns The created {@link ConstructSignature}.
- */
-const createConstructSignature = (typeParameters, parameters, type) => (0, make_1.make)("ConstructSignature", { typeParameters, parameters, type });
-exports.createConstructSignature = createConstructSignature;
-//# sourceMappingURL=createConstructSignature.mjs.map

package/lib/factory/types/createConstructSignature.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createConstructSignature.mjs","sources":["createConstructSignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConstructSignature = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConstructSignature}: a `new (params): T` construct signature\n * for an interface or type literal.\n *\n * The `new ` keyword prints first, then optional type parameters as `<...>`,\n * the parameter list, and the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `Foo` return type, the printer renders:\n *\n * ```ts\n * new (x: number): Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link ConstructSignature}.\n */\nconst createConstructSignature = (typeParameters, parameters, type) => (0, make_1.make)(\"ConstructSignature\", { typeParameters, parameters, type });\nexports.createConstructSignature = createConstructSignature;\n//# sourceMappingURL=createConstructSignature.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,wBAAwB,GAAG,MAAM;AACzC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,wBAAwB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACnJ,OAAO,CAAC,wBAAwB,GAAG,wBAAwB"}

package/lib/factory/types/createConstructorTypeNode.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createConstructorTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.
- *
- * Any modifiers print first (for example `abstract`), then the `new ` keyword,
- * then optional type parameters as `<...>`, the parameter list, and finally
- * `=>` followed by the return type.
- *
- * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the
- * printer renders:
- *
- * ```ts
- * new (x: number) => Foo
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The leading modifiers, if any.
- * @param typeParameters The generic type parameters, if any.
- * @param parameters The parameters.
- * @param type The return type.
- * @returns The created {@link ConstructorTypeNode}.
- */
-const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => (0, make_1.make)("ConstructorTypeNode", { modifiers, typeParameters, parameters, type });
-exports.createConstructorTypeNode = createConstructorTypeNode;
-//# sourceMappingURL=createConstructorTypeNode.mjs.map

package/lib/factory/types/createConstructorTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createConstructorTypeNode.mjs","sources":["createConstructorTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createConstructorTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.\n *\n * Any modifiers print first (for example `abstract`), then the `new ` keyword,\n * then optional type parameters as `<...>`, the parameter list, and finally\n * `=>` followed by the return type.\n *\n * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the\n * printer renders:\n *\n * ```ts\n * new (x: number) => Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link ConstructorTypeNode}.\n */\nconst createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => (0, make_1.make)(\"ConstructorTypeNode\", { modifiers, typeParameters, parameters, type });\nexports.createConstructorTypeNode = createConstructorTypeNode;\n//# sourceMappingURL=createConstructorTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,yBAAyB,GAAG,MAAM;AAC1C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,yBAAyB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC3K,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}

package/lib/factory/types/createExpressionWithTypeArguments.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createExpressionWithTypeArguments = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used
- * in heritage clauses such as `extends Base<T>`.
- *
- * The expression prints first, followed by the type arguments as `<...>` when
- * present. With no type arguments only the bare expression prints.
- *
- * Given a `Foo` expression and a single `string` type argument, the printer
- * renders:
- *
- * ```ts
- * Foo<string>;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param expression The base expression.
- * @param typeArguments The generic type arguments, if any.
- * @returns The created {@link ExpressionWithTypeArguments}.
- */
-const createExpressionWithTypeArguments = (expression, typeArguments) => (0, make_1.make)("ExpressionWithTypeArguments", { expression, typeArguments });
-exports.createExpressionWithTypeArguments = createExpressionWithTypeArguments;
-//# sourceMappingURL=createExpressionWithTypeArguments.mjs.map

package/lib/factory/types/createExpressionWithTypeArguments.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["createExpressionWithTypeArguments.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createExpressionWithTypeArguments = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used\n * in heritage clauses such as `extends Base<T>`.\n *\n * The expression prints first, followed by the type arguments as `<...>` when\n * present. With no type arguments only the bare expression prints.\n *\n * Given a `Foo` expression and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Foo<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The base expression.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link ExpressionWithTypeArguments}.\n */\nconst createExpressionWithTypeArguments = (expression, typeArguments) => (0, make_1.make)(\"ExpressionWithTypeArguments\", { expression, typeArguments });\nexports.createExpressionWithTypeArguments = createExpressionWithTypeArguments;\n//# sourceMappingURL=createExpressionWithTypeArguments.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,iCAAiC,GAAG,MAAM;AAClD,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,iCAAiC,GAAG,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;AACvJ,OAAO,CAAC,iCAAiC,GAAG,iCAAiC"}

package/lib/factory/types/createFunctionTypeNode.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFunctionTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link FunctionTypeNode}: a `(params) => T` function type.
- *
- * Optional type parameters print first as `<...>`, then the parameter list,
- * then `=>` followed by the return type. In postfix and array positions the
- * surrounding printer wraps a function type in parentheses, since `() => T[]`
- * would otherwise read as an array of the return type.
- *
- * Given one `x: number` parameter and a `string` return type, the printer
- * renders:
- *
- * ```ts
- * (x: number) => string;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param typeParameters The generic type parameters, if any.
- * @param parameters The parameters.
- * @param type The return type.
- * @returns The created {@link FunctionTypeNode}.
- */
-const createFunctionTypeNode = (typeParameters, parameters, type) => (0, make_1.make)("FunctionTypeNode", { typeParameters, parameters, type });
-exports.createFunctionTypeNode = createFunctionTypeNode;
-//# sourceMappingURL=createFunctionTypeNode.mjs.map

package/lib/factory/types/createFunctionTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFunctionTypeNode.mjs","sources":["createFunctionTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createFunctionTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link FunctionTypeNode}: a `(params) => T` function type.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then `=>` followed by the return type. In postfix and array positions the\n * surrounding printer wraps a function type in parentheses, since `() => T[]`\n * would otherwise read as an array of the return type.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number) => string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link FunctionTypeNode}.\n */\nconst createFunctionTypeNode = (typeParameters, parameters, type) => (0, make_1.make)(\"FunctionTypeNode\", { typeParameters, parameters, type });\nexports.createFunctionTypeNode = createFunctionTypeNode;\n//# sourceMappingURL=createFunctionTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AAC/I,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/types/createImportTypeNode.mjs

@@ -1,27 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link ImportTypeNode}: an `import("module").Qualifier<Args>` type.
- *
- * The `argument` is the module specifier inside `import(...)`. A `qualifier`
- * adds a `.Member` access, and type arguments add `<...>`. When `isTypeOf` is
- * true the whole thing is prefixed with `typeof ` to query a value's type.
- *
- * Given the module `"foo"`, qualifier `Bar`, and a single `string` type
- * argument, the printer renders:
- *
- * ```ts
- * import("foo").Bar<string>;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param argument The module specifier inside `import(...)`.
- * @param qualifier The `.Member` access on the import, if any.
- * @param typeArguments The generic type arguments, if any.
- * @param isTypeOf Whether to prefix the type with `typeof`.
- * @returns The created {@link ImportTypeNode}.
- */
-const createImportTypeNode = (argument, qualifier, typeArguments, isTypeOf = false) => (0, make_1.make)("ImportTypeNode", { argument, qualifier, typeArguments, isTypeOf });
-exports.createImportTypeNode = createImportTypeNode;
-//# sourceMappingURL=createImportTypeNode.mjs.map

package/lib/factory/types/createImportTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createImportTypeNode.mjs","sources":["createImportTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createImportTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link ImportTypeNode}: an `import(\"module\").Qualifier<Args>` type.\n *\n * The `argument` is the module specifier inside `import(...)`. A `qualifier`\n * adds a `.Member` access, and type arguments add `<...>`. When `isTypeOf` is\n * true the whole thing is prefixed with `typeof ` to query a value's type.\n *\n * Given the module `\"foo\"`, qualifier `Bar`, and a single `string` type\n * argument, the printer renders:\n *\n * ```ts\n * import(\"foo\").Bar<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param argument The module specifier inside `import(...)`.\n * @param qualifier The `.Member` access on the import, if any.\n * @param typeArguments The generic type arguments, if any.\n * @param isTypeOf Whether to prefix the type with `typeof`.\n * @returns The created {@link ImportTypeNode}.\n */\nconst createImportTypeNode = (argument, qualifier, typeArguments, isTypeOf = false) => (0, make_1.make)(\"ImportTypeNode\", { argument, qualifier, typeArguments, isTypeOf });\nexports.createImportTypeNode = createImportTypeNode;\n//# sourceMappingURL=createImportTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,GAAG,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC;AAC3K,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/types/createIndexSignature.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIndexSignature = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link IndexSignatureDeclaration}: a `[key: K]: V` index signature.
- *
- * Any modifiers print first (for example `readonly`), then the single key
- * parameter inside `[...]`, then `: ` followed by the value type.
- *
- * Given no modifiers, a `key: string` parameter, and a `number` value type, the
- * printer renders:
- *
- * ```ts
- * [key: string]: number
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The leading modifiers and decorators, if any.
- * @param parameters The index parameter list.
- * @param type The value type.
- * @returns The created {@link IndexSignatureDeclaration}.
- */
-const createIndexSignature = (modifiers, parameters, type) => (0, make_1.make)("IndexSignature", { modifiers, parameters, type });
-exports.createIndexSignature = createIndexSignature;
-//# sourceMappingURL=createIndexSignature.mjs.map

package/lib/factory/types/createIndexSignature.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createIndexSignature.mjs","sources":["createIndexSignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createIndexSignature = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link IndexSignatureDeclaration}: a `[key: K]: V` index signature.\n *\n * Any modifiers print first (for example `readonly`), then the single key\n * parameter inside `[...]`, then `: ` followed by the value type.\n *\n * Given no modifiers, a `key: string` parameter, and a `number` value type, the\n * printer renders:\n *\n * ```ts\n * [key: string]: number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param parameters The index parameter list.\n * @param type The value type.\n * @returns The created {@link IndexSignatureDeclaration}.\n */\nconst createIndexSignature = (modifiers, parameters, type) => (0, make_1.make)(\"IndexSignature\", { modifiers, parameters, type });\nexports.createIndexSignature = createIndexSignature;\n//# sourceMappingURL=createIndexSignature.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;AACjI,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/types/createIndexedAccessTypeNode.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIndexedAccessTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link IndexedAccessTypeNode}: a `T[K]` indexed access type.
- *
- * The object type is emitted in postfix-operand position, so a lower-precedence
- * form (union, intersection, function, constructor, conditional, infer, or
- * type-operator) gets wrapped in parentheses before the `[...]`. The index type
- * prints bare inside the brackets.
- *
- * Given a `T` object type and a `"key"` index, the printer renders:
- *
- * ```ts
- * T["key"];
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param objectType The object type being indexed.
- * @param indexType The index type.
- * @returns The created {@link IndexedAccessTypeNode}.
- */
-const createIndexedAccessTypeNode = (objectType, indexType) => (0, make_1.make)("IndexedAccessTypeNode", { objectType, indexType });
-exports.createIndexedAccessTypeNode = createIndexedAccessTypeNode;
-//# sourceMappingURL=createIndexedAccessTypeNode.mjs.map

package/lib/factory/types/createIndexedAccessTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createIndexedAccessTypeNode.mjs","sources":["createIndexedAccessTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createIndexedAccessTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link IndexedAccessTypeNode}: a `T[K]` indexed access type.\n *\n * The object type is emitted in postfix-operand position, so a lower-precedence\n * form (union, intersection, function, constructor, conditional, infer, or\n * type-operator) gets wrapped in parentheses before the `[...]`. The index type\n * prints bare inside the brackets.\n *\n * Given a `T` object type and a `\"key\"` index, the printer renders:\n *\n * ```ts\n * T[\"key\"];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param objectType The object type being indexed.\n * @param indexType The index type.\n * @returns The created {@link IndexedAccessTypeNode}.\n */\nconst createIndexedAccessTypeNode = (objectType, indexType) => (0, make_1.make)(\"IndexedAccessTypeNode\", { objectType, indexType });\nexports.createIndexedAccessTypeNode = createIndexedAccessTypeNode;\n//# sourceMappingURL=createIndexedAccessTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,2BAA2B,GAAG,MAAM;AAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,2BAA2B,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,uBAAuB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC;AACnI,OAAO,CAAC,2BAA2B,GAAG,2BAA2B"}

package/lib/factory/types/createInferTypeNode.mjs

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInferTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link InferTypeNode}: an `infer R` type used inside the extends
- * clause of a conditional type.
- *
- * The `infer ` keyword prints in front of the type parameter's name. In postfix
- * and array positions the surrounding printer wraps the infer type in
- * parentheses so `infer R[]` does not read as an array.
- *
- * Given a type parameter named `R`, the printer renders:
- *
- * ```ts
- * infer R
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param typeParameter The type parameter to infer.
- * @returns The created {@link InferTypeNode}.
- */
-const createInferTypeNode = (typeParameter) => (0, make_1.make)("InferTypeNode", { typeParameter });
-exports.createInferTypeNode = createInferTypeNode;
-//# sourceMappingURL=createInferTypeNode.mjs.map

package/lib/factory/types/createInferTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createInferTypeNode.mjs","sources":["createInferTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInferTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link InferTypeNode}: an `infer R` type used inside the extends\n * clause of a conditional type.\n *\n * The `infer ` keyword prints in front of the type parameter's name. In postfix\n * and array positions the surrounding printer wraps the infer type in\n * parentheses so `infer R[]` does not read as an array.\n *\n * Given a type parameter named `R`, the printer renders:\n *\n * ```ts\n * infer R\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameter The type parameter to infer.\n * @returns The created {@link InferTypeNode}.\n */\nconst createInferTypeNode = (typeParameter) => (0, make_1.make)(\"InferTypeNode\", { typeParameter });\nexports.createInferTypeNode = createInferTypeNode;\n//# sourceMappingURL=createInferTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,mBAAmB,GAAG,MAAM;AACpC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,mBAAmB,GAAG,CAAC,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,aAAa,EAAE,CAAC;AACnG,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}

package/lib/factory/types/createIntersectionTypeNode.mjs

@@ -1,24 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIntersectionTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link IntersectionTypeNode}: an `A & B` type.
- *
- * The constituents are joined with `&`. The printer is width-aware: when the
- * whole intersection fits on one line it stays inline as `A & B`, and when it
- * has to break it indents and puts each constituent on its own line with a
- * leading `&`, including a leading `&` before the first member.
- *
- * Given the constituents `A` and `B`, the printer renders:
- *
- * ```ts
- * A & B;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param types The constituent types.
- * @returns The created {@link IntersectionTypeNode}.
- */
-const createIntersectionTypeNode = (types) => (0, make_1.make)("IntersectionTypeNode", { types });
-exports.createIntersectionTypeNode = createIntersectionTypeNode;
-//# sourceMappingURL=createIntersectionTypeNode.mjs.map

package/lib/factory/types/createIntersectionTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createIntersectionTypeNode.mjs","sources":["createIntersectionTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createIntersectionTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link IntersectionTypeNode}: an `A & B` type.\n *\n * The constituents are joined with `&`. The printer is width-aware: when the\n * whole intersection fits on one line it stays inline as `A & B`, and when it\n * has to break it indents and puts each constituent on its own line with a\n * leading `&`, including a leading `&` before the first member.\n *\n * Given the constituents `A` and `B`, the printer renders:\n *\n * ```ts\n * A & B;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param types The constituent types.\n * @returns The created {@link IntersectionTypeNode}.\n */\nconst createIntersectionTypeNode = (types) => (0, make_1.make)(\"IntersectionTypeNode\", { types });\nexports.createIntersectionTypeNode = createIntersectionTypeNode;\n//# sourceMappingURL=createIntersectionTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,0BAA0B,GAAG,MAAM;AAC3C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,0BAA0B,GAAG,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,sBAAsB,EAAE,EAAE,KAAK,EAAE,CAAC;AACjG,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}

package/lib/factory/types/createKeywordTypeNode.mjs

@@ -1,25 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createKeywordTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link KeywordTypeNode}: a built-in keyword type such as `string` or
- * `number`.
- *
- * The kind is a keyword {@link SyntaxKind} like `StringKeyword`,
- * `NumberKeyword`, `BooleanKeyword`, `VoidKeyword`, `AnyKeyword`, or
- * `UnknownKeyword`. The printer emits the keyword's own source text directly,
- * so the node renders as that single word with no surrounding tokens.
- *
- * Given the `StringKeyword` kind, the printer renders:
- *
- * ```ts
- * string;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param kind The token kind.
- * @returns The created {@link KeywordTypeNode}.
- */
-const createKeywordTypeNode = (kind) => (0, make_1.make)("KeywordTypeNode", { keyword: kind });
-exports.createKeywordTypeNode = createKeywordTypeNode;
-//# sourceMappingURL=createKeywordTypeNode.mjs.map

package/lib/factory/types/createKeywordTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createKeywordTypeNode.mjs","sources":["createKeywordTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createKeywordTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link KeywordTypeNode}: a built-in keyword type such as `string` or\n * `number`.\n *\n * The kind is a keyword {@link SyntaxKind} like `StringKeyword`,\n * `NumberKeyword`, `BooleanKeyword`, `VoidKeyword`, `AnyKeyword`, or\n * `UnknownKeyword`. The printer emits the keyword's own source text directly,\n * so the node renders as that single word with no surrounding tokens.\n *\n * Given the `StringKeyword` kind, the printer renders:\n *\n * ```ts\n * string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param kind The token kind.\n * @returns The created {@link KeywordTypeNode}.\n */\nconst createKeywordTypeNode = (kind) => (0, make_1.make)(\"KeywordTypeNode\", { keyword: kind });\nexports.createKeywordTypeNode = createKeywordTypeNode;\n//# sourceMappingURL=createKeywordTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC9F,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}

package/lib/factory/types/createLiteralTypeNode.mjs

@@ -1,26 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLiteralTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link LiteralTypeNode}: a literal used in type position such as
- * `"foo"`, `42`, `true`, or `null`.
- *
- * The printer emits the wrapped literal directly, so the rendered text is
- * exactly that literal's own source. A {@link PrefixUnaryExpression} covers
- * negative numeric literals such as `-1`, and a {@link Token} covers keyword
- * literals such as `true`, `false`, and `null`.
- *
- * Given a `"foo"` string literal, the printer renders:
- *
- * ```ts
- * "foo";
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param literal The literal; a {@link PrefixUnaryExpression} covers negative
- *   numeric literals such as `-1`.
- * @returns The created {@link LiteralTypeNode}.
- */
-const createLiteralTypeNode = (literal) => (0, make_1.make)("LiteralTypeNode", { literal });
-exports.createLiteralTypeNode = createLiteralTypeNode;
-//# sourceMappingURL=createLiteralTypeNode.mjs.map

package/lib/factory/types/createLiteralTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createLiteralTypeNode.mjs","sources":["createLiteralTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createLiteralTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link LiteralTypeNode}: a literal used in type position such as\n * `\"foo\"`, `42`, `true`, or `null`.\n *\n * The printer emits the wrapped literal directly, so the rendered text is\n * exactly that literal's own source. A {@link PrefixUnaryExpression} covers\n * negative numeric literals such as `-1`, and a {@link Token} covers keyword\n * literals such as `true`, `false`, and `null`.\n *\n * Given a `\"foo\"` string literal, the printer renders:\n *\n * ```ts\n * \"foo\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param literal The literal; a {@link PrefixUnaryExpression} covers negative\n *   numeric literals such as `-1`.\n * @returns The created {@link LiteralTypeNode}.\n */\nconst createLiteralTypeNode = (literal) => (0, make_1.make)(\"LiteralTypeNode\", { literal });\nexports.createLiteralTypeNode = createLiteralTypeNode;\n//# sourceMappingURL=createLiteralTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,CAAC;AAC3F,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}

package/lib/factory/types/createMappedTypeNode.mjs

@@ -1,44 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMappedTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link MappedTypeNode}: a `{ [K in keyof T]: T[K] }` mapped type.
- *
- * The type parameter supplies the key variable and its `in` constraint. When
- * `nameType` is present it adds an `as` key remap, and when `type` is present
- * it adds the `: ValueType` value. The whole thing renders inside `{ ... }` on
- * one line.
- *
- * The `readonlyToken` and `questionToken` carry optional modifier polarity. A
- * plain `readonly` or `?` token prints as `readonly ` and `?`; a `+` or `-`
- * token prefixes the modifier, so it prints as `+readonly`/`-readonly` and
- * `+?`/`-?`.
- *
- * Given a `K in keyof T` parameter and a `T[K]` value with no modifiers, the
- * printer renders:
- *
- * ```ts
- * { [K in keyof T]: T[K] }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param readonlyToken The `readonly` modifier with optional `+`/`-` polarity,
- *   if any.
- * @param typeParameter The key type parameter holding the `in` constraint.
- * @param nameType The `as` key remap type, if any.
- * @param questionToken The optional-marker `?` with optional `+`/`-` polarity,
- *   if any.
- * @param type The mapped value type, if any.
- * @param members The members, if any.
- * @returns The created {@link MappedTypeNode}.
- */
-const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => (0, make_1.make)("MappedTypeNode", {
-    readonlyToken,
-    typeParameter,
-    nameType,
-    questionToken,
-    type,
-    members,
-});
-exports.createMappedTypeNode = createMappedTypeNode;
-//# sourceMappingURL=createMappedTypeNode.mjs.map

package/lib/factory/types/createMappedTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMappedTypeNode.mjs","sources":["createMappedTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createMappedTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link MappedTypeNode}: a `{ [K in keyof T]: T[K] }` mapped type.\n *\n * The type parameter supplies the key variable and its `in` constraint. When\n * `nameType` is present it adds an `as` key remap, and when `type` is present\n * it adds the `: ValueType` value. The whole thing renders inside `{ ... }` on\n * one line.\n *\n * The `readonlyToken` and `questionToken` carry optional modifier polarity. A\n * plain `readonly` or `?` token prints as `readonly ` and `?`; a `+` or `-`\n * token prefixes the modifier, so it prints as `+readonly`/`-readonly` and\n * `+?`/`-?`.\n *\n * Given a `K in keyof T` parameter and a `T[K]` value with no modifiers, the\n * printer renders:\n *\n * ```ts\n * { [K in keyof T]: T[K] }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param readonlyToken The `readonly` modifier with optional `+`/`-` polarity,\n *   if any.\n * @param typeParameter The key type parameter holding the `in` constraint.\n * @param nameType The `as` key remap type, if any.\n * @param questionToken The optional-marker `?` with optional `+`/`-` polarity,\n *   if any.\n * @param type The mapped value type, if any.\n * @param members The members, if any.\n * @returns The created {@link MappedTypeNode}.\n */\nconst createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => (0, make_1.make)(\"MappedTypeNode\", {\n    readonlyToken,\n    typeParameter,\n    nameType,\n    questionToken,\n    type,\n    members,\n});\nexports.createMappedTypeNode = createMappedTypeNode;\n//# sourceMappingURL=createMappedTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,oBAAoB,GAAG,MAAM;AACrC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,oBAAoB,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE;AAC1I,IAAI,aAAa;AACjB,IAAI,aAAa;AACjB,IAAI,QAAQ;AACZ,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,IAAI,OAAO;AACX,CAAC,CAAC;AACF,OAAO,CAAC,oBAAoB,GAAG,oBAAoB"}

package/lib/factory/types/createMethodSignature.mjs

@@ -1,39 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMethodSignature = void 0;
-const asPropertyName_1 = require("../internal/asPropertyName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link MethodSignature}: a `name(params): T` method signature for an
- * interface or type literal.
- *
- * Any modifiers print first, then the name, then a `?` when the question token
- * is present, then optional type parameters as `<...>`, the parameter list, and
- * the return type as `: Type` when present. A string name is normalized to a
- * property name node.
- *
- * Given the name `greet`, one `name: string` parameter, and a `void` return
- * type, the printer renders:
- *
- * ```ts
- * greet(name: string): void
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param modifiers The leading modifiers and decorators, if any.
- * @param name The method name.
- * @param questionToken The optional marker (`?`), if any.
- * @param typeParameters The generic type parameters, if any.
- * @param parameters The parameters.
- * @param type The return type, if any.
- * @returns The created {@link MethodSignature}.
- */
-const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => (0, make_1.make)("MethodSignature", {
-    modifiers,
-    name: (0, asPropertyName_1.asPropertyName)(name),
-    questionToken,
-    typeParameters,
-    parameters,
-    type,
-});
-exports.createMethodSignature = createMethodSignature;
-//# sourceMappingURL=createMethodSignature.mjs.map

package/lib/factory/types/createMethodSignature.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMethodSignature.mjs","sources":["createMethodSignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createMethodSignature = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link MethodSignature}: a `name(params): T` method signature for an\n * interface or type literal.\n *\n * Any modifiers print first, then the name, then a `?` when the question token\n * is present, then optional type parameters as `<...>`, the parameter list, and\n * the return type as `: Type` when present. A string name is normalized to a\n * property name node.\n *\n * Given the name `greet`, one `name: string` parameter, and a `void` return\n * type, the printer renders:\n *\n * ```ts\n * greet(name: string): void\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The method name.\n * @param questionToken The optional marker (`?`), if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link MethodSignature}.\n */\nconst createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => (0, make_1.make)(\"MethodSignature\", {\n    modifiers,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n});\nexports.createMethodSignature = createMethodSignature;\n//# sourceMappingURL=createMethodSignature.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,qBAAqB,GAAG,MAAM;AACtC,MAAM,gBAAgB,GAAG,OAAO,CAAC,4BAA4B,CAAC;AAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,qBAAqB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE;AACxI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}

package/lib/factory/types/createNamedTupleMember.mjs

@@ -1,33 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamedTupleMember = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
-/**
- * Create a {@link NamedTupleMember}: a labeled tuple element such as `name:
- * string`.
- *
- * A leading `...` prints when the rest token is present, then the label, then a
- * `?` when the question token is present, then `: ` followed by the type. A
- * string name is normalized to an identifier.
- *
- * Given the label `name` and a `string` type, the printer renders:
- *
- * ```ts
- * name: string;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param dotDotDotToken The rest marker (`...`), if any.
- * @param name The element label.
- * @param questionToken The optional marker (`?`), if any.
- * @param type The element type.
- * @returns The created {@link NamedTupleMember}.
- */
-const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => (0, make_1.make)("NamedTupleMember", {
-    dotDotDotToken,
-    name: (0, asName_1.asName)(name),
-    questionToken,
-    type,
-});
-exports.createNamedTupleMember = createNamedTupleMember;
-//# sourceMappingURL=createNamedTupleMember.mjs.map

package/lib/factory/types/createNamedTupleMember.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNamedTupleMember.mjs","sources":["createNamedTupleMember.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNamedTupleMember = void 0;\nconst asName_1 = require(\"../internal/asName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link NamedTupleMember}: a labeled tuple element such as `name:\n * string`.\n *\n * A leading `...` prints when the rest token is present, then the label, then a\n * `?` when the question token is present, then `: ` followed by the type. A\n * string name is normalized to an identifier.\n *\n * Given the label `name` and a `string` type, the printer renders:\n *\n * ```ts\n * name: string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The rest marker (`...`), if any.\n * @param name The element label.\n * @param questionToken The optional marker (`?`), if any.\n * @param type The element type.\n * @returns The created {@link NamedTupleMember}.\n */\nconst createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => (0, make_1.make)(\"NamedTupleMember\", {\n    dotDotDotToken,\n    name: (0, asName_1.asName)(name),\n    questionToken,\n    type,\n});\nexports.createNamedTupleMember = createNamedTupleMember;\n//# sourceMappingURL=createNamedTupleMember.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAC9C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE;AACnH,IAAI,cAAc;AAClB,IAAI,IAAI,EAAE,IAAI,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;AACpC,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/types/createNotEmittedTypeElement.mjs

@@ -1,17 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotEmittedTypeElement = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link NotEmittedTypeElement}: a placeholder type-element that
- * carries no syntax of its own.
- *
- * It exists to hold position and attached comments inside a member list without
- * contributing any text. The printer emits the empty string for it, so the
- * rendered output is empty:
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @returns The created {@link NotEmittedTypeElement}.
- */
-const createNotEmittedTypeElement = () => (0, make_1.make)("NotEmittedTypeElement", {});
-exports.createNotEmittedTypeElement = createNotEmittedTypeElement;
-//# sourceMappingURL=createNotEmittedTypeElement.mjs.map

package/lib/factory/types/createNotEmittedTypeElement.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNotEmittedTypeElement.mjs","sources":["createNotEmittedTypeElement.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createNotEmittedTypeElement = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link NotEmittedTypeElement}: a placeholder type-element that\n * carries no syntax of its own.\n *\n * It exists to hold position and attached comments inside a member list without\n * contributing any text. The printer emits the empty string for it, so the\n * rendered output is empty:\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link NotEmittedTypeElement}.\n */\nconst createNotEmittedTypeElement = () => (0, make_1.make)(\"NotEmittedTypeElement\", {});\nexports.createNotEmittedTypeElement = createNotEmittedTypeElement;\n//# sourceMappingURL=createNotEmittedTypeElement.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,2BAA2B,GAAG,MAAM;AAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,2BAA2B,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,uBAAuB,EAAE,EAAE,CAAC;AACvF,OAAO,CAAC,2BAA2B,GAAG,2BAA2B"}

package/lib/factory/types/createOptionalTypeNode.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOptionalTypeNode = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create an {@link OptionalTypeNode}: a `T?` optional element inside a tuple
- * type.
- *
- * The element type prints first, immediately followed by a `?`. This form is
- * only valid in tuple element position, for example `[string, number?]`.
- *
- * Given a `string` element type, the printer renders:
- *
- * ```ts
- * string?
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param type The element type.
- * @returns The created {@link OptionalTypeNode}.
- */
-const createOptionalTypeNode = (type) => (0, make_1.make)("OptionalTypeNode", { type });
-exports.createOptionalTypeNode = createOptionalTypeNode;
-//# sourceMappingURL=createOptionalTypeNode.mjs.map

package/lib/factory/types/createOptionalTypeNode.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createOptionalTypeNode.mjs","sources":["createOptionalTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createOptionalTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create an {@link OptionalTypeNode}: a `T?` optional element inside a tuple\n * type.\n *\n * The element type prints first, immediately followed by a `?`. This form is\n * only valid in tuple element position, for example `[string, number?]`.\n *\n * Given a `string` element type, the printer renders:\n *\n * ```ts\n * string?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The element type.\n * @returns The created {@link OptionalTypeNode}.\n */\nconst createOptionalTypeNode = (type) => (0, make_1.make)(\"OptionalTypeNode\", { type });\nexports.createOptionalTypeNode = createOptionalTypeNode;\n//# sourceMappingURL=createOptionalTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,sBAAsB,GAAG,MAAM;AACvC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,sBAAsB,GAAG,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,IAAI,EAAE,CAAC;AACvF,OAAO,CAAC,sBAAsB,GAAG,sBAAsB"}

package/lib/factory/types/createParenthesizedType.mjs

@@ -1,23 +0,0 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParenthesizedType = void 0;
-const make_1 = require("../internal/make");
-/**
- * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.
- *
- * The printer always wraps the inner type in literal parentheses, so this is
- * the way to force grouping the surrounding printer would not add on its own,
- * for example to disambiguate a union inside a larger type.
- *
- * Given an `A | B` inner type, the printer renders:
- *
- * ```ts
- * A | B;
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param type The inner type to parenthesize.
- * @returns The created {@link ParenthesizedTypeNode}.
- */
-const createParenthesizedType = (type) => (0, make_1.make)("ParenthesizedTypeNode", { type });
-exports.createParenthesizedType = createParenthesizedType;
-//# sourceMappingURL=createParenthesizedType.mjs.map