@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/declarations/createImportEqualsDeclaration.mjs

@@ -0,0 +1,35 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportEqualsDeclaration}: an `import x = ...` statement.
+ *
+ * The `modifiers` precede the `import` keyword, so an `export` modifier prints
+ * `export import`. When `isTypeOnly` is true the printer inserts the `type`
+ * keyword to make it a type-only import. The `name` is the local binding, and
+ * `moduleReference` is the right-hand side, either an external module reference
+ * such as `require("...")` or an entity name for an aliased namespace.
+ *
+ * Given an `export` modifier, `isTypeOnly` of false, the name `app`, and a
+ * `require("./app")` module reference, the printed statement is:
+ *
+ * ```ts
+ * export import app = require("./app");
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers, if any.
+ * @param isTypeOnly Whether the import is type-only (`import type`).
+ * @param name The local binding name.
+ * @param moduleReference The right-hand side module or entity reference.
+ * @returns The created {@link ImportEqualsDeclaration}.
+ */
+const createImportEqualsDeclaration = (modifiers, isTypeOnly, name, moduleReference) => make("ImportEqualsDeclaration", {
+    modifiers,
+    isTypeOnly,
+    name: asName(name),
+    moduleReference,
+});
+
+export { createImportEqualsDeclaration };
+//# sourceMappingURL=createImportEqualsDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createImportEqualsDeclaration.mjs","sources":["../../../src/factory/declarations/createImportEqualsDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,SAA8C,EAC9C,UAAmB,EACnB,IAAyB,EACzB,eAAgC,KAEhC,IAAI,CAAC,yBAAyB,EAAE;IAC9B,SAAS;IACT,UAAU;AACV,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,eAAe;AAChB,CAAA;;;;"}

package/lib/factory/declarations/createInterfaceDeclaration.mjs

@@ -0,0 +1,40 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link InterfaceDeclaration}: an `interface X { ... }`.
+ *
+ * The `modifiers` are printed in front of the `interface` keyword, so passing
+ * an `export` modifier yields `export interface`. The `name` accepts a plain
+ * string or a prebuilt identifier, and `typeParameters` add the `<...>` generic
+ * list when present. The `heritageClauses` carry the `extends` clauses, while
+ * `members` become the body. The printer wraps the members in a brace block,
+ * one member per line, and emits an empty `{}` when there are none.
+ *
+ * Given an `export` modifier, the name `IBox`, and a single `value: number`
+ * member, the printed declaration is:
+ *
+ * ```ts
+ * export interface IBox {
+ *   value: number;
+ * }
+ * ```
+ *
+ * @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 heritageClauses The `extends` / `implements` clauses, if any.
+ * @param members The members.
+ * @returns The created {@link InterfaceDeclaration}.
+ */
+const createInterfaceDeclaration = (modifiers, name, typeParameters, heritageClauses, members) => make("InterfaceDeclaration", {
+    modifiers,
+    name: asName(name),
+    typeParameters,
+    heritageClauses,
+    members,
+});
+
+export { createInterfaceDeclaration };
+//# sourceMappingURL=createInterfaceDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createInterfaceDeclaration.mjs","sources":["../../../src/factory/declarations/createInterfaceDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;MACU,0BAA0B,GAAG,CACxC,SAA8C,EAC9C,IAAyB,EACzB,cAA+D,EAC/D,eAAsD,EACtD,OAA+B,KAE/B,IAAI,CAAC,sBAAsB,EAAE;IAC3B,SAAS;AACT,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,cAAc;IACd,eAAe;IACf,OAAO;AACR,CAAA;;;;"}

package/lib/factory/declarations/createMethodDeclaration.mjs

@@ -0,0 +1,50 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link MethodDeclaration}: a class method `m(...) { ... }`.
+ *
+ * The `modifiers` precede the method name, so a `public` modifier prints
+ * `public m`, and `static` or `async` print likewise. Any decorators among the
+ * modifiers are hoisted onto their own lines above the method. The
+ * `asteriskToken` marks a generator method (`*m`), and the `questionToken`
+ * marks an optional method (`m?`). The `name` is the method key, and
+ * `typeParameters` add the generic `<...>` list.
+ *
+ * The `parameters` print inside the parentheses, the optional return `type`
+ * follows after a colon, and the `body` block holds the statements, indented
+ * one per line.
+ *
+ * Given a `public` modifier, the name `greet`, a `name: string` parameter, a
+ * `string` return type, and a body returning `name`, the printed method is:
+ *
+ * ```ts
+ * public greet(name: string): string {
+ *   return name;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param asteriskToken The generator marker (`*`), if any.
+ * @param name The name.
+ * @param questionToken The optional marker (`?`), if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The type.
+ * @param body The body.
+ * @returns The created {@link MethodDeclaration}.
+ */
+const createMethodDeclaration = (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) => make("MethodDeclaration", {
+    modifiers,
+    asteriskToken,
+    name: asPropertyName(name),
+    questionToken,
+    typeParameters,
+    parameters,
+    type,
+    body,
+});
+
+export { createMethodDeclaration };
+//# sourceMappingURL=createMethodDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createMethodDeclaration.mjs","sources":["../../../src/factory/declarations/createMethodDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,aAAgC,EAChC,IAA2B,EAC3B,aAAgC,EAChC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAuB,KAEvB,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,aAAa;AACb,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,aAAa;IACb,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;AACL,CAAA;;;;"}

package/lib/factory/declarations/createModuleBlock.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ModuleBlock}: the `{ ... }` body of a namespace or module.
+ *
+ * This is the body that a {@link ModuleDeclaration} wraps in braces. The
+ * `statements` become its contents, which the printer indents one per line
+ * inside the braces.
+ *
+ * Given a single `export type ID = string;` statement, the printed block is:
+ *
+ * ```ts
+ * {
+ *   export type ID = string;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param statements The statements.
+ * @returns The created {@link ModuleBlock}.
+ */
+const createModuleBlock = (statements) => make("ModuleBlock", { statements });
+
+export { createModuleBlock };
+//# sourceMappingURL=createModuleBlock.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModuleBlock.mjs","sources":["../../../src/factory/declarations/createModuleBlock.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,UAAgC,KAChB,IAAI,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/declarations/createModuleDeclaration.mjs

@@ -0,0 +1,43 @@
+import '../../syntax/SyntaxKind.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link ModuleDeclaration}: a `namespace X { ... }` or `module X { ...
+ * }`.
+ *
+ * The `modifiers` precede the keyword, so an `export` modifier prints `export
+ * namespace`. The `name` accepts a string, which is wrapped in an identifier,
+ * or a prebuilt module name. The `body` is the brace block, normally a
+ * {@link ModuleBlock}, whose statements the printer indents one per line.
+ *
+ * The `flags` decide the keyword the printer emits: the `Namespace` flag prints
+ * `namespace`, while the default prints `module`. This is the one input that
+ * does not show up as text directly but changes the rendered keyword.
+ *
+ * Given an `export` modifier, the name `app`, a body holding `export type ID =
+ * string;`, and the `Namespace` flag, the printed declaration is:
+ *
+ * ```ts
+ * export namespace app {
+ *   export type ID = string;
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers, if any.
+ * @param name The name.
+ * @param body The body.
+ * @param flags The node flags that select the `namespace` or `module` keyword.
+ * @returns The created {@link ModuleDeclaration}.
+ */
+const createModuleDeclaration = (modifiers, name, body, flags = NodeFlags.None) => make("ModuleDeclaration", {
+    modifiers,
+    name: typeof name === "string" ? createIdentifier(name) : name,
+    body,
+    flags,
+});
+
+export { createModuleDeclaration };
+//# sourceMappingURL=createModuleDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModuleDeclaration.mjs","sources":["../../../src/factory/declarations/createModuleDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;MACU,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,IAAyB,EACzB,IAA4B,EAC5B,KAAA,GAAmB,SAAS,CAAC,IAAI,KAEjC,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAC9D,IAAI;IACJ,KAAK;AACN,CAAA;;;;"}

package/lib/factory/declarations/createNamespaceExportDeclaration.mjs

@@ -0,0 +1,24 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamespaceExportDeclaration}: an `export as namespace X;`.
+ *
+ * This is the UMD global declaration used in `.d.ts` files to state the global
+ * variable name under which the module is exposed in a script context. The
+ * `name` is that global identifier.
+ *
+ * Given the name `App`, the printed declaration is:
+ *
+ * ```ts
+ * export as namespace App;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @returns The created {@link NamespaceExportDeclaration}.
+ */
+const createNamespaceExportDeclaration = (name) => make("NamespaceExportDeclaration", { name: asName(name) });
+
+export { createNamespaceExportDeclaration };
+//# sourceMappingURL=createNamespaceExportDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNamespaceExportDeclaration.mjs","sources":["../../../src/factory/declarations/createNamespaceExportDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,gCAAgC,GAAG,CAC9C,IAAyB,KAEzB,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/declarations/createPropertyDeclaration.mjs

@@ -0,0 +1,41 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PropertyDeclaration}: a class field such as `x: number;`.
+ *
+ * The `modifiers` precede the property name, so `public readonly` prints in
+ * that order. Any decorators among the modifiers are hoisted onto their own
+ * lines above the property. The `name` is the field key, and the
+ * `questionOrExclamationToken` appends either the optional marker (`?`) or the
+ * definite-assignment marker (`!`) after the name.
+ *
+ * The optional `type` prints after a colon, and the optional `initializer`
+ * prints after an `=`. The printer terminates the field with a semicolon.
+ *
+ * Given `public readonly` modifiers, the name `id`, a `string` type, and a
+ * string-literal initializer of `"x"`, the printed field is:
+ *
+ * ```ts
+ * public readonly id: string = "x";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param name The name.
+ * @param questionOrExclamationToken The optional (`?`) or definite-assignment
+ *   (`!`) marker, if any.
+ * @param type The type.
+ * @param initializer The initializer, if any.
+ * @returns The created {@link PropertyDeclaration}.
+ */
+const createPropertyDeclaration = (modifiers, name, questionOrExclamationToken, type, initializer) => make("PropertyDeclaration", {
+    modifiers,
+    name: asPropertyName(name),
+    questionOrExclamationToken,
+    type,
+    initializer,
+});
+
+export { createPropertyDeclaration };
+//# sourceMappingURL=createPropertyDeclaration.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyDeclaration.mjs","sources":["../../../src/factory/declarations/createPropertyDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,yBAAyB,GAAG,CACvC,SAA8C,EAC9C,IAA2B,EAC3B,0BAA6C,EAC7C,IAA0B,EAC1B,WAAmC,KAEnC,IAAI,CAAC,qBAAqB,EAAE;IAC1B,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,0BAA0B;IAC1B,IAAI;IACJ,WAAW;AACZ,CAAA;;;;"}

