@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/declarations/createSetAccessorDeclaration.mjs

@@ -0,0 +1,37 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SetAccessorDeclaration}: a `set x(value) { ... }` accessor.
+ *
+ * The `modifiers` precede the `set` keyword, so a `public` modifier prints
+ * `public set`. The `name` is the accessor key. A setter takes exactly one
+ * value parameter, supplied through `parameters`, and has no return type. The
+ * `body` block holds the statements, indented one per line.
+ *
+ * Given a `public` modifier, the name `value`, a single `value: number`
+ * parameter, and a body assigning `this._value = value`, the printed accessor
+ * is:
+ *
+ * ```ts
+ * public set value(value: number) {
+ *   this._value = value;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param parameters The parameters.
+ * @param body The body.
+ * @returns The created {@link SetAccessorDeclaration}.
+ */
+const createSetAccessorDeclaration = (modifiers, name, parameters, body) => make("SetAccessorDeclaration", {
+    modifiers,
+    name: asPropertyName(name),
+    parameters,
+    body,
+});
+
+export { createSetAccessorDeclaration };
+//# sourceMappingURL=createSetAccessorDeclaration.mjs.map

package/lib/factory/declarations/createSetAccessorDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSetAccessorDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createSetAccessorDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link SetAccessorDeclaration}: a `set x(value) { ... }` accessor.\n *\n * The `modifiers` precede the `set` keyword, so a `public` modifier prints\n * `public set`. The `name` is the accessor key. A setter takes exactly one\n * value parameter, supplied through `parameters`, and has no return type. The\n * `body` block holds the statements, indented one per line.\n *\n * Given a `public` modifier, the name `value`, a single `value: number`\n * parameter, and a body assigning `this._value = value`, the printed accessor\n * is:\n *\n * ```ts\n * public set value(value: number) {\n *   this._value = value;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param parameters The parameters.\n * @param body The body.\n * @returns The created {@link SetAccessorDeclaration}.\n */\nexport const createSetAccessorDeclaration = (modifiers, name, parameters, body) => make(\"SetAccessorDeclaration\", {\n    modifiers,\n    name: asPropertyName(name),\n    parameters,\n    body,\n});\n//# sourceMappingURL=createSetAccessorDeclaration.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,4BAA4B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,wBAAwB,EAAE;AAClH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/declarations/createTypeAliasDeclaration.mjs

@@ -0,0 +1,35 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeAliasDeclaration}: a `type X = ...;`.
+ *
+ * The `modifiers` precede the `type` keyword, so an `export` modifier prints
+ * `export type`. The `name` accepts a string or identifier, and
+ * `typeParameters` add the generic `<...>` list when present. The `type` is the
+ * aliased type printed after the `=`, and the printer terminates the statement
+ * with a semicolon.
+ *
+ * Given an `export` modifier, the name `ID`, and a `string` type, the printed
+ * declaration is:
+ *
+ * ```ts
+ * export type ID = string;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param typeParameters The generic type parameters, if any.
+ * @param type The type.
+ * @returns The created {@link TypeAliasDeclaration}.
+ */
+const createTypeAliasDeclaration = (modifiers, name, typeParameters, type) => make("TypeAliasDeclaration", {
+    modifiers,
+    name: asName(name),
+    typeParameters,
+    type,
+});
+
+export { createTypeAliasDeclaration };
+//# sourceMappingURL=createTypeAliasDeclaration.mjs.map

package/lib/factory/declarations/createTypeAliasDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeAliasDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createTypeAliasDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link TypeAliasDeclaration}: a `type X = ...;`.\n *\n * The `modifiers` precede the `type` keyword, so an `export` modifier prints\n * `export type`. The `name` accepts a string or identifier, and\n * `typeParameters` add the generic `<...>` list when present. The `type` is the\n * aliased type printed after the `=`, and the printer terminates the statement\n * with a semicolon.\n *\n * Given an `export` modifier, the name `ID`, and a `string` type, the printed\n * declaration is:\n *\n * ```ts\n * export type ID = 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 name.\n * @param typeParameters The generic type parameters, if any.\n * @param type The type.\n * @returns The created {@link TypeAliasDeclaration}.\n */\nexport const createTypeAliasDeclaration = (modifiers, name, typeParameters, type) => make(\"TypeAliasDeclaration\", {\n    modifiers,\n    name: asName(name),\n    typeParameters,\n    type,\n});\n//# sourceMappingURL=createTypeAliasDeclaration.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;AACY,MAAC,0BAA0B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,KAAK,IAAI,CAAC,sBAAsB,EAAE;AAClH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,cAAc;AAClB,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/expressions/createAdd.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `+` operator: addition or string
+ * concatenation.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `PlusToken` operator.
+ * The printer surrounds the operator with a single space on each side.
+ *
+ * Given operands `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * a + b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createAdd = (left, right) => createBinaryExpression(left, SyntaxKind.PlusToken, right);
+
+export { createAdd };
+//# sourceMappingURL=createAdd.mjs.map

package/lib/factory/expressions/createAdd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdd.mjs","sources":["../../../esm-tmp/factory/expressions/createAdd.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `+` operator: addition or string\n * concatenation.\n *\n * Shorthand for {@link createBinaryExpression} with the `PlusToken` operator.\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a` and `b`, the printer emits:\n *\n * ```ts\n * a + b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createAdd = (left, right) => createBinaryExpression(left, SyntaxKind.PlusToken, right);\n//# sourceMappingURL=createAdd.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,SAAS,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createArrayBindingPattern.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ArrayBindingPattern}: the `[a, b]` binding used in array
+ * destructuring.
+ *
+ * The elements are {@link BindingElement} nodes or omitted-element holes. The
+ * printer wraps them in square brackets, separated by a comma and a space.
+ *
+ * Given two binding elements named `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * [a, b];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The binding elements.
+ * @returns The created {@link ArrayBindingPattern}.
+ */
+const createArrayBindingPattern = (elements) => make("ArrayBindingPattern", { elements });
+
+export { createArrayBindingPattern };
+//# sourceMappingURL=createArrayBindingPattern.mjs.map

package/lib/factory/expressions/createArrayBindingPattern.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createArrayBindingPattern.mjs","sources":["../../../esm-tmp/factory/expressions/createArrayBindingPattern.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayBindingPattern}: the `[a, b]` binding used in array\n * destructuring.\n *\n * The elements are {@link BindingElement} nodes or omitted-element holes. The\n * printer wraps them in square brackets, separated by a comma and a space.\n *\n * Given two binding elements named `a` and `b`, the printer emits:\n *\n * ```ts\n * [a, b];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The binding elements.\n * @returns The created {@link ArrayBindingPattern}.\n */\nexport const createArrayBindingPattern = (elements) => make(\"ArrayBindingPattern\", { elements });\n//# sourceMappingURL=createArrayBindingPattern.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createArrayLiteralExpression.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ArrayLiteralExpression}: an `[...]` array literal.
+ *
+ * The elements may include {@link SpreadElement} and omitted holes. When
+ * `multiLine` is `false` (the default) the printer keeps the array on one line
+ * with comma-and-space separators. When `multiLine` is `true` it places each
+ * element on its own indented line and appends a trailing comma.
+ *
+ * Given elements `1`, `2`, `3` on a single line, the printer emits:
+ *
+ * ```ts
+ * [1, 2, 3];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The element expressions.
+ * @param multiLine When `true`, print one entry per line.
+ * @returns The created {@link ArrayLiteralExpression}.
+ */
+const createArrayLiteralExpression = (elements = [], multiLine) => make("ArrayLiteralExpression", { elements, multiLine });
+
+export { createArrayLiteralExpression };
+//# sourceMappingURL=createArrayLiteralExpression.mjs.map

package/lib/factory/expressions/createArrayLiteralExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createArrayLiteralExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createArrayLiteralExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayLiteralExpression}: an `[...]` array literal.\n *\n * The elements may include {@link SpreadElement} and omitted holes. When\n * `multiLine` is `false` (the default) the printer keeps the array on one line\n * with comma-and-space separators. When `multiLine` is `true` it places each\n * element on its own indented line and appends a trailing comma.\n *\n * Given elements `1`, `2`, `3` on a single line, the printer emits:\n *\n * ```ts\n * [1, 2, 3];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The element expressions.\n * @param multiLine When `true`, print one entry per line.\n * @returns The created {@link ArrayLiteralExpression}.\n */\nexport const createArrayLiteralExpression = (elements = [], multiLine) => make(\"ArrayLiteralExpression\", { elements, multiLine });\n//# sourceMappingURL=createArrayLiteralExpression.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,4BAA4B,GAAG,CAAC,QAAQ,GAAG,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC,wBAAwB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/expressions/createArrowFunction.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ArrowFunction}: a `(params) => body` arrow function.
+ *
+ * The `body` is either a {@link Block} for a statement body or an
+ * {@link Expression} for a concise body. The optional `modifiers`,
+ * `typeParameters` and return `type` are printed when present. The
+ * `_equalsGreaterThanToken` parameter exists only for signature parity with the
+ * legacy factory and is ignored: the printer always emits `=>` between the
+ * parameter list and the body.
+ *
+ * Given one parameter `x` and a concise body of `x`, the printer emits:
+ *
+ * ```ts
+ * (x) => x;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The return type, if any.
+ * @param _equalsGreaterThanToken Ignored; present only to mirror the legacy
+ *   signature.
+ * @param body The block or expression body.
+ * @returns The created {@link ArrowFunction}.
+ */
+const createArrowFunction = (modifiers, typeParameters, parameters, type, _equalsGreaterThanToken, body) => make("ArrowFunction", { modifiers, typeParameters, parameters, type, body });
+
+export { createArrowFunction };
+//# sourceMappingURL=createArrowFunction.mjs.map

