@ttsc/factory 0.15.9 → 0.15.10

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

@@ -0,0 +1 @@
+{"version":3,"file":"createClassExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createClassExpression.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link ClassExpression}: a `class` used as an expression.\n *\n * A string `name` is normalized with {@link asName}; the name is optional, as\n * are the `modifiers`, `typeParameters` and `heritageClauses` (the `extends` /\n * `implements` clauses). The `members` are printed inside the class body.\n *\n * Given name `C` and no members, the printer emits:\n *\n * ```ts\n * class C {}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param name The class name, if any.\n * @param typeParameters The generic type parameters, if any.\n * @param heritageClauses The extends and implements clauses, if any.\n * @param members The class members.\n * @returns The created {@link ClassExpression}.\n */\nexport const createClassExpression = (modifiers, name, typeParameters, heritageClauses, members) => make(\"ClassExpression\", {\n    modifiers,\n    name: name === undefined ? undefined : asName(name),\n    typeParameters,\n    heritageClauses,\n    members,\n});\n//# sourceMappingURL=createClassExpression.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;AACY,MAAC,qBAAqB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AAC5H,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;AACvD,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,OAAO;AACX,CAAC;;;;"}

package/lib/factory/expressions/createComma.mjs

@@ -0,0 +1,27 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `,` operator: the comma operator,
+ * which evaluates both operands and yields the right one.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `CommaToken` operator.
+ * The printer treats the comma like any other binary operator and surrounds it
+ * with a single space on each side, so the output has a space before the
+ * comma.
+ *
+ * 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 createComma = (left, right) => createBinaryExpression(left, SyntaxKind.CommaToken, right);
+
+export { createComma };
+//# sourceMappingURL=createComma.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createComma.mjs","sources":["../../../esm-tmp/factory/expressions/createComma.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `,` operator: the comma operator,\n * which evaluates both operands and yields the right one.\n *\n * Shorthand for {@link createBinaryExpression} with the `CommaToken` operator.\n * The printer treats the comma like any other binary operator and surrounds it\n * with a single space on each side, so the output has a space before the\n * comma.\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 createComma = (left, right) => createBinaryExpression(left, SyntaxKind.CommaToken, right);\n//# sourceMappingURL=createComma.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,WAAW,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createCommaListExpression.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link CommaListExpression}: a synthetic list of expressions joined
+ * by commas, used where several expressions are emitted in sequence.
+ *
+ * Unlike a chain of comma {@link BinaryExpression} nodes, this is a flat list.
+ * The printer separates the elements with a comma and a space.
+ *
+ * Given elements `a`, `b`, `c`, the printer emits:
+ *
+ * ```ts
+ * (a, b, c);
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The element expressions.
+ * @returns The created {@link CommaListExpression}.
+ */
+const createCommaListExpression = (elements) => make("CommaListExpression", { elements });
+
+export { createCommaListExpression };
+//# sourceMappingURL=createCommaListExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createCommaListExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createCommaListExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CommaListExpression}: a synthetic list of expressions joined\n * by commas, used where several expressions are emitted in sequence.\n *\n * Unlike a chain of comma {@link BinaryExpression} nodes, this is a flat list.\n * The printer separates the elements with a comma and a space.\n *\n * Given elements `a`, `b`, `c`, the printer emits:\n *\n * ```ts\n * (a, b, c);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The element expressions.\n * @returns The created {@link CommaListExpression}.\n */\nexport const createCommaListExpression = (elements) => make(\"CommaListExpression\", { elements });\n//# sourceMappingURL=createCommaListExpression.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/createComputedPropertyName.mjs

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ComputedPropertyName}: a `[expression]` property key.
+ *
+ * Used as the name of an object-literal member, class member or signature so
+ * the key is computed at runtime. The printer wraps the expression in square
+ * brackets.
+ *
+ * Given expression `key`, the printer emits the key:
+ *
+ * ```ts
+ * [key];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The key expression.
+ * @returns The created {@link ComputedPropertyName}.
+ */
+const createComputedPropertyName = (expression) => make("ComputedPropertyName", { expression });
+
+export { createComputedPropertyName };
+//# sourceMappingURL=createComputedPropertyName.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createComputedPropertyName.mjs","sources":["../../../esm-tmp/factory/expressions/createComputedPropertyName.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ComputedPropertyName}: a `[expression]` property key.\n *\n * Used as the name of an object-literal member, class member or signature so\n * the key is computed at runtime. The printer wraps the expression in square\n * brackets.\n *\n * Given expression `key`, the printer emits the key:\n *\n * ```ts\n * [key];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The key expression.\n * @returns The created {@link ComputedPropertyName}.\n */\nexport const createComputedPropertyName = (expression) => make(\"ComputedPropertyName\", { expression });\n//# sourceMappingURL=createComputedPropertyName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,0BAA0B,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,sBAAsB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createConditionalExpression.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link ConditionalExpression}: a ternary `condition ? whenTrue :
+ * whenFalse`.
+ *
+ * The `_questionToken` and `_colonToken` parameters exist only for signature
+ * parity with the legacy factory and are ignored: the printer always emits `?`
+ * and `:`, each surrounded by a single space.
+ *
+ * Given condition `cond` and branches `a` and `b`, the printer emits:
+ *
+ * ```ts
+ * cond ? a : b;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param condition The condition.
+ * @param _questionToken Ignored; present only to mirror the legacy signature.
+ * @param whenTrue The value when the condition holds.
+ * @param _colonToken Ignored; present only to mirror the legacy signature.
+ * @param whenFalse The value otherwise.
+ * @returns The created {@link ConditionalExpression}.
+ */
+const createConditionalExpression = (condition, _questionToken, whenTrue, _colonToken, whenFalse) => make("ConditionalExpression", { condition, whenTrue, whenFalse });
+
+export { createConditionalExpression };
+//# sourceMappingURL=createConditionalExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createConditionalExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createConditionalExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link ConditionalExpression}: a ternary `condition ? whenTrue :\n * whenFalse`.\n *\n * The `_questionToken` and `_colonToken` parameters exist only for signature\n * parity with the legacy factory and are ignored: the printer always emits `?`\n * and `:`, each surrounded by a single space.\n *\n * Given condition `cond` and branches `a` and `b`, the printer emits:\n *\n * ```ts\n * cond ? a : b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param condition The condition.\n * @param _questionToken Ignored; present only to mirror the legacy signature.\n * @param whenTrue The value when the condition holds.\n * @param _colonToken Ignored; present only to mirror the legacy signature.\n * @param whenFalse The value otherwise.\n * @returns The created {@link ConditionalExpression}.\n */\nexport const createConditionalExpression = (condition, _questionToken, whenTrue, _colonToken, whenFalse) => make(\"ConditionalExpression\", { condition, whenTrue, whenFalse });\n//# sourceMappingURL=createConditionalExpression.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;AACY,MAAC,2BAA2B,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

package/lib/factory/expressions/createDeleteExpression.mjs

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

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

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

package/lib/factory/expressions/createDivide.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createDivide.mjs","sources":["../../../esm-tmp/factory/expressions/createDivide.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `/` operator: division.\n *\n * Shorthand for {@link createBinaryExpression} with the `SlashToken` 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 createDivide = (left, right) => createBinaryExpression(left, SyntaxKind.SlashToken, right);\n//# sourceMappingURL=createDivide.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,YAAY,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createElementAccessChain.mjs

@@ -0,0 +1,32 @@
+import { make } from '../internal/make.mjs';
+import { createNumericLiteral } from '../literals/createNumericLiteral.mjs';
+
+/**
+ * Create an {@link ElementAccessChain}: a bracket access that participates in an
+ * optional chain.
+ *
+ * The `questionDotToken` is the `?.` token printed before the brackets. A
+ * numeric `index` is wrapped with {@link createNumericLiteral}; any other
+ * expression is used as the key directly. The printer wraps the key in square
+ * brackets.
+ *
+ * Given object `obj`, an optional `?.` token and index `0`, the printer emits:
+ *
+ * ```ts
+ * obj?.[0];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The object expression.
+ * @param questionDotToken The `?.` token, if this link is optional.
+ * @param index The index or key.
+ * @returns The created {@link ElementAccessChain}.
+ */
+const createElementAccessChain = (expression, questionDotToken, index) => make("ElementAccessChain", {
+    expression,
+    questionDotToken,
+    argumentExpression: typeof index === "number" ? createNumericLiteral(index) : index,
+});
+
+export { createElementAccessChain };
+//# sourceMappingURL=createElementAccessChain.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createElementAccessChain.mjs","sources":["../../../esm-tmp/factory/expressions/createElementAccessChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createNumericLiteral } from \"../literals/createNumericLiteral\";\n/**\n * Create an {@link ElementAccessChain}: a bracket access that participates in an\n * optional chain.\n *\n * The `questionDotToken` is the `?.` token printed before the brackets. A\n * numeric `index` is wrapped with {@link createNumericLiteral}; any other\n * expression is used as the key directly. The printer wraps the key in square\n * brackets.\n *\n * Given object `obj`, an optional `?.` token and index `0`, the printer emits:\n *\n * ```ts\n * obj?.[0];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The object expression.\n * @param questionDotToken The `?.` token, if this link is optional.\n * @param index The index or key.\n * @returns The created {@link ElementAccessChain}.\n */\nexport const createElementAccessChain = (expression, questionDotToken, index) => make(\"ElementAccessChain\", {\n    expression,\n    questionDotToken,\n    argumentExpression: typeof index === \"number\" ? createNumericLiteral(index) : index,\n});\n//# sourceMappingURL=createElementAccessChain.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;AACY,MAAC,wBAAwB,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,KAAK,KAAK,IAAI,CAAC,oBAAoB,EAAE;AAC5G,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,kBAAkB,EAAE,OAAO,KAAK,KAAK,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,GAAG,KAAK;AACvF,CAAC;;;;"}

package/lib/factory/expressions/createElementAccessExpression.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+import { createNumericLiteral } from '../literals/createNumericLiteral.mjs';
+
+/**
+ * Create an {@link ElementAccessExpression}: a `object[key]` bracket access.
+ *
+ * A numeric `index` is wrapped with {@link createNumericLiteral}; any other
+ * expression is used as the key directly. The printer wraps the key in square
+ * brackets, so a string key prints quoted (for example `obj["key"]`).
+ *
+ * Given object `obj` and index `0`, the printer emits:
+ *
+ * ```ts
+ * obj[0];
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The object expression.
+ * @param index The index or key.
+ * @returns The created {@link ElementAccessExpression}.
+ */
+const createElementAccessExpression = (expression, index) => make("ElementAccessExpression", {
+    expression,
+    argumentExpression: typeof index === "number" ? createNumericLiteral(index) : index,
+});
+
+export { createElementAccessExpression };
+//# sourceMappingURL=createElementAccessExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createElementAccessExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createElementAccessExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createNumericLiteral } from \"../literals/createNumericLiteral\";\n/**\n * Create an {@link ElementAccessExpression}: a `object[key]` bracket access.\n *\n * A numeric `index` is wrapped with {@link createNumericLiteral}; any other\n * expression is used as the key directly. The printer wraps the key in square\n * brackets, so a string key prints quoted (for example `obj[\"key\"]`).\n *\n * Given object `obj` and index `0`, the printer emits:\n *\n * ```ts\n * obj[0];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The object expression.\n * @param index The index or key.\n * @returns The created {@link ElementAccessExpression}.\n */\nexport const createElementAccessExpression = (expression, index) => make(\"ElementAccessExpression\", {\n    expression,\n    argumentExpression: typeof index === \"number\" ? createNumericLiteral(index) : index,\n});\n//# sourceMappingURL=createElementAccessExpression.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,6BAA6B,GAAG,CAAC,UAAU,EAAE,KAAK,KAAK,IAAI,CAAC,yBAAyB,EAAE;AACpG,IAAI,UAAU;AACd,IAAI,kBAAkB,EAAE,OAAO,KAAK,KAAK,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,GAAG,KAAK;AACvF,CAAC;;;;"}

package/lib/factory/expressions/createEquality.mjs

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"createEquality.mjs","sources":["../../../esm-tmp/factory/expressions/createEquality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `==` operator: loose equality with\n * type coercion.\n *\n * Shorthand for {@link createBinaryExpression} with the `EqualsEqualsToken`\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 createEquality = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsEqualsToken, right);\n//# sourceMappingURL=createEquality.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,iBAAiB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createExponent.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a {@link BinaryExpression} with the `**` operator: exponentiation.
+ *
+ * Shorthand for {@link createBinaryExpression} with the `AsteriskAsteriskToken`
+ * 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 base operand.
+ * @param right The exponent operand.
+ * @returns The created {@link BinaryExpression}.
+ */
+const createExponent = (left, right) => createBinaryExpression(left, SyntaxKind.AsteriskAsteriskToken, right);
+
+export { createExponent };
+//# sourceMappingURL=createExponent.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createExponent.mjs","sources":["../../../esm-tmp/factory/expressions/createExponent.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `**` operator: exponentiation.\n *\n * Shorthand for {@link createBinaryExpression} with the `AsteriskAsteriskToken`\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 base operand.\n * @param right The exponent operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createExponent = (left, right) => createBinaryExpression(left, SyntaxKind.AsteriskAsteriskToken, right);\n//# sourceMappingURL=createExponent.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,qBAAqB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createFunctionExpression.mjs

@@ -0,0 +1,38 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link FunctionExpression}: a `function` used as an expression.
+ *
+ * A string `name` is normalized with {@link asName}; the name is optional, as
+ * are the `modifiers`, `asteriskToken` (the generator `*`), `typeParameters`
+ * and return `type`. The `body` is a {@link Block}.
+ *
+ * Given name `f`, no parameters and an empty body, the printer emits:
+ *
+ * ```ts
+ * function f() {}
+ * ```
+ *
+ * @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 function name, if any.
+ * @param typeParameters The generic type parameters, if any.
+ * @param parameters The parameters.
+ * @param type The return type, if any.
+ * @param body The block body.
+ * @returns The created {@link FunctionExpression}.
+ */
+const createFunctionExpression = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => make("FunctionExpression", {
+    modifiers,
+    asteriskToken,
+    name: name === undefined ? undefined : asName(name),
+    typeParameters,
+    parameters,
+    type,
+    body,
+});
+
+export { createFunctionExpression };
+//# sourceMappingURL=createFunctionExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createFunctionExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createFunctionExpression.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link FunctionExpression}: a `function` used as an expression.\n *\n * A string `name` is normalized with {@link asName}; the name is optional, as\n * are the `modifiers`, `asteriskToken` (the generator `*`), `typeParameters`\n * and return `type`. The `body` is a {@link Block}.\n *\n * Given name `f`, no parameters and an empty body, the printer emits:\n *\n * ```ts\n * function f() {}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param asteriskToken The generator marker (`*`), if any.\n * @param name The function name, 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 body The block body.\n * @returns The created {@link FunctionExpression}.\n */\nexport const createFunctionExpression = (modifiers, asteriskToken, name, typeParameters, parameters, type, body) => make(\"FunctionExpression\", {\n    modifiers,\n    asteriskToken,\n    name: name === undefined ? undefined : asName(name),\n    typeParameters,\n    parameters,\n    type,\n    body,\n});\n//# sourceMappingURL=createFunctionExpression.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,wBAAwB,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,oBAAoB,EAAE;AAC/I,IAAI,SAAS;AACb,IAAI,aAAa;AACjB,IAAI,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;AACvD,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}

package/lib/factory/expressions/createGreaterThan.mjs

@@ -0,0 +1,26 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createGreaterThan.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `>` operator: greater-than\n * comparison.\n *\n * Shorthand for {@link createBinaryExpression} with the `GreaterThanToken`\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 createGreaterThan = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanToken, right);\n//# sourceMappingURL=createGreaterThan.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,gBAAgB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createGreaterThanEquals.mjs

