@ttsc/factory 0.15.9 → 0.15.10

package/lib/factory/expressions/createPrefixMinus.mjs

@@ -0,0 +1,22 @@
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createPrefixMinus.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a unary minus expression: `-operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `-` operator.\n *\n * With `operand` of `1`, the printer emits:\n *\n * ```ts\n * -1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand to negate.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixMinus = (operand) => createPrefixUnaryExpression(SyntaxKind.MinusToken, operand);\n//# sourceMappingURL=createPrefixMinus.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createPrefixPlus.mjs

@@ -0,0 +1,22 @@
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createPrefixPlus.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a unary plus expression: `+operand`.\n *\n * Thin wrapper over {@link createPrefixUnaryExpression} with the `+` operator.\n *\n * With `operand` of `a`, the printer emits:\n *\n * ```ts\n * +a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operand The operand.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixPlus = (operand) => createPrefixUnaryExpression(SyntaxKind.PlusToken, operand);\n//# sourceMappingURL=createPrefixPlus.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gBAAgB,GAAG,CAAC,OAAO,KAAK,2BAA2B,CAAC,UAAU,CAAC,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":["../../../esm-tmp/factory/expressions/createPrefixUnaryExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link PrefixUnaryExpression}: a unary operator that precedes its\n * operand.\n *\n * `operator` is the leading token, one of `+`, `-`, `~`, `!`, `++`, or `--`,\n * and `operand` is the target. The printer writes the operator immediately\n * before the operand with no space.\n *\n * With `operator` of `-` and `operand` of `1`, the printer emits:\n *\n * ```ts\n * -1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param operator The leading operator token.\n * @param operand The operand.\n * @returns The created {@link PrefixUnaryExpression}.\n */\nexport const createPrefixUnaryExpression = (operator, operand) => make(\"PrefixUnaryExpression\", { operator, operand });\n//# sourceMappingURL=createPrefixUnaryExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,CAAC,QAAQ,EAAE,OAAO,KAAK,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":["../../../esm-tmp/factory/expressions/createPropertyAccessChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link PropertyAccessChain}: a member access that participates in an\n * optional chain, such as `a?.b`.\n *\n * `expression` is the receiver and `name` is the accessed member; a string\n * `name` is wrapped in an identifier. `questionDotToken`, when present, makes\n * this link optional and prints as `?.`; when omitted the printer emits a plain\n * `.` while the node still carries chain context.\n *\n * With `expression` of `a`, a `?.` token, and `name` of `b`, the printer emits:\n *\n * ```ts\n * a?.b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The receiver expression.\n * @param questionDotToken The optional `?.` token, if this link is optional.\n * @param name The accessed member name.\n * @returns The created {@link PropertyAccessChain}.\n */\nexport const createPropertyAccessChain = (expression, questionDotToken, name) => make(\"PropertyAccessChain\", {\n    expression,\n    questionDotToken,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n});\n//# sourceMappingURL=createPropertyAccessChain.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,yBAAyB,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE;AAC7G,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,CAAC;;;;"}

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":["../../../esm-tmp/factory/expressions/createPropertyAccessExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link PropertyAccessExpression}: a dotted member access like `a.b`.\n *\n * `expression` is the receiver and `name` is the accessed member; a string\n * `name` is wrapped in an identifier. The printer joins them with a single dot\n * and no surrounding space.\n *\n * With `expression` of `a` and `name` of `b`, the printer emits:\n *\n * ```ts\n * a.b;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The receiver expression.\n * @param name The accessed member name.\n * @returns The created {@link PropertyAccessExpression}.\n */\nexport const createPropertyAccessExpression = (expression, name) => make(\"PropertyAccessExpression\", {\n    expression,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n});\n//# sourceMappingURL=createPropertyAccessExpression.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,8BAA8B,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,0BAA0B,EAAE;AACrG,IAAI,UAAU;AACd,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,CAAC;;;;"}

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":["../../../esm-tmp/factory/expressions/createPropertyAssignment.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertyAssignment}: a `name: value` member of an object\n * literal.\n *\n * `name` is the property key; a string is converted to a property name node.\n * `initializer` is the assigned value. The printer joins them with a colon and\n * a single space.\n *\n * With `name` of `a` and `initializer` of `1`, the printer emits:\n *\n * ```ts\n * a: 1;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The property name.\n * @param initializer The assigned value.\n * @returns The created {@link PropertyAssignment}.\n */\nexport const createPropertyAssignment = (name, initializer) => make(\"PropertyAssignment\", { name: asPropertyName(name), initializer });\n//# sourceMappingURL=createPropertyAssignment.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,wBAAwB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,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":["../../../esm-tmp/factory/expressions/createRegularExpressionLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link RegularExpressionLiteral}: a regex literal.\n *\n * `text` is the complete literal source, including the slash delimiters and any\n * trailing flags. The printer emits `text` verbatim; it does not validate or\n * re-escape the pattern.\n *\n * With `text` of `/ab+c/i`, the printer emits:\n *\n * ```ts\n * /ab+c/i;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The full regex literal source, including delimiters and flags.\n * @returns The created {@link RegularExpressionLiteral}.\n */\nexport const createRegularExpressionLiteral = (text) => make(\"RegularExpressionLiteral\", { text });\n//# sourceMappingURL=createRegularExpressionLiteral.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,8BAA8B,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,0BAA0B,EAAE,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createRightShift.mjs

@@ -0,0 +1,23 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createRightShift.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a signed right-shift expression: `left >> right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `>>` operator.\n *\n * With `left` of `a` and `right` of `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 createRightShift = (left, right) => createBinaryExpression(left, SyntaxKind.GreaterThanGreaterThanToken, right);\n//# sourceMappingURL=createRightShift.js.map"],"names":[],"mappings":";;;AAEA;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,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":["../../../esm-tmp/factory/expressions/createSatisfiesExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SatisfiesExpression}: an expression checked against a type\n * with `satisfies`.\n *\n * `expression` is the value and `type` is the type it must conform to without\n * widening or narrowing its inferred type. The printer joins them with the\n * `satisfies` keyword surrounded by single spaces.\n *\n * With `expression` of `x` and `type` of `Foo`, the printer emits:\n *\n * ```ts\n * x satisfies Foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression to check.\n * @param type The type the expression must satisfy.\n * @returns The created {@link SatisfiesExpression}.\n */\nexport const createSatisfiesExpression = (expression, type) => make(\"SatisfiesExpression\", { expression, type });\n//# sourceMappingURL=createSatisfiesExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,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":["../../../esm-tmp/factory/expressions/createShorthandPropertyAssignment.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link ShorthandPropertyAssignment}: an object member that reuses a\n * variable name as both key and value, like `{ a }`.\n *\n * `name` is the shared property name. `objectAssignmentInitializer` is only\n * valid when the literal is the target of a destructuring assignment; when\n * present the printer appends `=` and the default value, otherwise it emits the\n * name alone.\n *\n * With `name` of `a` and no initializer, the printer emits:\n *\n * ```ts\n * a;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The shared property name.\n * @param objectAssignmentInitializer The default value for object\n *   destructuring, if any.\n * @returns The created {@link ShorthandPropertyAssignment}.\n */\nexport const createShorthandPropertyAssignment = (name, objectAssignmentInitializer) => make(\"ShorthandPropertyAssignment\", {\n    name: asName(name),\n    objectAssignmentInitializer,\n});\n//# sourceMappingURL=createShorthandPropertyAssignment.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,iCAAiC,GAAG,CAAC,IAAI,EAAE,2BAA2B,KAAK,IAAI,CAAC,6BAA6B,EAAE;AAC5H,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,2BAA2B;AAC/B,CAAC;;;;"}

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":["../../../esm-tmp/factory/expressions/createSpreadAssignment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SpreadAssignment}: a `...expression` member that spreads one\n * object's properties into an object literal.\n *\n * `expression` is the source object. The printer prefixes it with `...` and no\n * separating space.\n *\n * With `expression` of `a` inside an object literal, the printer emits:\n *\n * ```ts\n * { ...a }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The object expression to spread.\n * @returns The created {@link SpreadAssignment}.\n */\nexport const createSpreadAssignment = (expression) => make(\"SpreadAssignment\", { expression });\n//# sourceMappingURL=createSpreadAssignment.js.map"],"names":[],"mappings":";;AACA;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/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":["../../../esm-tmp/factory/expressions/createSpreadElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SpreadElement}: a `...expression` element that spreads an\n * iterable into an array literal or argument list.\n *\n * `expression` is the source iterable. The printer prefixes it with `...` and\n * no separating space.\n *\n * With `expression` of `a` inside an array literal, the printer emits:\n *\n * ```ts\n * [...a];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The iterable expression to spread.\n * @returns The created {@link SpreadElement}.\n */\nexport const createSpreadElement = (expression) => make(\"SpreadElement\", { expression });\n//# sourceMappingURL=createSpreadElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createStrictEquality.mjs

@@ -0,0 +1,23 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createStrictEquality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a strict equality expression: `left === right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `===` operator.\n *\n * With `left` of `a` and `right` of `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 createStrictEquality = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsEqualsEqualsToken, right);\n//# sourceMappingURL=createStrictEquality.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,uBAAuB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createStrictInequality.mjs

