@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/statements/createReturnStatement.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ReturnStatement}: a `return ...;` statement.
+ *
+ * The optional `expression` is the value handed back to the caller. Omit it for
+ * a bare `return;` that yields `undefined`.
+ *
+ * With no expression the result is:
+ *
+ * ```ts
+ * return;
+ * ```
+ *
+ * With an `expression` of `value` the result is:
+ *
+ * ```ts
+ * return value;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link ReturnStatement}.
+ */
+const createReturnStatement = (expression) => make("ReturnStatement", { expression });
+
+export { createReturnStatement };
+//# sourceMappingURL=createReturnStatement.mjs.map

package/lib/factory/statements/createReturnStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createReturnStatement.mjs","sources":["../../../src/factory/statements/createReturnStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAuB,KACH,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createSwitchStatement.mjs

@@ -0,0 +1,31 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SwitchStatement}: a `switch (...) { ... }` statement.
+ *
+ * The `expression` is the subject compared against each arm, and `caseBlock` is
+ * the braced body of `case` and `default` clauses, built with
+ * {@link createCaseBlock}.
+ *
+ * With `expression` of `x` and a `caseBlock` holding a `case 1:` arm (calling
+ * `a()` then `break`) and a `default:` arm (calling `b()`), the result is:
+ *
+ * ```ts
+ * switch (x) {
+ *   case 1:
+ *     a();
+ *     break;
+ *   default:
+ *     b();
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @param caseBlock The caseBlock.
+ * @returns The created {@link SwitchStatement}.
+ */
+const createSwitchStatement = (expression, caseBlock) => make("SwitchStatement", { expression, caseBlock });
+
+export { createSwitchStatement };
+//# sourceMappingURL=createSwitchStatement.mjs.map

package/lib/factory/statements/createSwitchStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSwitchStatement.mjs","sources":["../../../src/factory/statements/createSwitchStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;MACU,qBAAqB,GAAG,CACnC,UAAsB,EACtB,SAAoB,KACA,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createThrowStatement.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ThrowStatement}: a `throw ...;` statement.
+ *
+ * The `expression` is the value raised, commonly a freshly constructed error.
+ * Unlike `return`, the expression is required.
+ *
+ * With an `expression` of `new Error("oops")`, the result is:
+ *
+ * ```ts
+ * throw new Error("oops");
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @returns The created {@link ThrowStatement}.
+ */
+const createThrowStatement = (expression) => make("ThrowStatement", { expression });
+
+export { createThrowStatement };
+//# sourceMappingURL=createThrowStatement.mjs.map

package/lib/factory/statements/createThrowStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createThrowStatement.mjs","sources":["../../../src/factory/statements/createThrowStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,oBAAoB,GAAG,CAAC,UAAsB,KACzD,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/statements/createTryStatement.mjs

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TryStatement}: a `try { ... } catch { ... } finally { ... }`
+ * statement.
+ *
+ * The `tryBlock` is the guarded body. The `catchClause` and `finallyBlock` are
+ * both optional, but at least one must be present for valid TypeScript: pass
+ * `undefined` for `catchClause` to emit a `try`/`finally`, or `undefined` for
+ * `finallyBlock` to emit a `try`/`catch`.
+ *
+ * With a `tryBlock` calling `risky()`, a `catchClause` binding `e` and calling
+ * `handle(e)`, and a `finallyBlock` calling `cleanup()`, the result is:
+ *
+ * ```ts
+ * try {
+ *   risky();
+ * } catch (e) {
+ *   handle(e);
+ * } finally {
+ *   cleanup();
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tryBlock The tryBlock.
+ * @param catchClause The catchClause.
+ * @param finallyBlock The finallyBlock.
+ * @returns The created {@link TryStatement}.
+ */
+const createTryStatement = (tryBlock, catchClause, finallyBlock) => make("TryStatement", { tryBlock, catchClause, finallyBlock });
+
+export { createTryStatement };
+//# sourceMappingURL=createTryStatement.mjs.map

package/lib/factory/statements/createTryStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTryStatement.mjs","sources":["../../../src/factory/statements/createTryStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;AACI,MAAM,kBAAkB,GAAG,CAChC,QAAe,EACf,WAAoC,EACpC,YAA+B,KAE/B,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE;;;;"}

package/lib/factory/statements/createVariableDeclaration.mjs

@@ -0,0 +1,38 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link VariableDeclaration}: one `name = value` binding.
+ *
+ * The `name` is the binding target; a string becomes an identifier, while a
+ * {@link BindingName} allows array or object destructuring such as `[a, b]`. The
+ * `exclamationToken` adds the definite-assignment `!`, `type` adds a `: T`
+ * annotation, and `initializer` adds `= value`. Each of those three is
+ * optional.
+ *
+ * This node is a single declarator, not a full statement: it carries no `const`
+ * / `let` / `var` keyword (that lives on the enclosing
+ * {@link VariableDeclarationList}) and no trailing semicolon. With a `name` of
+ * `x` and an `initializer` of `1`, it prints as:
+ *
+ * ```ts
+ * x = 1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name; a {@link BindingName} allows array / object
+ *   destructuring (e.g. `const [a, b] = ...`).
+ * @param exclamationToken The definite-assignment marker (`!`), if any.
+ * @param type The type.
+ * @param initializer The initializer, if any.
+ * @returns The created {@link VariableDeclaration}.
+ */
+const createVariableDeclaration = (name, exclamationToken, type, initializer) => make("VariableDeclaration", {
+    name: typeof name === "string" ? createIdentifier(name) : name,
+    exclamationToken,
+    type,
+    initializer,
+});
+
+export { createVariableDeclaration };
+//# sourceMappingURL=createVariableDeclaration.mjs.map

package/lib/factory/statements/createVariableDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVariableDeclaration.mjs","sources":["../../../src/factory/statements/createVariableDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,yBAAyB,GAAG,CACvC,IAA0B,EAC1B,gBAAwB,EACxB,IAAe,EACf,WAAwB,KAExB,IAAI,CAAC,qBAAqB,EAAE;AAC1B,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAC9D,gBAAgB;IAChB,IAAI;IACJ,WAAW;AACZ,CAAA;;;;"}

package/lib/factory/statements/createVariableDeclarationList.mjs

@@ -0,0 +1,28 @@
+import '../../syntax/SyntaxKind.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link VariableDeclarationList}: the `const x = 1` group.
+ *
+ * The `declarations` are the comma-separated declarators, and `flags` chooses
+ * the keyword the printer emits: `const`, `let`, or plain `var` when no flag is
+ * set. This is the keyword-bearing part shared by a {@link VariableStatement}
+ * and by `for` loop headers.
+ *
+ * The list carries no trailing semicolon on its own. With a single declaration
+ * of `x = 1` and the `const` flag, it prints as:
+ *
+ * ```ts
+ * const x = 1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param declarations The declarations.
+ * @param flags The declaration flags (`const` / `let` / `var`).
+ * @returns The created {@link VariableDeclarationList}.
+ */
+const createVariableDeclarationList = (declarations, flags = NodeFlags.None) => make("VariableDeclarationList", { declarations, flags });
+
+export { createVariableDeclarationList };
+//# sourceMappingURL=createVariableDeclarationList.mjs.map