package/lib/factory/expressions/createArrowFunction.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createArrowFunction.mjs","sources":["../../../esm-tmp/factory/expressions/createArrowFunction.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrowFunction}: a `(params) => body` arrow function.\n *\n * The `body` is either a {@link Block} for a statement body or an\n * {@link Expression} for a concise body. The optional `modifiers`,\n * `typeParameters` and return `type` are printed when present. The\n * `_equalsGreaterThanToken` parameter exists only for signature parity with the\n * legacy factory and is ignored: the printer always emits `=>` between the\n * parameter list and the body.\n *\n * Given one parameter `x` and a concise body of `x`, the printer emits:\n *\n * ```ts\n * (x) => x;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, 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 * @param _equalsGreaterThanToken Ignored; present only to mirror the legacy\n *   signature.\n * @param body The block or expression body.\n * @returns The created {@link ArrowFunction}.\n */\nexport const createArrowFunction = (modifiers, typeParameters, parameters, type, _equalsGreaterThanToken, body) => make(\"ArrowFunction\", { modifiers, typeParameters, parameters, type, body });\n//# sourceMappingURL=createArrowFunction.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;AACY,MAAC,mBAAmB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,uBAAuB,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createAsExpression.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link AsExpression}: a TypeScript `expression as type` assertion.
+ *
+ * The printer writes the expression, the `as` keyword and the target type, each
+ * separated by a single space.
+ *
+ * Given expression `value` and type `string`, the printer emits:
+ *
+ * ```ts
+ * value as string;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression being asserted.
+ * @param type The target type.
+ * @returns The created {@link AsExpression}.
+ */
+const createAsExpression = (expression, type) => make("AsExpression", { expression, type });
+
+export { createAsExpression };
+//# sourceMappingURL=createAsExpression.mjs.map