@@ -0,0 +1,23 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.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":["../../../esm-tmp/factory/expressions/createStrictInequality.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a strict inequality expression: `left !== right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `!==` operator.\n *\n * With `left` of `a` and `right` of `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 createStrictInequality = (left, right) => createBinaryExpression(left, SyntaxKind.ExclamationEqualsEqualsToken, right);\n//# sourceMappingURL=createStrictInequality.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,4BAA4B,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createSubtract.mjs

@@ -0,0 +1,23 @@
+import { createBinaryExpression } from './createBinaryExpression.mjs';
+import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+
+/**
+ * Create a subtraction 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 createSubtract = (left, right) => createBinaryExpression(left, SyntaxKind.MinusToken, right);
+
+export { createSubtract };
+//# sourceMappingURL=createSubtract.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createSubtract.mjs","sources":["../../../esm-tmp/factory/expressions/createSubtract.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a subtraction expression: `left - right`.\n *\n * Thin wrapper over {@link createBinaryExpression} with the `-` operator.\n *\n * With `left` of `a` and `right` of `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 createSubtract = (left, right) => createBinaryExpression(left, SyntaxKind.MinusToken, right);\n//# sourceMappingURL=createSubtract.js.map"],"names":[],"mappings":";;;AAEA;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,UAAU,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createTaggedTemplateExpression.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TaggedTemplateExpression}: a template literal invoked by a tag
+ * function.
+ *
+ * `tag` is the function applied to the template, `typeArguments` are its
+ * optional generic arguments, and `template` is the template literal itself.
+ * The printer writes the tag directly against the template with no space
+ * between them.
+ *
+ * With `tag` of `tag` and a template of ``hi``, the printer emits:
+ *
+ * ```ts
+ * tag`hi`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tag The tag expression applied to the template.
+ * @param typeArguments The generic type arguments, if any.
+ * @param template The template literal.
+ * @returns The created {@link TaggedTemplateExpression}.
+ */
+const createTaggedTemplateExpression = (tag, typeArguments, template) => make("TaggedTemplateExpression", { tag, typeArguments, template });
+
+export { createTaggedTemplateExpression };
+//# sourceMappingURL=createTaggedTemplateExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTaggedTemplateExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createTaggedTemplateExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TaggedTemplateExpression}: a template literal invoked by a tag\n * function.\n *\n * `tag` is the function applied to the template, `typeArguments` are its\n * optional generic arguments, and `template` is the template literal itself.\n * The printer writes the tag directly against the template with no space\n * between them.\n *\n * With `tag` of `tag` and a template of ``hi``, the printer emits:\n *\n * ```ts\n * tag`hi`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tag The tag expression applied to the template.\n * @param typeArguments The generic type arguments, if any.\n * @param template The template literal.\n * @returns The created {@link TaggedTemplateExpression}.\n */\nexport const createTaggedTemplateExpression = (tag, typeArguments, template) => make(\"TaggedTemplateExpression\", { tag, typeArguments, template });\n//# sourceMappingURL=createTaggedTemplateExpression.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;AACY,MAAC,8BAA8B,GAAG,CAAC,GAAG,EAAE,aAAa,EAAE,QAAQ,KAAK,IAAI,CAAC,0BAA0B,EAAE,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/expressions/createTemplateExpression.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateExpression}: a template literal with one or more
+ * interpolations.
+ *
+ * `head` is the leading text up to the first `${`, and each entry in
+ * `templateSpans` pairs an interpolated expression with the literal text that
+ * follows it. The printer wraps the whole thing in backticks and renders each
+ * span as `${expression}` followed by its trailing text.
+ *
+ * With `head` of `a`, a span interpolating `x` and a tail of `b`, the printer
+ * emits:
+ *
+ * ```ts
+ * `a${x}b`;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param head The leading literal text before the first interpolation.
+ * @param templateSpans The interpolation spans.
+ * @returns The created {@link TemplateExpression}.
+ */
+const createTemplateExpression = (head, templateSpans) => make("TemplateExpression", { head, templateSpans });
+
+export { createTemplateExpression };
+//# sourceMappingURL=createTemplateExpression.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createTemplateExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateExpression}: a template literal with one or more\n * interpolations.\n *\n * `head` is the leading text up to the first `${`, and each entry in\n * `templateSpans` pairs an interpolated expression with the literal text that\n * follows it. The printer wraps the whole thing in backticks and renders each\n * span as `${expression}` followed by its trailing text.\n *\n * With `head` of `a`, a span interpolating `x` and a tail of `b`, the printer\n * emits:\n *\n * ```ts\n * `a${x}b`;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param head The leading literal text before the first interpolation.\n * @param templateSpans The interpolation spans.\n * @returns The created {@link TemplateExpression}.\n */\nexport const createTemplateExpression = (head, templateSpans) => make(\"TemplateExpression\", { head, templateSpans });\n//# sourceMappingURL=createTemplateExpression.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;AACY,MAAC,wBAAwB,GAAG,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,CAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/expressions/createTemplateSpan.mjs

@@ -0,0 +1,28 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TemplateSpan}: one interpolation segment of a template
+ * literal.
+ *
+ * A span pairs `expression`, the interpolated value, with `literal`, the static
+ * text that follows it. `literal` is a {@link TemplateMiddle} when more spans
+ * follow or a {@link TemplateTail} for the last one. Spans are not standalone
+ * expressions; they live inside a {@link TemplateExpression}, which supplies the
+ * leading head and the surrounding backticks.
+ *
+ * With `expression` of `x` and a tail literal of `b`, the printer emits the
+ * fragment:
+ *
+ * ```ts
+ * x}b`
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The interpolated expression.
+ * @param literal The static text following the interpolation.
+ * @returns The created {@link TemplateSpan}.
+ */
+const createTemplateSpan = (expression, literal) => make("TemplateSpan", { expression, literal });
+
+export { createTemplateSpan };
+//# sourceMappingURL=createTemplateSpan.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTemplateSpan.mjs","sources":["../../../esm-tmp/factory/expressions/createTemplateSpan.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TemplateSpan}: one interpolation segment of a template\n * literal.\n *\n * A span pairs `expression`, the interpolated value, with `literal`, the static\n * text that follows it. `literal` is a {@link TemplateMiddle} when more spans\n * follow or a {@link TemplateTail} for the last one. Spans are not standalone\n * expressions; they live inside a {@link TemplateExpression}, which supplies the\n * leading head and the surrounding backticks.\n *\n * With `expression` of `x` and a tail literal of `b`, the printer emits the\n * fragment:\n *\n * ```ts\n * x}b`\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The interpolated expression.\n * @param literal The static text following the interpolation.\n * @returns The created {@link TemplateSpan}.\n */\nexport const createTemplateSpan = (expression, literal) => make(\"TemplateSpan\", { expression, literal });\n//# sourceMappingURL=createTemplateSpan.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,kBAAkB,GAAG,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/expressions/createTypeAssertion.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeAssertion}: the angle-bracket cast form `<Type>expr`.
+ *
+ * `type` is the asserted type and `expression` is the value being cast. The
+ * printer wraps the type in angle brackets and places it before the expression
+ * with no space. This is the older cast syntax; the `as` form is a separate
+ * node.
+ *
+ * With `type` of `Foo` and `expression` of `x`, the printer emits:
+ *
+ * ```ts
+ * <Foo>x
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The asserted type.
+ * @param expression The expression to cast.
+ * @returns The created {@link TypeAssertion}.
+ */
+const createTypeAssertion = (type, expression) => make("TypeAssertion", { type, expression });
+
+export { createTypeAssertion };
+//# sourceMappingURL=createTypeAssertion.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTypeAssertion.mjs","sources":["../../../esm-tmp/factory/expressions/createTypeAssertion.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link TypeAssertion}: the angle-bracket cast form `<Type>expr`.\n *\n * `type` is the asserted type and `expression` is the value being cast. The\n * printer wraps the type in angle brackets and places it before the expression\n * with no space. This is the older cast syntax; the `as` form is a separate\n * node.\n *\n * With `type` of `Foo` and `expression` of `x`, the printer emits:\n *\n * ```ts\n * <Foo>x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The asserted type.\n * @param expression The expression to cast.\n * @returns The created {@link TypeAssertion}.\n */\nexport const createTypeAssertion = (type, expression) => make(\"TypeAssertion\", { type, expression });\n//# sourceMappingURL=createTypeAssertion.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createTypeOfExpression.mjs

@@ -0,0 +1,22 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link TypeOfExpression}: the `typeof` operator applied to a value.
+ *
+ * `expression` is the operand. The printer writes the `typeof` keyword followed
+ * by a single space and then the operand.
+ *
+ * With `expression` of `x`, the printer emits:
+ *
+ * ```ts
+ * typeof x;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param expression The operand of `typeof`.
+ * @returns The created {@link TypeOfExpression}.
+ */
+const createTypeOfExpression = (expression) => make("TypeOfExpression", { expression });
+
+export { createTypeOfExpression };
+//# sourceMappingURL=createTypeOfExpression.mjs.map