@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/expressions/createParenthesizedExpression.mjs

@@ -0,0 +1,24 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ParenthesizedExpression}: an explicit `( ... )` grouping
+ * around `expression`.
+ *
+ * This is an explicit grouping node that is always present in the tree; the
+ * printer emits the parentheses unconditionally rather than inferring them from
+ * precedence.
+ *
+ * With `expression` of `a % b`, the printer emits:
+ *
+ * ```ts
+ * a % b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The inner expression to wrap in parentheses.
+ * @returns The created {@link ParenthesizedExpression}.
+ */
+const createParenthesizedExpression = (expression) => make("ParenthesizedExpression", { expression });
+
+export { createParenthesizedExpression };
+//# sourceMappingURL=createParenthesizedExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createParenthesizedExpression.mjs","sources":["../../../src/factory/expressions/createParenthesizedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,UAAsB,KACM,IAAI,CAAC,yBAAyB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createPartiallyEmittedExpression.mjs

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PartiallyEmittedExpression}: a transform wrapper that prints
+ * only its inner `expression`.
+ *
+ * This node exists to carry transform bookkeeping such as the `original` source
+ * node while the surrounding syntax (for example a stripped type assertion) is
+ * dropped. The printer emits the inner expression alone; the wrapper itself
+ * adds nothing to the output.
+ *
+ * With `expression` of `a`, the printer emits:
+ *
+ * ```ts
+ * a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression to emit.
+ * @param original The original node this was derived from, if any.
+ * @returns The created {@link PartiallyEmittedExpression}.
+ */
+const createPartiallyEmittedExpression = (expression, original) => make("PartiallyEmittedExpression", { expression, original });
+
+export { createPartiallyEmittedExpression };
+//# sourceMappingURL=createPartiallyEmittedExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPartiallyEmittedExpression.mjs","sources":["../../../src/factory/expressions/createPartiallyEmittedExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;MACU,gCAAgC,GAAG,CAC9C,UAAsB,EACtB,QAAe,KAEf,IAAI,CAAC,4BAA4B,EAAE,EAAE,UAAU,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createPostfixDecrement.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
+
+/**
+ * Create a postfix decrement expression: `operand--`.
+ *
+ * Thin wrapper over {@link createPostfixUnaryExpression} with the `--` operator.
+ *
+ * With `operand` of `a`, the printer emits:
+ *
+ * ```ts
+ * a--;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to decrement.
+ * @returns The created {@link PostfixUnaryExpression}.
+ */
+const createPostfixDecrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.MinusMinusToken);
+
+export { createPostfixDecrement };
+//# sourceMappingURL=createPostfixDecrement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPostfixDecrement.mjs","sources":["../../../src/factory/expressions/createPostfixDecrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAAmB,KAEnB,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,eAAe;;;;"}

package/lib/factory/expressions/createPostfixIncrement.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPostfixUnaryExpression } from './createPostfixUnaryExpression.mjs';
+
+/**
+ * Create a postfix increment expression: `operand++`.
+ *
+ * Thin wrapper over {@link createPostfixUnaryExpression} with the `++` operator.
+ *
+ * With `operand` of `a`, the printer emits:
+ *
+ * ```ts
+ * a++;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to increment.
+ * @returns The created {@link PostfixUnaryExpression}.
+ */
+const createPostfixIncrement = (operand) => createPostfixUnaryExpression(operand, SyntaxKind.PlusPlusToken);
+
+export { createPostfixIncrement };
+//# sourceMappingURL=createPostfixIncrement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPostfixIncrement.mjs","sources":["../../../src/factory/expressions/createPostfixIncrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAAmB,KAEnB,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,aAAa;;;;"}

