@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/expressions/createGreaterThan.mjs

@@ -0,0 +1,27 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `>` operator: greater-than
+ * comparison.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `GreaterThanToken`
+ * 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 createGreaterThan = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanToken, right);
+
+export { createGreaterThan };
+//# sourceMappingURL=createGreaterThan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createGreaterThan.mjs","sources":["../../../src/factory/expressions/createGreaterThan.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,iBAAiB,GAAG,CAC/B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,gBAAgB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createGreaterThanEquals.mjs

@@ -0,0 +1,27 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `>=` operator: greater-than-or-
+ * equal comparison.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `GreaterThanEqualsToken`
+ * 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 createGreaterThanEquals = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanEqualsToken, right);
+
+export { createGreaterThanEquals };
+//# sourceMappingURL=createGreaterThanEquals.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createGreaterThanEquals.mjs","sources":["../../../src/factory/expressions/createGreaterThanEquals.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,uBAAuB,GAAG,CACrC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,sBAAsB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createImmediatelyInvokedArrowFunction.mjs

@@ -0,0 +1,29 @@
+import { createBlock } from '../statements/createBlock.mjs';
+import { createArrowFunction } from './createArrowFunction.mjs';
+import { createCallExpression } from './createCallExpression.mjs';
+import { createParenthesizedExpression } from './createParenthesizedExpression.mjs';
+
+/**
+ * Create an immediately-invoked arrow function: `(() => { ... })()`.
+ *
+ * The `statements` become the body of a parameterless arrow function whose
+ * block is forced multi-line. The arrow is wrapped in parentheses with
+ * {@link createParenthesizedExpression} and then called with no arguments via
+ * {@link createCallExpression}.
+ *
+ * Given a single `return 1;` statement, the printer emits:
+ *
+ * ```ts
+ * (() => {
+ *   return 1;
+ * })();
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param statements The body statements.
+ * @returns The created {@link CallExpression}.
+ */
+const createImmediatelyInvokedArrowFunction = (statements) => createCallExpression(createParenthesizedExpression(createArrowFunction(undefined, undefined, [], undefined, undefined, createBlock(statements, true))), undefined, []);
+
+export { createImmediatelyInvokedArrowFunction };
+//# sourceMappingURL=createImmediatelyInvokedArrowFunction.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createImmediatelyInvokedArrowFunction.mjs","sources":["../../../src/factory/expressions/createImmediatelyInvokedArrowFunction.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,qCAAqC,GAAG,CACnD,UAAgC,KAEhC,oBAAoB,CAClB,6BAA6B,CAC3B,mBAAmB,CACjB,SAAS,EACT,SAAS,EACT,EAAE,EACF,SAAS,EACT,SAAS,EACT,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAC9B,CACF,EACD,SAAS,EACT,EAAE;;;;"}

package/lib/factory/expressions/createImmediatelyInvokedFunctionExpression.mjs

@@ -0,0 +1,29 @@
+import { createBlock } from '../statements/createBlock.mjs';
+import { createCallExpression } from './createCallExpression.mjs';
+import { createFunctionExpression } from './createFunctionExpression.mjs';
+import { createParenthesizedExpression } from './createParenthesizedExpression.mjs';
+
+/**
+ * Create an immediately-invoked function expression: `(function () { ... })()`.
+ *
+ * The `statements` become the body of an anonymous function expression whose
+ * block is forced multi-line. The function is wrapped in parentheses with
+ * {@link createParenthesizedExpression} and then called with no arguments via
+ * {@link createCallExpression}.
+ *
+ * Given a single `return 1;` statement, the printer emits:
+ *
+ * ```ts
+ * (function () {
+ *   return 1;
+ * })();
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param statements The body statements.
+ * @returns The created {@link CallExpression}.
+ */
+const createImmediatelyInvokedFunctionExpression = (statements) => createCallExpression(createParenthesizedExpression(createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, createBlock(statements, true))), undefined, []);
+
+export { createImmediatelyInvokedFunctionExpression };
+//# sourceMappingURL=createImmediatelyInvokedFunctionExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createImmediatelyInvokedFunctionExpression.mjs","sources":["../../../src/factory/expressions/createImmediatelyInvokedFunctionExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAMA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,0CAA0C,GAAG,CACxD,UAAgC,KAEhC,oBAAoB,CAClB,6BAA6B,CAC3B,wBAAwB,CACtB,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,EAAE,EACF,SAAS,EACT,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAC9B,CACF,EACD,SAAS,EACT,EAAE;;;;"}

