@ttsc/factory 0.15.8 → 0.15.10

package/lib/factory/types/createImportTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createImportTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link ImportTypeNode}: an `import("module").Qualifier<Args>` type.
  *
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @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;
+const createImportTypeNode = (argument, qualifier, typeArguments, isTypeOf = false) => make("ImportTypeNode", { argument, qualifier, typeArguments, isTypeOf });
+
+export { createImportTypeNode };
 //# sourceMappingURL=createImportTypeNode.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createImportTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createImportTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createImportTypeNode = (argument, qualifier, typeArguments, isTypeOf = false) => make(\"ImportTypeNode\", { argument, qualifier, typeArguments, isTypeOf });\n//# sourceMappingURL=createImportTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,GAAG,KAAK,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/types/createIndexSignature.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIndexSignature = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link IndexSignatureDeclaration}: a `[key: K]: V` index signature.
  *
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @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;
+const createIndexSignature = (modifiers, parameters, type) => make("IndexSignature", { modifiers, parameters, type });
+
+export { createIndexSignature };
 //# sourceMappingURL=createIndexSignature.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createIndexSignature.mjs","sources":["../../../esm-tmp/factory/types/createIndexSignature.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createIndexSignature = (modifiers, parameters, type) => make(\"IndexSignature\", { modifiers, parameters, type });\n//# sourceMappingURL=createIndexSignature.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,gBAAgB,EAAE,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createIndexedAccessTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIndexedAccessTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link IndexedAccessTypeNode}: a `T[K]` indexed access type.
  *
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param indexType The index type.
  * @returns The created {@link IndexedAccessTypeNode}.
  */
-const createIndexedAccessTypeNode = (objectType, indexType) => (0, make_1.make)("IndexedAccessTypeNode", { objectType, indexType });
-exports.createIndexedAccessTypeNode = createIndexedAccessTypeNode;
+const createIndexedAccessTypeNode = (objectType, indexType) => make("IndexedAccessTypeNode", { objectType, indexType });
+
+export { createIndexedAccessTypeNode };
 //# sourceMappingURL=createIndexedAccessTypeNode.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createIndexedAccessTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createIndexedAccessTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createIndexedAccessTypeNode = (objectType, indexType) => make(\"IndexedAccessTypeNode\", { objectType, indexType });\n//# sourceMappingURL=createIndexedAccessTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAC,uBAAuB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/types/createInferTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInferTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link InferTypeNode}: an `infer R` type used inside the extends
  * clause of a conditional type.
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param typeParameter The type parameter to infer.
  * @returns The created {@link InferTypeNode}.
  */