package/lib/factory/statements/createVariableDeclarationList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVariableDeclarationList.mjs","sources":["../../../src/factory/statements/createVariableDeclarationList.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,YAA4C,EAC5C,KAAA,GAAmB,SAAS,CAAC,IAAI,KAEjC,IAAI,CAAC,yBAAyB,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE;;;;"}

package/lib/factory/statements/createVariableStatement.mjs

@@ -0,0 +1,33 @@
+import { make } from '../internal/make.mjs';
+import { createVariableDeclarationList } from './createVariableDeclarationList.mjs';
+
+/**
+ * Create a {@link VariableStatement}: a full `const x = 1;` statement.
+ *
+ * The optional `modifiers` are leading keywords such as `export` or `declare`.
+ * The `declarationList` carries the keyword and declarators; pass a
+ * {@link VariableDeclarationList} directly, or pass a plain array of
+ * declarations and it is wrapped into a list for you (defaulting to `var`, so
+ * build the list yourself when you need `const` or `let`).
+ *
+ * This is the statement-level wrapper that adds the trailing semicolon. With no
+ * modifiers and a `const` declaration list of `x = 1`, the result is:
+ *
+ * ```ts
+ * const x = 1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param declarationList The declaration list.
+ * @returns The created {@link VariableStatement}.
+ */
+const createVariableStatement = (modifiers, declarationList) => make("VariableStatement", {
+    modifiers,
+    declarationList: Array.isArray(declarationList)
+        ? createVariableDeclarationList(declarationList)
+        : declarationList,
+});
+
+export { createVariableStatement };
+//# sourceMappingURL=createVariableStatement.mjs.map

package/lib/factory/statements/createVariableStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVariableStatement.mjs","sources":["../../../src/factory/statements/createVariableStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,eAAyE,KAEzE,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,eAAe;AAC5C,UAAE,6BAA6B,CAC3B,eAAiD;AAErD,UAAG,eAA2C;AACjD,CAAA;;;;"}