package/lib/factory/declarations/createSemicolonClassElement.mjs

@@ -0,0 +1,20 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SemicolonClassElement}: a stray `;` in a class body.
+ *
+ * This is an empty class member, a lone semicolon that TypeScript permits
+ * between real members. It carries no name or body. Placed inside a class, the
+ * printer emits it as a single semicolon on its own line:
+ *
+ * ```ts
+ * class C {}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link SemicolonClassElement}.
+ */
+const createSemicolonClassElement = () => make("SemicolonClassElement", {});
+
+export { createSemicolonClassElement };
+//# sourceMappingURL=createSemicolonClassElement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSemicolonClassElement.mjs","sources":["../../../src/factory/declarations/createSemicolonClassElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;AAaG;AACI,MAAM,2BAA2B,GAAG,MACzC,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}

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":["../../../src/factory/declarations/createSetAccessorDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,4BAA4B,GAAG,CAC1C,SAA8C,EAC9C,IAA2B,EAC3B,UAA2C,EAC3C,IAAuB,KAEvB,IAAI,CAAC,wBAAwB,EAAE;IAC7B,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

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":["../../../src/factory/declarations/createTypeAliasDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,0BAA0B,GAAG,CACxC,SAA8C,EAC9C,IAAyB,EACzB,cAA+D,EAC/D,IAAc,KAEd,IAAI,CAAC,sBAAsB,EAAE;IAC3B,SAAS;AACT,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,cAAc;IACd,IAAI;AACL,CAAA;;;;"}

package/lib/factory/expressions/createAdd.mjs

@@ -0,0 +1,26 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.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":["../../../src/factory/expressions/createAdd.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,SAAS,GAAG,CACvB,IAAgB,EAChB,KAAiB,KAEjB,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":["../../../src/factory/expressions/createArrayBindingPattern.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,QAAwC,KAChB,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":["../../../src/factory/expressions/createArrayLiteralExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,4BAA4B,GAAG,CAC1C,QAAA,GAAkC,EAAE,EACpC,SAAmB,KAEnB,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":["../../../src/factory/expressions/createArrowFunction.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,mBAAmB,GAAG,CACjC,SAA8C,EAC9C,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,uBAA0C,EAC1C,IAAwB,KAExB,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":["../../../src/factory/expressions/createAsExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;MACU,kBAAkB,GAAG,CAChC,UAAsB,EACtB,IAAc,KACG,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createAssignment.mjs

@@ -0,0 +1,26 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.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":["../../../src/factory/expressions/createAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,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":["../../../src/factory/expressions/createAwaitExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAsB,KACF,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":["../../../src/factory/expressions/createBinaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,sBAAsB,GAAG,CACpC,IAAgB,EAChB,QAA4B,EAC5B,KAAiB,KAEjB,IAAI,CAAC,kBAAkB,EAAE;IACvB,IAAI;AACJ,IAAA,QAAQ,EAAE,OAAO,QAAQ,KAAK,QAAQ,GAAI,QAAgB,CAAC,KAAK,GAAG,QAAQ;IAC3E,KAAK;AACN,CAAA;;;;"}