package/lib/factory/expressions/createAsExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAsExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createAsExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link AsExpression}: a TypeScript `expression as type` assertion.\n *\n * The printer writes the expression, the `as` keyword and the target type, each\n * separated by a single space.\n *\n * Given expression `value` and type `string`, the printer emits:\n *\n * ```ts\n * value as string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression being asserted.\n * @param type The target type.\n * @returns The created {@link AsExpression}.\n */\nexport const createAsExpression = (expression, type) => make(\"AsExpression\", { expression, type });\n//# sourceMappingURL=createAsExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createAssignment.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `=` operator: a simple assignment.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `EqualsToken` operator.
+ * The left operand is the assignment target and the right operand is the value.
+ * The printer surrounds the operator with a single space on each side.
+ *
+ * Given operands `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * a = b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The assignment target.
+ * @param right The value to assign.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createAssignment = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsToken, right);
+
+export { createAssignment };
+//# sourceMappingURL=createAssignment.mjs.map

package/lib/factory/expressions/createAssignment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAssignment.mjs","sources":["../../../esm-tmp/factory/expressions/createAssignment.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `=` operator: a simple assignment.\n *\n * Shorthand for {@link createBinaryExpression} with the `EqualsToken` operator.\n * The left operand is the assignment target and the right operand is the value.\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a` and `b`, the printer emits:\n *\n * ```ts\n * a = b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The assignment target.\n * @param right The value to assign.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createAssignment = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsToken, right);\n//# sourceMappingURL=createAssignment.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createAwaitExpression.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link AwaitExpression}: an `await` of an operand.
+ *
+ * The printer writes the `await` keyword followed by a single space and the
+ * operand expression.
+ *
+ * Given operand `promise`, the printer emits:
+ *
+ * ```ts
+ * await promise;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The awaited expression.
+ * @returns The created {@link AwaitExpression}.
+ */
+const createAwaitExpression = (expression) => make("AwaitExpression", { expression });
+
+export { createAwaitExpression };
+//# sourceMappingURL=createAwaitExpression.mjs.map

package/lib/factory/expressions/createAwaitExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAwaitExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createAwaitExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link AwaitExpression}: an `await` of an operand.\n *\n * The printer writes the `await` keyword followed by a single space and the\n * operand expression.\n *\n * Given operand `promise`, the printer emits:\n *\n * ```ts\n * await promise;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The awaited expression.\n * @returns The created {@link AwaitExpression}.\n */\nexport const createAwaitExpression = (expression) => make(\"AwaitExpression\", { expression });\n//# sourceMappingURL=createAwaitExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createBinaryExpression.mjs

@@ -0,0 +1,33 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link BinaryExpression}: two operands joined by an infix operator.
+ *
+ * The operator may be given as a `SyntaxKind` string (e.g. `"+"`, `"==="`,
+ * `"&&"`) or as an operator {@link Token}, in which case its `token` value is
+ * used. This is the base builder behind the operator-specific shorthands such
+ * as {@link createAdd}, {@link createStrictEquality} and
+ * {@link createLogicalAnd}.
+ *
+ * The printer surrounds the operator with a single space on each side.
+ *
+ * Given operands `a`, `b` and the `+` operator, the printer emits:
+ *
+ * ```ts
+ * a + b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param operator The operator token or its `SyntaxKind`.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createBinaryExpression = (left, operator, right) => make("BinaryExpression", {
+    left,
+    operator: typeof operator === "object" ? operator.token : operator,
+    right,
+});
+
+export { createBinaryExpression };
+//# sourceMappingURL=createBinaryExpression.mjs.map

package/lib/factory/expressions/createBinaryExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBinaryExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createBinaryExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link BinaryExpression}: two operands joined by an infix operator.\n *\n * The operator may be given as a `SyntaxKind` string (e.g. `\"+\"`, `\"===\"`,\n * `\"&&\"`) or as an operator {@link Token}, in which case its `token` value is\n * used. This is the base builder behind the operator-specific shorthands such\n * as {@link createAdd}, {@link createStrictEquality} and\n * {@link createLogicalAnd}.\n *\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a`, `b` and the `+` operator, the printer emits:\n *\n * ```ts\n * a + b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param operator The operator token or its `SyntaxKind`.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createBinaryExpression = (left, operator, right) => make(\"BinaryExpression\", {\n    left,\n    operator: typeof operator === \"object\" ? operator.token : operator,\n    right,\n});\n//# sourceMappingURL=createBinaryExpression.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;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC1F,IAAI,IAAI;AACR,IAAI,QAAQ,EAAE,OAAO,QAAQ,KAAK,QAAQ,GAAG,QAAQ,CAAC,KAAK,GAAG,QAAQ;AACtE,IAAI,KAAK;AACT,CAAC;;;;"}

