@ttsc/factory 0.15.6 → 0.15.8

package/lib/factory/types/createInferTypeNode.js

@@ -3,11 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInferTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link InferTypeNode}.
+ * 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 typeParameter.
- * @returns The created node.
+ * @param typeParameter The type parameter to infer.
+ * @returns The created {@link InferTypeNode}.
  */
 const createInferTypeNode = (typeParameter) => (0, make_1.make)("InferTypeNode", { typeParameter });
 exports.createInferTypeNode = createInferTypeNode;

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

@@ -1 +1 @@
-{"version":3,"file":"createInferTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createInferTypeNode.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,mBAAmB,GAAG,CACjC,aAAuC,EACxB,EAAE,CAAC,IAAA,WAAI,EAAC,eAAe,EAAE,EAAE,aAAa,EAAE,CAAC,CAAC;AAFhD,QAAA,mBAAmB,GAAnB,mBAAmB,CAE6B"}
+{"version":3,"file":"createInferTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createInferTypeNode.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACI,MAAM,mBAAmB,GAAG,CACjC,aAAuC,EACxB,EAAE,CAAC,IAAA,WAAI,EAAC,eAAe,EAAE,EAAE,aAAa,EAAE,CAAC,CAAC;AAFhD,QAAA,mBAAmB,GAAnB,mBAAmB,CAE6B"}

package/lib/factory/types/createInferTypeNode.mjs

@@ -2,11 +2,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInferTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link InferTypeNode}.
+ * 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 typeParameter.
- * @returns The created node.
+ * @param typeParameter The type parameter to infer.
+ * @returns The created {@link InferTypeNode}.
  */
 const createInferTypeNode = (typeParameter) => (0, make_1.make)("InferTypeNode", { typeParameter });
 exports.createInferTypeNode = createInferTypeNode;

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

@@ -1 +1 @@
-{"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 a {@link InferTypeNode}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameter The typeParameter.\n * @returns The created node.\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,MAAM,mBAAmB,GAAG,CAAC,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,aAAa,EAAE,CAAC;AACnG,OAAO,CAAC,mBAAmB,GAAG,mBAAmB"}
+{"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.d.ts

@@ -1,6 +1,17 @@
 import type { IntersectionTypeNode, TypeNode } from "../../ast";
 /**
- * Create a {@link IntersectionTypeNode}.
+ * 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.

package/lib/factory/types/createIntersectionTypeNode.js

@@ -3,7 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIntersectionTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link IntersectionTypeNode}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createIntersectionTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createIntersectionTypeNode.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,0BAA0B,GAAG,CACxC,KAA0B,EACJ,EAAE,CAAC,IAAA,WAAI,EAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;AAFtD,QAAA,0BAA0B,GAA1B,0BAA0B,CAE4B"}
+{"version":3,"file":"createIntersectionTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createIntersectionTypeNode.ts"],"names":[],"mappings":";;;AACA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACI,MAAM,0BAA0B,GAAG,CACxC,KAA0B,EACJ,EAAE,CAAC,IAAA,WAAI,EAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;AAFtD,QAAA,0BAA0B,GAA1B,0BAA0B,CAE4B"}

package/lib/factory/types/createIntersectionTypeNode.mjs

@@ -2,7 +2,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIntersectionTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link IntersectionTypeNode}.
+ * 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.

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

@@ -1 +1 @@
-{"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 a {@link IntersectionTypeNode}.\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,MAAM,0BAA0B,GAAG,CAAC,KAAK,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,sBAAsB,EAAE,EAAE,KAAK,EAAE,CAAC;AACjG,OAAO,CAAC,0BAA0B,GAAG,0BAA0B"}
+{"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.d.ts

@@ -1,7 +1,19 @@
 import type { KeywordTypeNode } from "../../ast";
 import { SyntaxKind } from "../../syntax";
 /**
- * Create a {@link KeywordTypeNode}.
+ * 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.

package/lib/factory/types/createKeywordTypeNode.js

@@ -3,7 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createKeywordTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link KeywordTypeNode}.
+ * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"createKeywordTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createKeywordTypeNode.ts"],"names":[],"mappings":";;;AAEA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,qBAAqB,GAAG,CAAC,IAAgB,EAAmB,EAAE,CACzE,IAAA,WAAI,EAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;AADhC,QAAA,qBAAqB,GAArB,qBAAqB,CACW"}
+{"version":3,"file":"createKeywordTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createKeywordTypeNode.ts"],"names":[],"mappings":";;;AAEA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACI,MAAM,qBAAqB,GAAG,CAAC,IAAgB,EAAmB,EAAE,CACzE,IAAA,WAAI,EAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;AADhC,QAAA,qBAAqB,GAArB,qBAAqB,CACW"}

package/lib/factory/types/createKeywordTypeNode.mjs

@@ -2,7 +2,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createKeywordTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link KeywordTypeNode}.
+ * 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.

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

@@ -1 +1 @@
-{"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}.\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,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"}
+{"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.d.ts

@@ -1,9 +1,22 @@
-import type { BigIntLiteral, LiteralTypeNode, NumericLiteral, StringLiteral, Token } from "../../ast";
+import type { BigIntLiteral, LiteralTypeNode, NumericLiteral, PrefixUnaryExpression, StringLiteral, Token } from "../../ast";
 /**
- * Create a {@link LiteralTypeNode}.
+ * 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.
+ * @param literal The literal; a {@link PrefixUnaryExpression} covers negative
+ *   numeric literals such as `-1`.
  * @returns The created {@link LiteralTypeNode}.
  */
-export declare const createLiteralTypeNode: (literal: StringLiteral | NumericLiteral | BigIntLiteral | Token) => LiteralTypeNode;
+export declare const createLiteralTypeNode: (literal: StringLiteral | NumericLiteral | BigIntLiteral | PrefixUnaryExpression | Token) => LiteralTypeNode;

package/lib/factory/types/createLiteralTypeNode.js

@@ -3,10 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLiteralTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link LiteralTypeNode}.
+ * 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.
+ * @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 });

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