package/lib/factory/expressions/createPostfixUnaryExpression.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PostfixUnaryExpression}: a unary operator that follows its
+ * operand.
+ *
+ * `operand` is the target and `operator` is the trailing token, one of `++` or
+ * `--`. The printer appends the operator directly after the operand with no
+ * space.
+ *
+ * With `operand` of `a` and `operator` of `++`, the printer emits:
+ *
+ * ```ts
+ * a++;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand.
+ * @param operator The trailing operator token (`++` or `--`).
+ * @returns The created {@link PostfixUnaryExpression}.
+ */
+const createPostfixUnaryExpression = (operand, operator) => make("PostfixUnaryExpression", { operand, operator });
+
+export { createPostfixUnaryExpression };
+//# sourceMappingURL=createPostfixUnaryExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPostfixUnaryExpression.mjs","sources":["../../../src/factory/expressions/createPostfixUnaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,4BAA4B,GAAG,CAC1C,OAAmB,EACnB,QAAoB,KAEpB,IAAI,CAAC,wBAAwB,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createPrefixDecrement.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+
+/**
+ * Create a prefix decrement expression: `--operand`.
+ *
+ * Thin wrapper over {@link createPrefixUnaryExpression} with the `--` operator.
+ *
+ * With `operand` of `a`, the printer emits:
+ *
+ * ```ts
+ * --a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to decrement.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createPrefixDecrement = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusMinusToken, operand);
+
+export { createPrefixDecrement };
+//# sourceMappingURL=createPrefixDecrement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPrefixDecrement.mjs","sources":["../../../src/factory/expressions/createPrefixDecrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAmB,KAEnB,2BAA2B,CAAC,UAAU,CAAC,eAAe,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixIncrement.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+
+/**
+ * Create a prefix increment expression: `++operand`.
+ *
+ * Thin wrapper over {@link createPrefixUnaryExpression} with the `++` operator.
+ *
+ * With `operand` of `a`, the printer emits:
+ *
+ * ```ts
+ * ++a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to increment.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createPrefixIncrement = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusPlusToken, operand);
+
+export { createPrefixIncrement };
+//# sourceMappingURL=createPrefixIncrement.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPrefixIncrement.mjs","sources":["../../../src/factory/expressions/createPrefixIncrement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;AAcG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAmB,KAEnB,2BAA2B,CAAC,UAAU,CAAC,aAAa,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixMinus.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+
+/**
+ * Create a unary minus expression: `-operand`.
+ *
+ * Thin wrapper over {@link createPrefixUnaryExpression} with the `-` operator.
+ *
+ * With `operand` of `1`, the printer emits:
+ *
+ * ```ts
+ * -1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand to negate.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createPrefixMinus = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusToken, operand);
+
+export { createPrefixMinus };
+//# sourceMappingURL=createPrefixMinus.mjs.map

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

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

package/lib/factory/expressions/createPrefixPlus.mjs

@@ -0,0 +1,23 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+
+/**
+ * Create a unary plus expression: `+operand`.
+ *
+ * Thin wrapper over {@link createPrefixUnaryExpression} with the `+` operator.
+ *
+ * With `operand` of `a`, the printer emits:
+ *
+ * ```ts
+ * +a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operand The operand.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createPrefixPlus = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusToken, operand);
+
+export { createPrefixPlus };
+//# sourceMappingURL=createPrefixPlus.mjs.map

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

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

package/lib/factory/expressions/createPrefixUnaryExpression.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PrefixUnaryExpression}: a unary operator that precedes its
+ * operand.
+ *
+ * `operator` is the leading token, one of `+`, `-`, `~`, `!`, `++`, or `--`,
+ * and `operand` is the target. The printer writes the operator immediately
+ * before the operand with no space.
+ *
+ * With `operator` of `-` and `operand` of `1`, the printer emits:
+ *
+ * ```ts
+ * -1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param operator The leading operator token.
+ * @param operand The operand.
+ * @returns The created {@link PrefixUnaryExpression}.
+ */
+const createPrefixUnaryExpression = (operator, operand) => make("PrefixUnaryExpression", { operator, operand });
+
+export { createPrefixUnaryExpression };
+//# sourceMappingURL=createPrefixUnaryExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPrefixUnaryExpression.mjs","sources":["../../../src/factory/expressions/createPrefixUnaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,2BAA2B,GAAG,CACzC,QAAoB,EACpB,OAAmB,KAEnB,IAAI,CAAC,uBAAuB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/expressions/createPropertyAccessChain.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link PropertyAccessChain}: a member access that participates in an
+ * optional chain, such as `a?.b`.
+ *
+ * `expression` is the receiver and `name` is the accessed member; a string
+ * `name` is wrapped in an identifier. `questionDotToken`, when present, makes
+ * this link optional and prints as `?.`; when omitted the printer emits a plain
+ * `.` while the node still carries chain context.
+ *
+ * With `expression` of `a`, a `?.` token, and `name` of `b`, the printer emits:
+ *
+ * ```ts
+ * a?.b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The receiver expression.
+ * @param questionDotToken The optional `?.` token, if this link is optional.
+ * @param name The accessed member name.
+ * @returns The created {@link PropertyAccessChain}.
+ */
+const createPropertyAccessChain = (expression, questionDotToken, name) => make("PropertyAccessChain", {
+    expression,
+    questionDotToken,
+    name: typeof name === "string" ? createIdentifier(name) : name,
+});
+
+export { createPropertyAccessChain };
+//# sourceMappingURL=createPropertyAccessChain.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyAccessChain.mjs","sources":["../../../src/factory/expressions/createPropertyAccessChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,yBAAyB,GAAG,CACvC,UAAsB,EACtB,gBAAmC,EACnC,IAA6C,KAE7C,IAAI,CAAC,qBAAqB,EAAE;IAC1B,UAAU;IACV,gBAAgB;AAChB,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAC/D,CAAA;;;;"}

package/lib/factory/expressions/createPropertyAccessExpression.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link PropertyAccessExpression}: a dotted member access like `a.b`.
+ *
+ * `expression` is the receiver and `name` is the accessed member; a string
+ * `name` is wrapped in an identifier. The printer joins them with a single dot
+ * and no surrounding space.
+ *
+ * With `expression` of `a` and `name` of `b`, the printer emits:
+ *
+ * ```ts
+ * a.b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The receiver expression.
+ * @param name The accessed member name.
+ * @returns The created {@link PropertyAccessExpression}.
+ */
+const createPropertyAccessExpression = (expression, name) => make("PropertyAccessExpression", {
+    expression,
+    name: typeof name === "string" ? createIdentifier(name) : name,
+});
+
+export { createPropertyAccessExpression };
+//# sourceMappingURL=createPropertyAccessExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyAccessExpression.mjs","sources":["../../../src/factory/expressions/createPropertyAccessExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,UAAsB,EACtB,IAA6C,KAE7C,IAAI,CAAC,0BAA0B,EAAE;IAC/B,UAAU;AACV,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAC/D,CAAA;;;;"}