package/lib/factory/expressions/createInequality.mjs

@@ -0,0 +1,27 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `!=` operator: loose inequality
+ * with type coercion.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `ExclamationEqualsToken`
+ * 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 createInequality = (left, right) => createBinaryExpression(left, SyntaxKind.ExclamationEqualsToken, right);
+
+export { createInequality };
+//# sourceMappingURL=createInequality.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createInequality.mjs","sources":["../../../src/factory/expressions/createInequality.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,sBAAsB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLeftShift.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: bitwise left shift.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `LessThanLessThanToken`
+ * 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 value to shift.
+ * @param right The shift amount.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createLeftShift = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanLessThanToken, right);
+
+export { createLeftShift };
+//# sourceMappingURL=createLeftShift.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLeftShift.mjs","sources":["../../../src/factory/expressions/createLeftShift.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,eAAe,GAAG,CAC7B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,qBAAqB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLessThan.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: less-than comparison.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `LessThanToken`
+ * 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 createLessThan = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanToken, right);
+
+export { createLessThan };
+//# sourceMappingURL=createLessThan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLessThan.mjs","sources":["../../../src/factory/expressions/createLessThan.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,aAAa,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLessThanEquals.mjs

@@ -0,0 +1,27 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `<=` operator: less-than-or-equal
+ * comparison.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `LessThanEqualsToken`
+ * 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 createLessThanEquals = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanEqualsToken, right);
+
+export { createLessThanEquals };
+//# sourceMappingURL=createLessThanEquals.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLessThanEquals.mjs","sources":["../../../src/factory/expressions/createLessThanEquals.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,oBAAoB,GAAG,CAClC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,mBAAmB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLogicalAnd.mjs

@@ -0,0 +1,27 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `&&` operator: logical AND with
+ * short-circuit evaluation.
+ *
+ * Shorthand for {@link createBinaryExpression} with the
+ * `AmpersandAmpersandToken` 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 createLogicalAnd = (left, right) => createBinaryExpression(left, SyntaxKind.AmpersandAmpersandToken, right);
+
+export { createLogicalAnd };
+//# sourceMappingURL=createLogicalAnd.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLogicalAnd.mjs","sources":["../../../src/factory/expressions/createLogicalAnd.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,uBAAuB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLogicalNot.mjs