package/lib/factory/expressions/createBindingElement.mjs

@@ -0,0 +1,39 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link BindingElement}: one entry of an array or object binding
+ * pattern.
+ *
+ * A `dotDotDotToken` marks a rest element. A `propertyName` (accepted as a
+ * string or {@link PropertyName}, normalized with {@link asPropertyName}) maps a
+ * source property to a different local `name`. A string `name` is wrapped with
+ * {@link createIdentifier}. An `initializer` supplies a default value.
+ *
+ * The printer renders the parts as `...`, `propertyName: name` and `= default`,
+ * each present only when supplied. A plain element named `a` prints as `a`;
+ * with an initializer `def` it prints as `c = def`; a rest element named `rest`
+ * prints as `...rest`. With a property name `src` mapping to local `dst` it
+ * prints:
+ *
+ * ```ts
+ * src: dst;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param dotDotDotToken The rest token, if this is a rest element.
+ * @param propertyName The source property name, if renamed.
+ * @param name The local binding name.
+ * @param initializer The default-value initializer, if any.
+ * @returns The created {@link BindingElement}.
+ */
+const createBindingElement = (dotDotDotToken, propertyName, name, initializer) => make("BindingElement", {
+    dotDotDotToken,
+    propertyName: propertyName === undefined ? undefined : asPropertyName(propertyName),
+    name: typeof name === "string" ? createIdentifier(name) : name,
+    initializer,
+});
+
+export { createBindingElement };
+//# sourceMappingURL=createBindingElement.mjs.map

package/lib/factory/expressions/createBindingElement.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBindingElement.mjs","sources":["../../../esm-tmp/factory/expressions/createBindingElement.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link BindingElement}: one entry of an array or object binding\n * pattern.\n *\n * A `dotDotDotToken` marks a rest element. A `propertyName` (accepted as a\n * string or {@link PropertyName}, normalized with {@link asPropertyName}) maps a\n * source property to a different local `name`. A string `name` is wrapped with\n * {@link createIdentifier}. An `initializer` supplies a default value.\n *\n * The printer renders the parts as `...`, `propertyName: name` and `= default`,\n * each present only when supplied. A plain element named `a` prints as `a`;\n * with an initializer `def` it prints as `c = def`; a rest element named `rest`\n * prints as `...rest`. With a property name `src` mapping to local `dst` it\n * prints:\n *\n * ```ts\n * src: dst;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The rest token, if this is a rest element.\n * @param propertyName The source property name, if renamed.\n * @param name The local binding name.\n * @param initializer The default-value initializer, if any.\n * @returns The created {@link BindingElement}.\n */\nexport const createBindingElement = (dotDotDotToken, propertyName, name, initializer) => make(\"BindingElement\", {\n    dotDotDotToken,\n    propertyName: propertyName === undefined ? undefined : asPropertyName(propertyName),\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n    initializer,\n});\n//# sourceMappingURL=createBindingElement.js.map"],"names":[],"mappings":";;;;AAGA;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,cAAc,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAChH,IAAI,cAAc;AAClB,IAAI,YAAY,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,cAAc,CAAC,YAAY,CAAC;AACvF,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,IAAI,WAAW;AACf,CAAC;;;;"}