package/lib/factory/expressions/createPropertyAssignment.mjs

@@ -0,0 +1,26 @@
+import { asPropertyName } from '../internal/asPropertyName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link PropertyAssignment}: a `name: value` member of an object
+ * literal.
+ *
+ * `name` is the property key; a string is converted to a property name node.
+ * `initializer` is the assigned value. The printer joins them with a colon and
+ * a single space.
+ *
+ * With `name` of `a` and `initializer` of `1`, the printer emits:
+ *
+ * ```ts
+ * a: 1;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The property name.
+ * @param initializer The assigned value.
+ * @returns The created {@link PropertyAssignment}.
+ */
+const createPropertyAssignment = (name, initializer) => make("PropertyAssignment", { name: asPropertyName(name), initializer });
+
+export { createPropertyAssignment };
+//# sourceMappingURL=createPropertyAssignment.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyAssignment.mjs","sources":["../../../src/factory/expressions/createPropertyAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,wBAAwB,GAAG,CACtC,IAA2B,EAC3B,WAAuB,KAEvB,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE;;;;"}

package/lib/factory/expressions/createRegularExpressionLiteral.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link RegularExpressionLiteral}: a regex literal.
+ *
+ * `text` is the complete literal source, including the slash delimiters and any
+ * trailing flags. The printer emits `text` verbatim; it does not validate or
+ * re-escape the pattern.
+ *
+ * With `text` of `/ab+c/i`, the printer emits:
+ *
+ * ```ts
+ * /ab+c/i;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param text The full regex literal source, including delimiters and flags.
+ * @returns The created {@link RegularExpressionLiteral}.
+ */
+const createRegularExpressionLiteral = (text) => make("RegularExpressionLiteral", { text });
+
+export { createRegularExpressionLiteral };
+//# sourceMappingURL=createRegularExpressionLiteral.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createRegularExpressionLiteral.mjs","sources":["../../../src/factory/expressions/createRegularExpressionLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,8BAA8B,GAAG,CAC5C,IAAY,KACiB,IAAI,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createRightShift.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a signed right-shift 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 createRightShift = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanGreaterThanToken, right);
+
+export { createRightShift };
+//# sourceMappingURL=createRightShift.mjs.map

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

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