@@ -1 +1 @@
-{"version":3,"file":"createLiteralTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createLiteralTypeNode.ts"],"names":[],"mappings":";;;AAOA,2CAAwC;AAExC;;;;;;GAMG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAA+D,EAC9C,EAAE,CAAC,IAAA,WAAI,EAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;AAF9C,QAAA,qBAAqB,GAArB,qBAAqB,CAEyB"}
+{"version":3,"file":"createLiteralTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createLiteralTypeNode.ts"],"names":[],"mappings":";;;AAQA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;GAmBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAKS,EACQ,EAAE,CAAC,IAAA,WAAI,EAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;AAP9C,QAAA,qBAAqB,GAArB,qBAAqB,CAOyB"}

package/lib/factory/types/createLiteralTypeNode.mjs

@@ -2,10 +2,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLiteralTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link LiteralTypeNode}.
+ * 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.
+ * @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 });

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

@@ -1 +1 @@
-{"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}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param literal The literal.\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,MAAM,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,CAAC;AAC3F,OAAO,CAAC,qBAAqB,GAAG,qBAAqB"}
+{"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.d.ts

@@ -1,14 +1,33 @@
 import type { MappedTypeNode, Token, TypeElement, TypeNode, TypeParameterDeclaration } from "../../ast";
 /**
- * Create a {@link MappedTypeNode}.
+ * 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 readonlyToken.
- * @param typeParameter The typeParameter.
- * @param nameType The nameType.
- * @param questionToken The questionToken.
- * @param type The type.
- * @param members The members.
- * @returns The created node.
+ * @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}.
  */
 export declare const createMappedTypeNode: (readonlyToken: Token | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: Token | undefined, type: TypeNode | undefined, members: readonly TypeElement[] | undefined) => MappedTypeNode;

package/lib/factory/types/createMappedTypeNode.js

@@ -3,16 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMappedTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MappedTypeNode}.
+ * 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 readonlyToken.
- * @param typeParameter The typeParameter.
- * @param nameType The nameType.
- * @param questionToken The questionToken.
- * @param type The type.
- * @param members The members.
- * @returns The created node.
+ * @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,

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