package/lib/factory/expressions/createBitwiseAnd.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `&` operator: bitwise AND.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `AmpersandToken`
+ * operator. The printer surrounds the operator with a single space on each
+ * side.
+ *
+ * Given operands `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * a & b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createBitwiseAnd = (left, right) => createBinaryExpression(left, SyntaxKind.AmpersandToken, right);
+
+export { createBitwiseAnd };
+//# sourceMappingURL=createBitwiseAnd.mjs.map

package/lib/factory/expressions/createBitwiseAnd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBitwiseAnd.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseAnd.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `&` operator: bitwise AND.\n *\n * Shorthand for {@link createBinaryExpression} with the `AmpersandToken`\n * operator. The printer surrounds the operator with a single space on each\n * side.\n *\n * Given operands `a` and `b`, the printer emits:\n *\n * ```ts\n * a & b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createBitwiseAnd = (left, right) => createBinaryExpression(left, SyntaxKind.AmpersandToken, right);\n//# sourceMappingURL=createBitwiseAnd.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,cAAc,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createBitwiseNot.mjs

@@ -0,0 +1,24 @@
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link PrefixUnaryExpression} with the `~` operator: bitwise NOT.
+ *
+ * Shorthand for {@link createPrefixUnaryExpression} with the `TildeToken`
+ * operator. The printer writes the operator directly before the operand with no
+ * separating space.
+ *
+ * Given operand `a`, the printer emits:
+ *
+ * ```ts
+ * ~a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to negate.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createBitwiseNot = (operand) => createPrefixUnaryExpression(SyntaxKind.TildeToken, operand);
+
+export { createBitwiseNot };
+//# sourceMappingURL=createBitwiseNot.mjs.map

package/lib/factory/expressions/createBitwiseNot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBitwiseNot.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseNot.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a {@link PrefixUnaryExpression} with the `~` operator: bitwise NOT.\n *\n * Shorthand for {@link createPrefixUnaryExpression} with the `TildeToken`\n * operator. The printer writes the operator directly before the operand with no\n * separating space.\n *\n * Given operand `a`, the printer emits:\n *\n * ```ts\n * ~a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to negate.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createBitwiseNot = (operand) => createPrefixUnaryExpression(SyntaxKind.TildeToken, operand);\n//# sourceMappingURL=createBitwiseNot.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createBitwiseOr.mjs