-const createInferTypeNode = (typeParameter) => (0, make_1.make)("InferTypeNode", { typeParameter });
-exports.createInferTypeNode = createInferTypeNode;
+const createInferTypeNode = (typeParameter) => make("InferTypeNode", { typeParameter });
+
+export { createInferTypeNode };
 //# sourceMappingURL=createInferTypeNode.mjs.map

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 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"}
+{"version":3,"file":"createInferTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createInferTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createInferTypeNode = (typeParameter) => make(\"InferTypeNode\", { typeParameter });\n//# sourceMappingURL=createInferTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,aAAa,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createIntersectionTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIntersectionTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link IntersectionTypeNode}: an `A & B` type.
  *
@@ -19,6 +18,7 @@ const make_1 = require("../internal/make");
  * @param types The constituent types.
  * @returns The created {@link IntersectionTypeNode}.
  */
-const createIntersectionTypeNode = (types) => (0, make_1.make)("IntersectionTypeNode", { types });
-exports.createIntersectionTypeNode = createIntersectionTypeNode;
+const createIntersectionTypeNode = (types) => make("IntersectionTypeNode", { types });
+
+export { createIntersectionTypeNode };
 //# sourceMappingURL=createIntersectionTypeNode.mjs.map

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 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"}
+{"version":3,"file":"createIntersectionTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createIntersectionTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createIntersectionTypeNode = (types) => make(\"IntersectionTypeNode\", { types });\n//# sourceMappingURL=createIntersectionTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,0BAA0B,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/types/createKeywordTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createKeywordTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link KeywordTypeNode}: a built-in keyword type such as `string` or
  * `number`.
@@ -20,6 +19,7 @@ const make_1 = require("../internal/make");
  * @param kind The token kind.
  * @returns The created {@link KeywordTypeNode}.
  */
-const createKeywordTypeNode = (kind) => (0, make_1.make)("KeywordTypeNode", { keyword: kind });
-exports.createKeywordTypeNode = createKeywordTypeNode;
+const createKeywordTypeNode = (kind) => make("KeywordTypeNode", { keyword: kind });
+
+export { createKeywordTypeNode };
 //# sourceMappingURL=createKeywordTypeNode.mjs.map

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}: 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"}
+{"version":3,"file":"createKeywordTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createKeywordTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createKeywordTypeNode = (kind) => make(\"KeywordTypeNode\", { keyword: kind });\n//# sourceMappingURL=createKeywordTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createLiteralTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLiteralTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link LiteralTypeNode}: a literal used in type position such as
  * `"foo"`, `42`, `true`, or `null`.
@@ -21,6 +20,7 @@ const make_1 = require("../internal/make");
  *   numeric literals such as `-1`.
  * @returns The created {@link LiteralTypeNode}.
  */
-const createLiteralTypeNode = (literal) => (0, make_1.make)("LiteralTypeNode", { literal });
-exports.createLiteralTypeNode = createLiteralTypeNode;
+const createLiteralTypeNode = (literal) => make("LiteralTypeNode", { literal });
+
+export { createLiteralTypeNode };
 //# sourceMappingURL=createLiteralTypeNode.mjs.map

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}: 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"}
+{"version":3,"file":"createLiteralTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createLiteralTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createLiteralTypeNode = (literal) => make(\"LiteralTypeNode\", { literal });\n//# sourceMappingURL=createLiteralTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createMappedTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMappedTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link MappedTypeNode}: a `{ [K in keyof T]: T[K] }` mapped type.
  *
@@ -32,7 +31,7 @@ const make_1 = require("../internal/make");
  * @param members The members, if any.
  * @returns The created {@link MappedTypeNode}.
  */
-const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => (0, make_1.make)("MappedTypeNode", {
+const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => make("MappedTypeNode", {
     readonlyToken,
     typeParameter,
     nameType,
@@ -40,5 +39,6 @@ const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionTo
     type,
     members,
 });
-exports.createMappedTypeNode = createMappedTypeNode;
+
+export { createMappedTypeNode };
 //# sourceMappingURL=createMappedTypeNode.mjs.map

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}: 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"}
+{"version":3,"file":"createMappedTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createMappedTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createMappedTypeNode = (readonlyToken, typeParameter, nameType, questionToken, type, members) => make(\"MappedTypeNode\", {\n    readonlyToken,\n    typeParameter,\n    nameType,\n    questionToken,\n    type,\n    members,\n});\n//# sourceMappingURL=createMappedTypeNode.js.map"],"names":[],"mappings":";;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;AACY,MAAC,oBAAoB,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACrI,IAAI,aAAa;AACjB,IAAI,aAAa;AACjB,IAAI,QAAQ;AACZ,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/types/createMethodSignature.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMethodSignature = void 0;
-const asPropertyName_1 = require("../internal/asPropertyName");
-const make_1 = require("../internal/make");
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link MethodSignature}: a `name(params): T` method signature for an
  * interface or type literal.
@@ -27,13 +26,14 @@ const make_1 = require("../internal/make");
  * @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", {
+const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => make("MethodSignature", {
     modifiers,
-    name: (0, asPropertyName_1.asPropertyName)(name),
+    name: asPropertyName(name),
     questionToken,
     typeParameters,
     parameters,
     type,
 });
-exports.createMethodSignature = createMethodSignature;
+
+export { createMethodSignature };
 //# sourceMappingURL=createMethodSignature.mjs.map

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}: 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"}
+{"version":3,"file":"createMethodSignature.mjs","sources":["../../../esm-tmp/factory/types/createMethodSignature.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../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 */\nexport const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => make(\"MethodSignature\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionToken,\n    typeParameters,\n    parameters,\n    type,\n});\n//# sourceMappingURL=createMethodSignature.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACnI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,aAAa;AACjB,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/types/createNamedTupleMember.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNamedTupleMember = void 0;
-const asName_1 = require("../internal/asName");
-const make_1 = require("../internal/make");
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NamedTupleMember}: a labeled tuple element such as `name:
  * string`.
@@ -23,11 +22,12 @@ const make_1 = require("../internal/make");
  * @param type The element type.
  * @returns The created {@link NamedTupleMember}.
  */
-const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => (0, make_1.make)("NamedTupleMember", {
+const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => make("NamedTupleMember", {
     dotDotDotToken,
-    name: (0, asName_1.asName)(name),
+    name: asName(name),
     questionToken,
     type,
 });
-exports.createNamedTupleMember = createNamedTupleMember;
+
+export { createNamedTupleMember };
 //# sourceMappingURL=createNamedTupleMember.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createNamedTupleMember.mjs","sources":["../../../esm-tmp/factory/types/createNamedTupleMember.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../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 */\nexport const createNamedTupleMember = (dotDotDotToken, name, questionToken, type) => make(\"NamedTupleMember\", {\n    dotDotDotToken,\n    name: asName(name),\n    questionToken,\n    type,\n});\n//# sourceMappingURL=createNamedTupleMember.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC9G,IAAI,cAAc;AAClB,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/types/createNotEmittedTypeElement.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNotEmittedTypeElement = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link NotEmittedTypeElement}: a placeholder type-element that
  * carries no syntax of its own.
@@ -12,6 +11,7 @@ const make_1 = require("../internal/make");
  * @author Jeongho Nam - https://github.com/samchon
  * @returns The created {@link NotEmittedTypeElement}.
  */
-const createNotEmittedTypeElement = () => (0, make_1.make)("NotEmittedTypeElement", {});
-exports.createNotEmittedTypeElement = createNotEmittedTypeElement;
+const createNotEmittedTypeElement = () => make("NotEmittedTypeElement", {});
+
+export { createNotEmittedTypeElement };
 //# sourceMappingURL=createNotEmittedTypeElement.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createNotEmittedTypeElement.mjs","sources":["../../../esm-tmp/factory/types/createNotEmittedTypeElement.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createNotEmittedTypeElement = () => make(\"NotEmittedTypeElement\", {});\n//# sourceMappingURL=createNotEmittedTypeElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}

package/lib/factory/types/createOptionalTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOptionalTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create an {@link OptionalTypeNode}: a `T?` optional element inside a tuple
  * type.
@@ -18,6 +17,7 @@ const make_1 = require("../internal/make");
  * @param type The element type.
  * @returns The created {@link OptionalTypeNode}.
  */
-const createOptionalTypeNode = (type) => (0, make_1.make)("OptionalTypeNode", { type });
-exports.createOptionalTypeNode = createOptionalTypeNode;
+const createOptionalTypeNode = (type) => make("OptionalTypeNode", { type });
+
+export { createOptionalTypeNode };
 //# sourceMappingURL=createOptionalTypeNode.mjs.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"createOptionalTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createOptionalTypeNode.js"],"sourcesContent":["import { make } from \"../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 */\nexport const createOptionalTypeNode = (type) => make(\"OptionalTypeNode\", { type });\n//# sourceMappingURL=createOptionalTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createParenthesizedType.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParenthesizedType = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.
  *
@@ -18,6 +17,7 @@ const make_1 = require("../internal/make");
  * @param type The inner type to parenthesize.
  * @returns The created {@link ParenthesizedTypeNode}.
  */
-const createParenthesizedType = (type) => (0, make_1.make)("ParenthesizedTypeNode", { type });
-exports.createParenthesizedType = createParenthesizedType;
+const createParenthesizedType = (type) => make("ParenthesizedTypeNode", { type });
+
+export { createParenthesizedType };
 //# sourceMappingURL=createParenthesizedType.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createParenthesizedType.mjs","sources":["createParenthesizedType.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createParenthesizedType = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.\n *\n * The printer always wraps the inner type in literal parentheses, so this is\n * the way to force grouping the surrounding printer would not add on its own,\n * for example to disambiguate a union inside a larger type.\n *\n * Given an `A | B` inner type, the printer renders:\n *\n * ```ts\n * A | B;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The inner type to parenthesize.\n * @returns The created {@link ParenthesizedTypeNode}.\n */\nconst createParenthesizedType = (type) => (0, make_1.make)(\"ParenthesizedTypeNode\", { type });\nexports.createParenthesizedType = createParenthesizedType;\n//# sourceMappingURL=createParenthesizedType.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,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,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,uBAAuB,EAAE,EAAE,IAAI,EAAE,CAAC;AAC7F,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createParenthesizedType.mjs","sources":["../../../esm-tmp/factory/types/createParenthesizedType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ParenthesizedTypeNode}: a `(T)` explicitly parenthesized type.\n *\n * The printer always wraps the inner type in literal parentheses, so this is\n * the way to force grouping the surrounding printer would not add on its own,\n * for example to disambiguate a union inside a larger type.\n *\n * Given an `A | B` inner type, the printer renders:\n *\n * ```ts\n * A | B;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The inner type to parenthesize.\n * @returns The created {@link ParenthesizedTypeNode}.\n */\nexport const createParenthesizedType = (type) => make(\"ParenthesizedTypeNode\", { type });\n//# sourceMappingURL=createParenthesizedType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,uBAAuB,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createPropertySignature.mjs

@@ -1,7 +1,6 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPropertySignature = void 0;
-const asPropertyName_1 = require("../internal/asPropertyName");
-const make_1 = require("../internal/make");
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link PropertySignature}: a `name?: T` property in an interface or
  * type literal.
@@ -24,11 +23,12 @@ const make_1 = require("../internal/make");
  * @param type The property type, if any.
  * @returns The created {@link PropertySignature}.
  */
-const createPropertySignature = (modifiers, name, questionToken, type) => (0, make_1.make)("PropertySignature", {
+const createPropertySignature = (modifiers, name, questionToken, type) => make("PropertySignature", {
     modifiers,
-    name: (0, asPropertyName_1.asPropertyName)(name),
+    name: asPropertyName(name),
     questionToken,
     type,
 });
-exports.createPropertySignature = createPropertySignature;
+
+export { createPropertySignature };
 //# sourceMappingURL=createPropertySignature.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertySignature.mjs","sources":["createPropertySignature.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createPropertySignature = void 0;\nconst asPropertyName_1 = require(\"../internal/asPropertyName\");\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link PropertySignature}: a `name?: T` property in an interface or\n * type literal.\n *\n * Any modifiers print first (for example `readonly`), then the name, then a `?`\n * when the question token is present, then `: ` followed by the type when\n * present. A string name is normalized to a property name node.\n *\n * Given the name `name`, a present question token, and a `string` type, the\n * printer renders:\n *\n * ```ts\n * name?: string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The property name.\n * @param questionToken The optional marker (`?`), if any.\n * @param type The property type, if any.\n * @returns The created {@link PropertySignature}.\n */\nconst createPropertySignature = (modifiers, name, questionToken, type) => (0, make_1.make)(\"PropertySignature\", {\n    modifiers,\n    name: (0, asPropertyName_1.asPropertyName)(name),\n    questionToken,\n    type,\n});\nexports.createPropertySignature = createPropertySignature;\n//# sourceMappingURL=createPropertySignature.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,uBAAuB,GAAG,MAAM;AACxC,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,MAAM,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,mBAAmB,EAAE;AAChH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,gBAAgB,CAAC,cAAc,EAAE,IAAI,CAAC;AACpD,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC,CAAC;AACF,OAAO,CAAC,uBAAuB,GAAG,uBAAuB"}
+{"version":3,"file":"createPropertySignature.mjs","sources":["../../../esm-tmp/factory/types/createPropertySignature.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertySignature}: a `name?: T` property in an interface or\n * type literal.\n *\n * Any modifiers print first (for example `readonly`), then the name, then a `?`\n * when the question token is present, then `: ` followed by the type when\n * present. A string name is normalized to a property name node.\n *\n * Given the name `name`, a present question token, and a `string` type, the\n * printer renders:\n *\n * ```ts\n * name?: string\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The property name.\n * @param questionToken The optional marker (`?`), if any.\n * @param type The property type, if any.\n * @returns The created {@link PropertySignature}.\n */\nexport const createPropertySignature = (modifiers, name, questionToken, type) => make(\"PropertySignature\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionToken,\n    type,\n});\n//# sourceMappingURL=createPropertySignature.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3G,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,aAAa;AACjB,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/types/createRestTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRestTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.
  *
@@ -17,6 +16,7 @@ const make_1 = require("../internal/make");
  * @param type The rest element type.
  * @returns The created {@link RestTypeNode}.
  */
-const createRestTypeNode = (type) => (0, make_1.make)("RestTypeNode", { type });
-exports.createRestTypeNode = createRestTypeNode;
+const createRestTypeNode = (type) => make("RestTypeNode", { type });
+
+export { createRestTypeNode };
 //# sourceMappingURL=createRestTypeNode.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createRestTypeNode.mjs","sources":["createRestTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createRestTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.\n *\n * A leading `...` prints in front of the type. This form is only valid in tuple\n * 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 rest element type.\n * @returns The created {@link RestTypeNode}.\n */\nconst createRestTypeNode = (type) => (0, make_1.make)(\"RestTypeNode\", { type });\nexports.createRestTypeNode = createRestTypeNode;\n//# sourceMappingURL=createRestTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,kBAAkB,GAAG,MAAM;AACnC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,kBAAkB,GAAG,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,IAAI,EAAE,CAAC;AAC/E,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}
+{"version":3,"file":"createRestTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createRestTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link RestTypeNode}: a `...T` rest element inside a tuple type.\n *\n * A leading `...` prints in front of the type. This form is only valid in tuple\n * 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 rest element type.\n * @returns The created {@link RestTypeNode}.\n */\nexport const createRestTypeNode = (type) => make(\"RestTypeNode\", { type });\n//# sourceMappingURL=createRestTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createTemplateLiteralType.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplateLiteralType = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal
  * type.
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param templateSpans The interpolated spans.
  * @returns The created {@link TemplateLiteralTypeNode}.
  */
-const createTemplateLiteralType = (head, templateSpans) => (0, make_1.make)("TemplateLiteralType", { head, templateSpans });
-exports.createTemplateLiteralType = createTemplateLiteralType;
+const createTemplateLiteralType = (head, templateSpans) => make("TemplateLiteralType", { head, templateSpans });
+
+export { createTemplateLiteralType };
 //# sourceMappingURL=createTemplateLiteralType.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createTemplateLiteralType.mjs","sources":["createTemplateLiteralType.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTemplateLiteralType = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal\n * type.\n *\n * The head supplies the leading text up to the first `${`, then each span\n * contributes an interpolated type followed by the literal text up to the next\n * `${` or the closing backtick. The spans print back to back, so the whole\n * thing reads as one template string.\n *\n * Given the head text `id-` and a single span of `string` ending the template,\n * the printer renders:\n *\n * ```ts\n * `id-${string}`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param head The leading text up to the first interpolation.\n * @param templateSpans The interpolated spans.\n * @returns The created {@link TemplateLiteralTypeNode}.\n */\nconst createTemplateLiteralType = (head, templateSpans) => (0, make_1.make)(\"TemplateLiteralType\", { head, templateSpans });\nexports.createTemplateLiteralType = createTemplateLiteralType;\n//# sourceMappingURL=createTemplateLiteralType.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,IAAI,EAAE,aAAa,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,qBAAqB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;AAC3H,OAAO,CAAC,yBAAyB,GAAG,yBAAyB"}
+{"version":3,"file":"createTemplateLiteralType.mjs","sources":["../../../esm-tmp/factory/types/createTemplateLiteralType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateLiteralTypeNode}: a ``id-${string}`` template literal\n * type.\n *\n * The head supplies the leading text up to the first `${`, then each span\n * contributes an interpolated type followed by the literal text up to the next\n * `${` or the closing backtick. The spans print back to back, so the whole\n * thing reads as one template string.\n *\n * Given the head text `id-` and a single span of `string` ending the template,\n * the printer renders:\n *\n * ```ts\n * `id-${string}`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param head The leading text up to the first interpolation.\n * @param templateSpans The interpolated spans.\n * @returns The created {@link TemplateLiteralTypeNode}.\n */\nexport const createTemplateLiteralType = (head, templateSpans) => make(\"TemplateLiteralType\", { head, templateSpans });\n//# sourceMappingURL=createTemplateLiteralType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createTemplateLiteralTypeSpan.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTemplateLiteralTypeSpan = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template
  * literal type, an interpolated type plus the literal text that follows it.
@@ -22,6 +21,7 @@ const make_1 = require("../internal/make");
  * @param literal The trailing middle or tail literal.
  * @returns The created {@link TemplateLiteralTypeSpan}.
  */
-const createTemplateLiteralTypeSpan = (type, literal) => (0, make_1.make)("TemplateLiteralTypeSpan", { type, literal });
-exports.createTemplateLiteralTypeSpan = createTemplateLiteralTypeSpan;
+const createTemplateLiteralTypeSpan = (type, literal) => make("TemplateLiteralTypeSpan", { type, literal });
+
+export { createTemplateLiteralTypeSpan };
 //# sourceMappingURL=createTemplateLiteralTypeSpan.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createTemplateLiteralTypeSpan.mjs","sources":["createTemplateLiteralTypeSpan.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createTemplateLiteralTypeSpan = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template\n * literal type, an interpolated type plus the literal text that follows it.\n *\n * The type prints first, then the trailing literal. The literal is a\n * {@link TemplateMiddle} when another span follows and a {@link TemplateTail}\n * when it closes the template. A span only renders meaningfully inside a\n * template literal type; on its own it is just a fragment.\n *\n * Given a `number` type and a `px` tail inside a ``width:${...}`` template, the\n * printer renders:\n *\n * ```ts\n * `width:${number}px`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The interpolated type.\n * @param literal The trailing middle or tail literal.\n * @returns The created {@link TemplateLiteralTypeSpan}.\n */\nconst createTemplateLiteralTypeSpan = (type, literal) => (0, make_1.make)(\"TemplateLiteralTypeSpan\", { type, literal });\nexports.createTemplateLiteralTypeSpan = createTemplateLiteralTypeSpan;\n//# sourceMappingURL=createTemplateLiteralTypeSpan.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,6BAA6B,GAAG,MAAM;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,6BAA6B,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,MAAM,CAAC,IAAI,EAAE,yBAAyB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;AACvH,OAAO,CAAC,6BAA6B,GAAG,6BAA6B"}
+{"version":3,"file":"createTemplateLiteralTypeSpan.mjs","sources":["../../../esm-tmp/factory/types/createTemplateLiteralTypeSpan.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateLiteralTypeSpan}: one interpolation of a template\n * literal type, an interpolated type plus the literal text that follows it.\n *\n * The type prints first, then the trailing literal. The literal is a\n * {@link TemplateMiddle} when another span follows and a {@link TemplateTail}\n * when it closes the template. A span only renders meaningfully inside a\n * template literal type; on its own it is just a fragment.\n *\n * Given a `number` type and a `px` tail inside a ``width:${...}`` template, the\n * printer renders:\n *\n * ```ts\n * `width:${number}px`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The interpolated type.\n * @param literal The trailing middle or tail literal.\n * @returns The created {@link TemplateLiteralTypeSpan}.\n */\nexport const createTemplateLiteralTypeSpan = (type, literal) => make(\"TemplateLiteralTypeSpan\", { type, literal });\n//# sourceMappingURL=createTemplateLiteralTypeSpan.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC,yBAAyB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/types/createThisTypeNode.mjs

@@ -1,6 +1,5 @@
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createThisTypeNode = void 0;
-const make_1 = require("../internal/make");
+import { make } from '../internal/make.mjs';
+
 /**
  * Create a {@link ThisTypeNode}: the `this` type.
  *
@@ -17,6 +16,7 @@ const make_1 = require("../internal/make");
  * @author Jeongho Nam - https://github.com/samchon
  * @returns The created {@link ThisTypeNode}.
  */
-const createThisTypeNode = () => (0, make_1.make)("ThisTypeNode", {});
-exports.createThisTypeNode = createThisTypeNode;
+const createThisTypeNode = () => make("ThisTypeNode", {});
+
+export { createThisTypeNode };
 //# sourceMappingURL=createThisTypeNode.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"createThisTypeNode.mjs","sources":["createThisTypeNode.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createThisTypeNode = void 0;\nconst make_1 = require(\"../internal/make\");\n/**\n * Create a {@link ThisTypeNode}: the `this` type.\n *\n * It takes no inputs and the printer always emits the single keyword `this`,\n * the polymorphic this-type used in fluent method return positions and type\n * predicates.\n *\n * The printer renders:\n *\n * ```ts\n * this;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link ThisTypeNode}.\n */\nconst createThisTypeNode = () => (0, make_1.make)(\"ThisTypeNode\", {});\nexports.createThisTypeNode = createThisTypeNode;\n//# sourceMappingURL=createThisTypeNode.js.map"],"names":[],"mappings":"AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;AAC7D,OAAO,CAAC,kBAAkB,GAAG,MAAM;AACnC,MAAM,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,kBAAkB,GAAG,MAAM,IAAI,MAAM,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,CAAC;AACrE,OAAO,CAAC,kBAAkB,GAAG,kBAAkB"}
+{"version":3,"file":"createThisTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createThisTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ThisTypeNode}: the `this` type.\n *\n * It takes no inputs and the printer always emits the single keyword `this`,\n * the polymorphic this-type used in fluent method return positions and type\n * predicates.\n *\n * The printer renders:\n *\n * ```ts\n * this;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link ThisTypeNode}.\n */\nexport const createThisTypeNode = () => make(\"ThisTypeNode\", {});\n//# sourceMappingURL=createThisTypeNode.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,EAAE;;;;"}