@@ -1 +1 @@
-{"version":3,"file":"createMappedTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createMappedTypeNode.ts"],"names":[],"mappings":";;;AAOA,2CAAwC;AAExC;;;;;;;;;;;GAWG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,aAAuC,EACvC,QAA8B,EAC9B,aAAgC,EAChC,IAA0B,EAC1B,OAA2C,EAC3B,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE;IACrB,aAAa;IACb,aAAa;IACb,QAAQ;IACR,aAAa;IACb,IAAI;IACJ,OAAO;CACR,CAAC,CAAC;AAfQ,QAAA,oBAAoB,GAApB,oBAAoB,CAe5B"}
+{"version":3,"file":"createMappedTypeNode.js","sourceRoot":"","sources":["../../../src/factory/types/createMappedTypeNode.ts"],"names":[],"mappings":";;;AAOA,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACI,MAAM,oBAAoB,GAAG,CAClC,aAAgC,EAChC,aAAuC,EACvC,QAA8B,EAC9B,aAAgC,EAChC,IAA0B,EAC1B,OAA2C,EAC3B,EAAE,CAClB,IAAA,WAAI,EAAC,gBAAgB,EAAE;IACrB,aAAa;IACb,aAAa;IACb,QAAQ;IACR,aAAa;IACb,IAAI;IACJ,OAAO;CACR,CAAC,CAAC;AAfQ,QAAA,oBAAoB,GAApB,oBAAoB,CAe5B"}

package/lib/factory/types/createMappedTypeNode.mjs

@@ -2,16 +2,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMappedTypeNode = void 0;
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MappedTypeNode}.
+ * 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 readonlyToken.
- * @param typeParameter The typeParameter.
- * @param nameType The nameType.
- * @param questionToken The questionToken.
- * @param type The type.
- * @param members The members.
- * @returns The created node.
+ * @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,

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

@@ -1 +1 @@
-{"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}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param readonlyToken The readonlyToken.\n * @param typeParameter The typeParameter.\n * @param nameType The nameType.\n * @param questionToken The questionToken.\n * @param type The type.\n * @param members The members.\n * @returns The created node.\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,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"}
+{"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.d.ts

@@ -1,14 +1,27 @@
 import type { MethodSignature, ModifierLike, ParameterDeclaration, PropertyName, Token, TypeNode, TypeParameterDeclaration } from "../../ast";
 /**
- * Create a {@link MethodSignature}.
+ * 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 name.
+ * @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 type.
+ * @param type The return type, if any.
  * @returns The created {@link MethodSignature}.
  */
 export declare const createMethodSignature: (modifiers: readonly ModifierLike[] | undefined, name: string | PropertyName, questionToken: Token | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined) => MethodSignature;

package/lib/factory/types/createMethodSignature.js

@@ -4,15 +4,28 @@ exports.createMethodSignature = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MethodSignature}.
+ * 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 name.
+ * @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 type.
+ * @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", {

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

@@ -1 +1 @@
-{"version":3,"file":"createMethodSignature.js","sourceRoot":"","sources":["../../../src/factory/types/createMethodSignature.ts"],"names":[],"mappings":";;;AASA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;;GAWG;AACI,MAAM,qBAAqB,GAAG,CACnC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EACT,EAAE,CACnB,IAAA,WAAI,EAAC,iBAAiB,EAAE;IACtB,SAAS;IACT,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;CACL,CAAC,CAAC;AAfQ,QAAA,qBAAqB,GAArB,qBAAqB,CAe7B"}
+{"version":3,"file":"createMethodSignature.js","sourceRoot":"","sources":["../../../src/factory/types/createMethodSignature.ts"],"names":[],"mappings":";;;AASA,+DAA4D;AAC5D,2CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACI,MAAM,qBAAqB,GAAG,CACnC,SAA8C,EAC9C,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EACT,EAAE,CACnB,IAAA,WAAI,EAAC,iBAAiB,EAAE;IACtB,SAAS;IACT,IAAI,EAAE,IAAA,+BAAc,EAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;CACL,CAAC,CAAC;AAfQ,QAAA,qBAAqB,GAArB,qBAAqB,CAe7B"}

package/lib/factory/types/createMethodSignature.mjs

@@ -3,15 +3,28 @@ exports.createMethodSignature = void 0;
 const asPropertyName_1 = require("../internal/asPropertyName");
 const make_1 = require("../internal/make");
 /**
- * Create a {@link MethodSignature}.
+ * 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 name.
+ * @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 type.
+ * @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", {

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

@@ -1 +1 @@
-{"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}.\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The 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 type.\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,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"}
+{"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.d.ts

@@ -1,12 +1,23 @@
 import type { Identifier, NamedTupleMember, Token, TypeNode } from "../../ast";
 /**
- * Create a {@link NamedTupleMember}.
+ * 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 dotDotDotToken.
- * @param name The name.
- * @param questionToken The questionToken.
- * @param type The type.
- * @returns The created node.
+ * @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}.
  */
 export declare const createNamedTupleMember: (dotDotDotToken: Token | undefined, name: string | Identifier, questionToken: Token | undefined, type: TypeNode) => NamedTupleMember;