@@ -0,0 +1,24 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `|` operator: bitwise OR.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `BarToken` operator. The
+ * printer surrounds the operator with a single space on each side.
+ *
+ * Given operands `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * a | b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createBitwiseOr = (left, right) => createBinaryExpression(left, SyntaxKind.BarToken, right);
+
+export { createBitwiseOr };
+//# sourceMappingURL=createBitwiseOr.mjs.map

package/lib/factory/expressions/createBitwiseOr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBitwiseOr.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseOr.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `|` operator: bitwise OR.\n *\n * Shorthand for {@link createBinaryExpression} with the `BarToken` operator. The\n * printer surrounds the operator with a single space on each side.\n *\n * Given operands `a` and `b`, the printer emits:\n *\n * ```ts\n * a | b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createBitwiseOr = (left, right) => createBinaryExpression(left, SyntaxKind.BarToken, right);\n//# sourceMappingURL=createBitwiseOr.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createBitwiseXor.mjs

@@ -0,0 +1,24 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `^` operator: bitwise XOR.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `CaretToken` operator.
+ * The printer surrounds the operator with a single space on each side.
+ *
+ * Given operands `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * a ^ b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand operand.
+ * @param right The right-hand operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createBitwiseXor = (left, right) => createBinaryExpression(left, SyntaxKind.CaretToken, right);
+
+export { createBitwiseXor };
+//# sourceMappingURL=createBitwiseXor.mjs.map

package/lib/factory/expressions/createBitwiseXor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createBitwiseXor.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseXor.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `^` operator: bitwise XOR.\n *\n * Shorthand for {@link createBinaryExpression} with the `CaretToken` operator.\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a` and `b`, the printer emits:\n *\n * ```ts\n * a ^ b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand operand.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createBitwiseXor = (left, right) => createBinaryExpression(left, SyntaxKind.CaretToken, right);\n//# sourceMappingURL=createBitwiseXor.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createCallChain.mjs

@@ -0,0 +1,35 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link CallChain}: a call that participates in an optional chain.
+ *
+ * The `questionDotToken` is the `?.` token. When it sits directly before the
+ * argument list the printer emits an optional call `fn?.(args)`; when the
+ * callee is a property-access chain the `?.` appears at that link and the call
+ * itself uses plain parentheses. The optional `typeArguments` are printed in
+ * `<...>` before the arguments, and a missing `argumentsArray` is treated as an
+ * empty list.
+ *
+ * Given a property-access chain `obj?.fn` and one argument `a`, the printer
+ * emits:
+ *
+ * ```ts
+ * obj?.fn(a);
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The callee expression.
+ * @param questionDotToken The `?.` token, if the call link is optional.
+ * @param typeArguments The generic type arguments, if any.
+ * @param argumentsArray The call arguments.
+ * @returns The created {@link CallChain}.
+ */
+const createCallChain = (expression, questionDotToken, typeArguments, argumentsArray) => make("CallChain", {
+    expression,
+    questionDotToken,
+    typeArguments,
+    arguments: argumentsArray ?? [],
+});
+
+export { createCallChain };
+//# sourceMappingURL=createCallChain.mjs.map