@@ -0,0 +1,25 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+
+/**
+ * Create a {@link PrefixUnaryExpression} with the `!` operator: logical NOT.
+ *
+ * Shorthand for {@link createPrefixUnaryExpression} with the `ExclamationToken`
+ * 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 createLogicalNot = (operand) => createPrefixUnaryExpression(SyntaxKind.ExclamationToken, operand);
+
+export { createLogicalNot };
+//# sourceMappingURL=createLogicalNot.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLogicalNot.mjs","sources":["../../../src/factory/expressions/createLogicalNot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,gBAAgB,GAAG,CAAC,OAAmB,KAClD,2BAA2B,CAAC,UAAU,CAAC,gBAAgB,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createLogicalOr.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: logical OR with
+ * short-circuit evaluation.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `BarBarToken` 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 createLogicalOr = (left, right) => createBinaryExpression(left, SyntaxKind.BarBarToken, right);
+
+export { createLogicalOr };
+//# sourceMappingURL=createLogicalOr.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createLogicalOr.mjs","sources":["../../../src/factory/expressions/createLogicalOr.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,eAAe,GAAG,CAC7B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createMetaProperty.mjs

@@ -0,0 +1,29 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link MetaProperty}: a meta-property reference like `new.target` or
+ * `import.meta`.
+ *
+ * `keywordToken` selects the leading keyword (`NewKeyword` for `new.target`,
+ * `ImportKeyword` for `import.meta`) and `name` is the member that follows the
+ * dot. The printer emits the keyword, a dot, and the name with no surrounding
+ * whitespace.
+ *
+ * With `keywordToken` of `NewKeyword` and `name` of `target`, the printer
+ * emits:
+ *
+ * ```ts
+ * new.target;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param keywordToken The leading keyword token (`NewKeyword` or
+ *   `ImportKeyword`).
+ * @param name The member name following the dot.
+ * @returns The created {@link MetaProperty}.
+ */
+const createMetaProperty = (keywordToken, name) => make("MetaProperty", { keywordToken, name: asName(name) });
+
+export { createMetaProperty };
+//# sourceMappingURL=createMetaProperty.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createMetaProperty.mjs","sources":["../../../src/factory/expressions/createMetaProperty.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAKA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,kBAAkB,GAAG,CAChC,YAAwB,EACxB,IAAyB,KACR,IAAI,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/expressions/createModulo.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a remainder expression: `left % right`.
+ *
+ * Thin wrapper over {@link createBinaryExpression} with the `%` operator.
+ *
+ * With `left` of `a` and `right` of `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 createModulo = (left, right) => createBinaryExpression(left, SyntaxKind.PercentToken, right);
+
+export { createModulo };
+//# sourceMappingURL=createModulo.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createModulo.mjs","sources":["../../../src/factory/expressions/createModulo.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,YAAY,GAAG,CAC1B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,YAAY,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createMultiply.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a multiplication expression: `left * right`.
+ *
+ * Thin wrapper over {@link createBinaryExpression} with the `*` operator.
+ *
+ * With `left` of `a` and `right` of `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 createMultiply = (left, right) => createBinaryExpression(left, SyntaxKind.AsteriskToken, right);
+
+export { createMultiply };
+//# sourceMappingURL=createMultiply.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createMultiply.mjs","sources":["../../../src/factory/expressions/createMultiply.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;AAeG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,aAAa,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createNewExpression.mjs