package/lib/factory/statements/createWhileStatement.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link WhileStatement}: a `while (...) ...` loop.
+ *
+ * The `expression` is the condition tested before each pass and `statement` is
+ * the loop body. The body runs zero or more times, only while the condition
+ * holds.
+ *
+ * With an `expression` of `cond` and a `statement` block calling `a()`, the
+ * result is:
+ *
+ * ```ts
+ * while (cond) {
+ *   a();
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @param statement The statement.
+ * @returns The created {@link WhileStatement}.
+ */
+const createWhileStatement = (expression, statement) => make("WhileStatement", { expression, statement });
+
+export { createWhileStatement };
+//# sourceMappingURL=createWhileStatement.mjs.map

package/lib/factory/statements/createWhileStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWhileStatement.mjs","sources":["../../../src/factory/statements/createWhileStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,oBAAoB,GAAG,CAClC,UAAsB,EACtB,SAAoB,KACD,IAAI,CAAC,gBAAgB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/statements/createWithStatement.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link WithStatement}: a `with (...) ...` statement.
+ *
+ * The `expression` supplies the object whose properties join the scope of
+ * `statement`, the body. `with` is disallowed in strict mode and in ES modules,
+ * so this exists mainly for completeness and faithful round-tripping.
+ *
+ * With an `expression` of `obj` and a `statement` block calling `a()`, the
+ * result is:
+ *
+ * ```ts
+ * with (obj) {
+ *   a();
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression.
+ * @param statement The statement.
+ * @returns The created {@link WithStatement}.
+ */
+const createWithStatement = (expression, statement) => make("WithStatement", { expression, statement });
+
+export { createWithStatement };
+//# sourceMappingURL=createWithStatement.mjs.map

package/lib/factory/statements/createWithStatement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createWithStatement.mjs","sources":["../../../src/factory/statements/createWithStatement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,mBAAmB,GAAG,CACjC,UAAsB,EACtB,SAAoB,KACF,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/types/createArrayTypeNode.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ArrayTypeNode}: a `T[]` postfix array type.
+ *
+ * The element type is emitted in postfix-operand position, so a
+ * lower-precedence form that would otherwise re-associate gets wrapped in
+ * parentheses first. A union, intersection, function, constructor, conditional,
+ * infer, or type-operator element prints as `(...)[]`; anything else prints
+ * bare.
+ *
+ * Given a `string` element, the printer renders:
+ *
+ * ```ts
+ * string[]
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elementType The element type.
+ * @returns The created {@link ArrayTypeNode}.
+ */
+const createArrayTypeNode = (elementType) => make("ArrayTypeNode", { elementType });
+
+export { createArrayTypeNode };
+//# sourceMappingURL=createArrayTypeNode.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createArrayTypeNode.mjs","sources":["../../../src/factory/types/createArrayTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,mBAAmB,GAAG,CAAC,WAAqB,KACvD,IAAI,CAAC,eAAe,EAAE,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/types/createCallSignature.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link CallSignature}: a `(params): ReturnType` call signature for an
+ * interface or type literal.
+ *
+ * Optional type parameters print first as `<...>`, then the parameter list,
+ * then the return type as `: Type` when present.
+ *
+ * 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, if any.
+ * @returns The created {@link CallSignature}.
+ */
+const createCallSignature = (typeParameters, parameters, type) => make("CallSignature", { typeParameters, parameters, type });
+
+export { createCallSignature };
+//# sourceMappingURL=createCallSignature.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCallSignature.mjs","sources":["../../../src/factory/types/createCallSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,eAAe,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/types/createConditionalTypeNode.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createConditionalTypeNode.mjs","sources":["../../../src/factory/types/createConditionalTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAAmB,EACnB,WAAqB,EACrB,QAAkB,EAClB,SAAmB,KAEnB,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

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":["../../../src/factory/types/createConstructSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,wBAAwB,GAAG,CACtC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,KAE1B,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":["../../../src/factory/types/createConstructorTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,yBAAyB,GAAG,CACvC,SAA0C,EAC1C,cAA+D,EAC/D,UAA2C,EAC3C,IAAc,KAEd,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":["../../../src/factory/types/createExpressionWithTypeArguments.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;AAkBG;MACU,iCAAiC,GAAG,CAC/C,UAAsB,EACtB,aAA8C,KAE9C,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":["../../../src/factory/types/createFunctionTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,sBAAsB,GAAG,CACpC,cAA+D,EAC/D,UAA2C,EAC3C,IAAc,KAEd,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":["../../../src/factory/types/createImportTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,oBAAoB,GAAG,CAClC,QAAkB,EAClB,SAAsB,EACtB,aAAmC,EACnC,QAAA,GAAoB,KAAK,KAEzB,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":["../../../src/factory/types/createIndexSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,SAA8C,EAC9C,UAA2C,EAC3C,IAAc,KAEd,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":["../../../src/factory/types/createIndexedAccessTypeNode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,2BAA2B,GAAG,CACzC,UAAoB,EACpB,SAAmB,KAEnB,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