package/lib/factory/expressions/createCallChain.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCallChain.mjs","sources":["../../../esm-tmp/factory/expressions/createCallChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallChain}: a call that participates in an optional chain.\n *\n * The `questionDotToken` is the `?.` token. When it sits directly before the\n * argument list the printer emits an optional call `fn?.(args)`; when the\n * callee is a property-access chain the `?.` appears at that link and the call\n * itself uses plain parentheses. The optional `typeArguments` are printed in\n * `<...>` before the arguments, and a missing `argumentsArray` is treated as an\n * empty list.\n *\n * Given a property-access chain `obj?.fn` and one argument `a`, the printer\n * emits:\n *\n * ```ts\n * obj?.fn(a);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The callee expression.\n * @param questionDotToken The `?.` token, if the call link is optional.\n * @param typeArguments The generic type arguments, if any.\n * @param argumentsArray The call arguments.\n * @returns The created {@link CallChain}.\n */\nexport const createCallChain = (expression, questionDotToken, typeArguments, argumentsArray) => make(\"CallChain\", {\n    expression,\n    questionDotToken,\n    typeArguments,\n    arguments: argumentsArray ?? [],\n});\n//# sourceMappingURL=createCallChain.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;AACY,MAAC,eAAe,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC,WAAW,EAAE;AAClH,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc,IAAI,EAAE;AACnC,CAAC;;;;"}

package/lib/factory/expressions/createCallExpression.mjs

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link CallExpression}: a function or method call.
+ *
+ * The optional `typeArguments` are printed in `<...>` before the argument list.
+ * The arguments are printed comma separated inside the parentheses, and a
+ * missing `argumentsArray` is treated as an empty list.
+ *
+ * Given callee `fn` and arguments `a`, `b`, the printer emits:
+ *
+ * ```ts
+ * fn(a, b);
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The callee expression.
+ * @param typeArguments The generic type arguments, if any.
+ * @param argumentsArray The call arguments.
+ * @returns The created {@link CallExpression}.
+ */
+const createCallExpression = (expression, typeArguments, argumentsArray) => make("CallExpression", {
+    expression,
+    typeArguments,
+    arguments: argumentsArray ?? [],
+});
+
+export { createCallExpression };
+//# sourceMappingURL=createCallExpression.mjs.map

package/lib/factory/expressions/createCallExpression.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCallExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createCallExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallExpression}: a function or method call.\n *\n * The optional `typeArguments` are printed in `<...>` before the argument list.\n * The arguments are printed comma separated inside the parentheses, and a\n * missing `argumentsArray` is treated as an empty list.\n *\n * Given callee `fn` and arguments `a`, `b`, the printer emits:\n *\n * ```ts\n * fn(a, b);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The callee expression.\n * @param typeArguments The generic type arguments, if any.\n * @param argumentsArray The call arguments.\n * @returns The created {@link CallExpression}.\n */\nexport const createCallExpression = (expression, typeArguments, argumentsArray) => make(\"CallExpression\", {\n    expression,\n    typeArguments,\n    arguments: argumentsArray ?? [],\n});\n//# sourceMappingURL=createCallExpression.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,UAAU,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAC1G,IAAI,UAAU;AACd,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc,IAAI,EAAE;AACnC,CAAC;;;;"}

package/lib/factory/expressions/createClassExpression.mjs

@@ -0,0 +1,34 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ClassExpression}: a `class` used as an expression.
+ *
+ * A string `name` is normalized with {@link asName}; the name is optional, as
+ * are the `modifiers`, `typeParameters` and `heritageClauses` (the `extends` /
+ * `implements` clauses). The `members` are printed inside the class body.
+ *
+ * Given name `C` and no members, the printer emits:
+ *
+ * ```ts
+ * class C {}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers, if any.
+ * @param name The class name, if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param heritageClauses The extends and implements clauses, if any.
+ * @param members The class members.
+ * @returns The created {@link ClassExpression}.
+ */
+const createClassExpression = (modifiers, name, typeParameters, heritageClauses, members) => make("ClassExpression", {
+    modifiers,
+    name: name === undefined ? undefined : asName(name),
+    typeParameters,
+    heritageClauses,
+    members,
+});
+
+export { createClassExpression };
+//# sourceMappingURL=createClassExpression.mjs.map