@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/types/createConstructSignature.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createConstructSignature.mjs","sources":["../../../esm-tmp/factory/types/createConstructSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructSignature}: a `new (params): T` construct signature\n * for an interface or type literal.\n *\n * The `new ` keyword prints first, then optional type parameters as `<...>`,\n * the parameter list, and the return type as `: Type` when present.\n *\n * Given one `x: number` parameter and a `Foo` return type, the printer renders:\n *\n * ```ts\n * new (x: number): Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link ConstructSignature}.\n */\nexport const createConstructSignature = (typeParameters, parameters, type) => make(\"ConstructSignature\", { typeParameters, parameters, type });\n//# sourceMappingURL=createConstructSignature.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,wBAAwB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createConstructorTypeNode.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createConstructorTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createConstructorTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConstructorTypeNode}: a `new (params) => T` constructor type.\n *\n * Any modifiers print first (for example `abstract`), then the `new ` keyword,\n * then optional type parameters as `<...>`, the parameter list, and finally\n * `=>` followed by the return type.\n *\n * Given no modifiers, one `x: number` parameter, and a `Foo` return type, the\n * printer renders:\n *\n * ```ts\n * new (x: number) => Foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link ConstructorTypeNode}.\n */\nexport const createConstructorTypeNode = (modifiers, typeParameters, parameters, type) => make(\"ConstructorTypeNode\", { modifiers, typeParameters, parameters, type });\n//# sourceMappingURL=createConstructorTypeNode.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,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createExpressionWithTypeArguments.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createExpressionWithTypeArguments.mjs","sources":["../../../esm-tmp/factory/types/createExpressionWithTypeArguments.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ExpressionWithTypeArguments}: an `Expr<TypeArgs>` form used\n * in heritage clauses such as `extends Base<T>`.\n *\n * The expression prints first, followed by the type arguments as `<...>` when\n * present. With no type arguments only the bare expression prints.\n *\n * Given a `Foo` expression and a single `string` type argument, the printer\n * renders:\n *\n * ```ts\n * Foo<string>;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The base expression.\n * @param typeArguments The generic type arguments, if any.\n * @returns The created {@link ExpressionWithTypeArguments}.\n */\nexport const createExpressionWithTypeArguments = (expression, typeArguments) => make(\"ExpressionWithTypeArguments\", { expression, typeArguments });\n//# sourceMappingURL=createExpressionWithTypeArguments.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,iCAAiC,GAAG,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAC,6BAA6B,EAAE,EAAE,UAAU,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/types/createFunctionTypeNode.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFunctionTypeNode.mjs","sources":["../../../esm-tmp/factory/types/createFunctionTypeNode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link FunctionTypeNode}: a `(params) => T` function type.\n *\n * Optional type parameters print first as `<...>`, then the parameter list,\n * then `=>` followed by the return type. In postfix and array positions the\n * surrounding printer wraps a function type in parentheses, since `() => T[]`\n * would otherwise read as an array of the return type.\n *\n * Given one `x: number` parameter and a `string` return type, the printer\n * renders:\n *\n * ```ts\n * (x: number) => string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The generic type parameters, if any.\n * @param parameters The parameters.\n * @param type The return type.\n * @returns The created {@link FunctionTypeNode}.\n */\nexport const createFunctionTypeNode = (typeParameters, parameters, type) => make(\"FunctionTypeNode\", { typeParameters, parameters, type });\n//# sourceMappingURL=createFunctionTypeNode.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,sBAAsB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,kBAAkB,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createImportTypeNode.mjs

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,39 @@
+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.
+ *
+ * Any modifiers print first, then the name, then a `?` when the question token
+ * is present, then optional type parameters as `<...>`, the parameter list, and
+ * the return type as `: Type` when present. A string name is normalized to a
+ * property name node.
+ *
+ * Given the name `greet`, one `name: string` parameter, and a `void` return
+ * type, the printer renders:
+ *
+ * ```ts
+ * greet(name: string): void
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The method name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The return type, if any.
+ * @returns The created {@link MethodSignature}.
+ */
+const createMethodSignature = (modifiers, name, questionToken, typeParameters, parameters, type) => make("MethodSignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    typeParameters,
+    parameters,
+    type,
+});
+
+export { createMethodSignature };
+//# sourceMappingURL=createMethodSignature.mjs.map

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,34 @@
+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.
+ *
+ * Any modifiers print first (for example `readonly`), then the name, then a `?`
+ * when the question token is present, then `: ` followed by the type when
+ * present. A string name is normalized to a property name node.
+ *
+ * Given the name `name`, a present question token, and a `string` type, the
+ * printer renders:
+ *
+ * ```ts
+ * name?: string
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The property name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param type The property type, if any.
+ * @returns The created {@link PropertySignature}.
+ */
+const createPropertySignature = (modifiers, name, questionToken, type) => make("PropertySignature", {
+    modifiers,
+    name: asPropertyName(name),
+    questionToken,
+    type,
+});
+
+export { createPropertySignature };
+//# sourceMappingURL=createPropertySignature.mjs.map

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

@@ -0,0 +1 @@
+{"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;;;;"}