package/lib/factory/expressions/createSatisfiesExpression.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SatisfiesExpression}: an expression checked against a type
+ * with `satisfies`.
+ *
+ * `expression` is the value and `type` is the type it must conform to without
+ * widening or narrowing its inferred type. The printer joins them with the
+ * `satisfies` keyword surrounded by single spaces.
+ *
+ * With `expression` of `x` and `type` of `Foo`, the printer emits:
+ *
+ * ```ts
+ * x satisfies Foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The expression to check.
+ * @param type The type the expression must satisfy.
+ * @returns The created {@link SatisfiesExpression}.
+ */
+const createSatisfiesExpression = (expression, type) => make("SatisfiesExpression", { expression, type });
+
+export { createSatisfiesExpression };
+//# sourceMappingURL=createSatisfiesExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSatisfiesExpression.mjs","sources":["../../../src/factory/expressions/createSatisfiesExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,yBAAyB,GAAG,CACvC,UAAsB,EACtB,IAAc,KACU,IAAI,CAAC,qBAAqB,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createShorthandPropertyAssignment.mjs

@@ -0,0 +1,31 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ShorthandPropertyAssignment}: an object member that reuses a
+ * variable name as both key and value, like `{ a }`.
+ *
+ * `name` is the shared property name. `objectAssignmentInitializer` is only
+ * valid when the literal is the target of a destructuring assignment; when
+ * present the printer appends `=` and the default value, otherwise it emits the
+ * name alone.
+ *
+ * With `name` of `a` and no initializer, the printer emits:
+ *
+ * ```ts
+ * a;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The shared property name.
+ * @param objectAssignmentInitializer The default value for object
+ *   destructuring, if any.
+ * @returns The created {@link ShorthandPropertyAssignment}.
+ */
+const createShorthandPropertyAssignment = (name, objectAssignmentInitializer) => make("ShorthandPropertyAssignment", {
+    name: asName(name),
+    objectAssignmentInitializer,
+});
+
+export { createShorthandPropertyAssignment };
+//# sourceMappingURL=createShorthandPropertyAssignment.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createShorthandPropertyAssignment.mjs","sources":["../../../src/factory/expressions/createShorthandPropertyAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,iCAAiC,GAAG,CAC/C,IAAyB,EACzB,2BAAwC,KAExC,IAAI,CAAC,6BAA6B,EAAE;AAClC,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,2BAA2B;AAC5B,CAAA;;;;"}

package/lib/factory/expressions/createSpreadAssignment.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SpreadAssignment}: a `...expression` member that spreads one
+ * object's properties into an object literal.
+ *
+ * `expression` is the source object. The printer prefixes it with `...` and no
+ * separating space.
+ *
+ * With `expression` of `a` inside an object literal, the printer emits:
+ *
+ * ```ts
+ * { ...a }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The object expression to spread.
+ * @returns The created {@link SpreadAssignment}.
+ */
+const createSpreadAssignment = (expression) => make("SpreadAssignment", { expression });
+
+export { createSpreadAssignment };
+//# sourceMappingURL=createSpreadAssignment.mjs.map

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

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

package/lib/factory/expressions/createSpreadElement.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link SpreadElement}: a `...expression` element that spreads an
+ * iterable into an array literal or argument list.
+ *
+ * `expression` is the source iterable. The printer prefixes it with `...` and
+ * no separating space.
+ *
+ * With `expression` of `a` inside an array literal, the printer emits:
+ *
+ * ```ts
+ * [...a];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The iterable expression to spread.
+ * @returns The created {@link SpreadElement}.
+ */
+const createSpreadElement = (expression) => make("SpreadElement", { expression });
+
+export { createSpreadElement };
+//# sourceMappingURL=createSpreadElement.mjs.map

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

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

package/lib/factory/expressions/createStrictEquality.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a strict equality 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 createStrictEquality = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsEqualsEqualsToken, right);
+
+export { createStrictEquality };
+//# sourceMappingURL=createStrictEquality.mjs.map

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

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

package/lib/factory/expressions/createStrictInequality.mjs

@@ -0,0 +1,24 @@
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+
+/**
+ * Create a strict inequality 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 createStrictInequality = (left, right) => createBinaryExpression(left, SyntaxKind.ExclamationEqualsEqualsToken, right);
+
+export { createStrictInequality };
+//# sourceMappingURL=createStrictInequality.mjs.map

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

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