@@ -0,0 +1,30 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NewExpression}: a constructor call with `new`.
+ *
+ * `expression` is the constructor being invoked. `typeArguments`, when present,
+ * are printed in angle brackets after the constructor. `argumentsArray` holds
+ * the call arguments; an empty array still prints the parentheses, so `new
+ * Foo()` is emitted rather than `new Foo`.
+ *
+ * With `expression` of `Foo` and a single argument `a`, the printer emits:
+ *
+ * ```ts
+ * new Foo(a);
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The constructor expression.
+ * @param typeArguments The generic type arguments, if any.
+ * @param argumentsArray The constructor arguments.
+ * @returns The created {@link NewExpression}.
+ */
+const createNewExpression = (expression, typeArguments, argumentsArray) => make("NewExpression", {
+    expression,
+    typeArguments,
+    arguments: argumentsArray,
+});
+
+export { createNewExpression };
+//# sourceMappingURL=createNewExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNewExpression.mjs","sources":["../../../src/factory/expressions/createNewExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,UAAsB,EACtB,aAA8C,EAC9C,cAAiD,KAEjD,IAAI,CAAC,eAAe,EAAE;IACpB,UAAU;IACV,aAAa;AACb,IAAA,SAAS,EAAE,cAAc;AAC1B,CAAA;;;;"}

package/lib/factory/expressions/createNonNullChain.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NonNullChain}: a non-null assertion `!` that participates in
+ * an optional chain.
+ *
+ * This is the chain-aware variant of {@link createNonNullExpression}. It marks
+ * `expression` as non-null inside an optional chain so the chain context is
+ * preserved. The printed form is the same single `!` suffix.
+ *
+ * With `expression` of `a`, the printer emits:
+ *
+ * ```ts
+ * a!;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression to assert as non-null.
+ * @returns The created {@link NonNullChain}.
+ */
+const createNonNullChain = (expression) => make("NonNullChain", { expression });
+
+export { createNonNullChain };
+//# sourceMappingURL=createNonNullChain.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNonNullChain.mjs","sources":["../../../src/factory/expressions/createNonNullChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,kBAAkB,GAAG,CAAC,UAAsB,KACvD,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createNonNullExpression.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NonNullExpression}: a non-null assertion that suffixes
+ * `expression` with `!`.
+ *
+ * The assertion strips `null` and `undefined` from the operand's type at
+ * compile time. The printer appends a single `!` directly after the operand
+ * with no space.
+ *
+ * With `expression` of `a`, the printer emits:
+ *
+ * ```ts
+ * a!;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression to assert as non-null.
+ * @returns The created {@link NonNullExpression}.
+ */
+const createNonNullExpression = (expression) => make("NonNullExpression", { expression });
+
+export { createNonNullExpression };
+//# sourceMappingURL=createNonNullExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNonNullExpression.mjs","sources":["../../../src/factory/expressions/createNonNullExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,uBAAuB,GAAG,CACrC,UAAsB,KACA,IAAI,CAAC,mBAAmB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createObjectBindingPattern.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ObjectBindingPattern}: the `{ ... }` binding form used to
+ * destructure an object.
+ *
+ * `elements` are the binding elements, each naming a property to bind and
+ * optionally a default or rest. The printer wraps the elements in braces and
+ * separates them with commas, with a single space inside the braces.
+ *
+ * With binding elements `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 ObjectBindingPattern}.
+ */
+const createObjectBindingPattern = (elements) => make("ObjectBindingPattern", { elements });
+
+export { createObjectBindingPattern };
+//# sourceMappingURL=createObjectBindingPattern.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createObjectBindingPattern.mjs","sources":["../../../src/factory/expressions/createObjectBindingPattern.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,0BAA0B,GAAG,CACxC,QAAmC,KACV,IAAI,CAAC,sBAAsB,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createObjectLiteralExpression.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ObjectLiteralExpression}: a `{ ... }` object literal.
+ *
+ * `properties` are the members (assignments, shorthands, spreads, methods).
+ * `multiLine` controls layout. When `true`, each property is printed on its own
+ * line and a trailing comma is added; when falsy, the whole literal is printed
+ * inline with a single space inside the braces.
+ *
+ * With a single property `a: 1` and `multiLine` of `true`, the printer emits:
+ *
+ * ```ts
+ * {
+ *   "a": 1
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param properties The object members.
+ * @param multiLine When `true`, print one entry per line.
+ * @returns The created {@link ObjectLiteralExpression}.
+ */
+const createObjectLiteralExpression = (properties = [], multiLine) => make("ObjectLiteralExpression", { properties, multiLine });
+
+export { createObjectLiteralExpression };
+//# sourceMappingURL=createObjectLiteralExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createObjectLiteralExpression.mjs","sources":["../../../src/factory/expressions/createObjectLiteralExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,6BAA6B,GAAG,CAC3C,UAAA,GAA8C,EAAE,EAChD,SAAmB,KAEnB,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/expressions/createOmittedExpression.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link OmittedExpression}: an elided element, the hole left by a
+ * missing entry in an array literal or binding pattern.
+ *
+ * The node carries no operand. The printer emits nothing for it; the
+ * surrounding list still prints its comma separator, which is what produces the
+ * visible gap.
+ *
+ * Placed before `a` in an array literal, the printer emits:
+ *
+ * ```ts
+ * [, a];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link OmittedExpression}.
+ */
+const createOmittedExpression = () => make("OmittedExpression", {});
+
+export { createOmittedExpression };
+//# sourceMappingURL=createOmittedExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createOmittedExpression.mjs","sources":["../../../src/factory/expressions/createOmittedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,MACrC,IAAI,CAAC,mBAAmB,EAAE,EAAE;;;;"}