@@ -0,0 +1,26 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createGreaterThanEquals.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `>=` operator: greater-than-or-\n * equal comparison.\n *\n * Shorthand for {@link createBinaryExpression} with the `GreaterThanEqualsToken`\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 createGreaterThanEquals = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanEqualsToken, right);\n//# sourceMappingURL=createGreaterThanEquals.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,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":["../../../esm-tmp/factory/expressions/createImmediatelyInvokedArrowFunction.js"],"sourcesContent":["import { createBlock } from \"../statements/createBlock\";\nimport { createArrowFunction } from \"./createArrowFunction\";\nimport { createCallExpression } from \"./createCallExpression\";\nimport { createParenthesizedExpression } from \"./createParenthesizedExpression\";\n/**\n * Create an immediately-invoked arrow function: `(() => { ... })()`.\n *\n * The `statements` become the body of a parameterless arrow function whose\n * block is forced multi-line. The arrow is wrapped in parentheses with\n * {@link createParenthesizedExpression} and then called with no arguments via\n * {@link createCallExpression}.\n *\n * Given a single `return 1;` statement, the printer emits:\n *\n * ```ts\n * (() => {\n *   return 1;\n * })();\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The body statements.\n * @returns The created {@link CallExpression}.\n */\nexport const createImmediatelyInvokedArrowFunction = (statements) => createCallExpression(createParenthesizedExpression(createArrowFunction(undefined, undefined, [], undefined, undefined, createBlock(statements, true))), undefined, []);\n//# sourceMappingURL=createImmediatelyInvokedArrowFunction.js.map"],"names":[],"mappings":";;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qCAAqC,GAAG,CAAC,UAAU,KAAK,oBAAoB,CAAC,6BAA6B,CAAC,mBAAmB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,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":["../../../esm-tmp/factory/expressions/createImmediatelyInvokedFunctionExpression.js"],"sourcesContent":["import { createBlock } from \"../statements/createBlock\";\nimport { createCallExpression } from \"./createCallExpression\";\nimport { createFunctionExpression } from \"./createFunctionExpression\";\nimport { createParenthesizedExpression } from \"./createParenthesizedExpression\";\n/**\n * Create an immediately-invoked function expression: `(function () { ... })()`.\n *\n * The `statements` become the body of an anonymous function expression whose\n * block is forced multi-line. The function is wrapped in parentheses with\n * {@link createParenthesizedExpression} and then called with no arguments via\n * {@link createCallExpression}.\n *\n * Given a single `return 1;` statement, the printer emits:\n *\n * ```ts\n * (function () {\n *   return 1;\n * })();\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param statements The body statements.\n * @returns The created {@link CallExpression}.\n */\nexport const createImmediatelyInvokedFunctionExpression = (statements) => createCallExpression(createParenthesizedExpression(createFunctionExpression(undefined, undefined, undefined, undefined, [], undefined, createBlock(statements, true))), undefined, []);\n//# sourceMappingURL=createImmediatelyInvokedFunctionExpression.js.map"],"names":[],"mappings":";;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,0CAA0C,GAAG,CAAC,UAAU,KAAK,oBAAoB,CAAC,6BAA6B,CAAC,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE;;;;"}

package/lib/factory/expressions/createInequality.mjs

@@ -0,0 +1,26 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createInequality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `!=` operator: loose inequality\n * with type coercion.\n *\n * Shorthand for {@link createBinaryExpression} with the `ExclamationEqualsToken`\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 createInequality = (left, right) => createBinaryExpression(left, SyntaxKind.ExclamationEqualsToken, right);\n//# sourceMappingURL=createInequality.js.map"],"names":[],"mappings":";;;AAEA;AACA;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,sBAAsB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLeftShift.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createLeftShift.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `<<` operator: bitwise left shift.\n *\n * Shorthand for {@link createBinaryExpression} with the `LessThanLessThanToken`\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 value to shift.\n * @param right The shift amount.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createLeftShift = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanLessThanToken, right);\n//# sourceMappingURL=createLeftShift.js.map"],"names":[],"mappings":";;;AAEA;AACA;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,qBAAqB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLessThan.mjs

@@ -0,0 +1,25 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createLessThan.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `<` operator: less-than comparison.\n *\n * Shorthand for {@link createBinaryExpression} with the `LessThanToken`\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 createLessThan = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanToken, right);\n//# sourceMappingURL=createLessThan.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,aAAa,EAAE,KAAK;;;;"}