@ttsc/factory 0.15.10 → 0.16.0

package/lib/factory/declarations/createModuleDeclaration.mjs

@@ -1,6 +1,7 @@
+import '../../syntax/SyntaxKind.mjs';
+import { NodeFlags } from '../../syntax/NodeFlags.mjs';
 import { make } from '../internal/make.mjs';
 import { createIdentifier } from '../names/createIdentifier.mjs';
-import { NodeFlags } from '../../syntax/NodeFlags.mjs';
 
 /**
  * Create a {@link ModuleDeclaration}: a `namespace X { ... }` or `module X { ...

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

@@ -1 +1 @@
-{"version":3,"file":"createModuleDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createModuleDeclaration.js"],"sourcesContent":["import { NodeFlags } from \"../../syntax\";\nimport { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link ModuleDeclaration}: a `namespace X { ... }` or `module X { ...\n * }`.\n *\n * The `modifiers` precede the keyword, so an `export` modifier prints `export\n * namespace`. The `name` accepts a string, which is wrapped in an identifier,\n * or a prebuilt module name. The `body` is the brace block, normally a\n * {@link ModuleBlock}, whose statements the printer indents one per line.\n *\n * The `flags` decide the keyword the printer emits: the `Namespace` flag prints\n * `namespace`, while the default prints `module`. This is the one input that\n * does not show up as text directly but changes the rendered keyword.\n *\n * Given an `export` modifier, the name `app`, a body holding `export type ID =\n * string;`, and the `Namespace` flag, the printed declaration is:\n *\n * ```ts\n * export namespace app {\n *   export type ID = string;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers, if any.\n * @param name The name.\n * @param body The body.\n * @param flags The node flags that select the `namespace` or `module` keyword.\n * @returns The created {@link ModuleDeclaration}.\n */\nexport const createModuleDeclaration = (modifiers, name, body, flags = NodeFlags.None) => make(\"ModuleDeclaration\", {\n    modifiers,\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n    body,\n    flags,\n});\n//# sourceMappingURL=createModuleDeclaration.js.map"],"names":[],"mappings":";;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACpH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,IAAI,IAAI;AACR,IAAI,KAAK;AACT,CAAC;;;;"}
+{"version":3,"file":"createModuleDeclaration.mjs","sources":["../../../src/factory/declarations/createModuleDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;MACU,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,IAAyB,EACzB,IAA4B,EAC5B,KAAA,GAAmB,SAAS,CAAC,IAAI,KAEjC,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;AACT,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAC9D,IAAI;IACJ,KAAK;AACN,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createNamespaceExportDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createNamespaceExportDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link NamespaceExportDeclaration}: an `export as namespace X;`.\n *\n * This is the UMD global declaration used in `.d.ts` files to state the global\n * variable name under which the module is exposed in a script context. The\n * `name` is that global identifier.\n *\n * Given the name `App`, the printed declaration is:\n *\n * ```ts\n * export as namespace App;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @returns The created {@link NamespaceExportDeclaration}.\n */\nexport const createNamespaceExportDeclaration = (name) => make(\"NamespaceExportDeclaration\", { name: asName(name) });\n//# sourceMappingURL=createNamespaceExportDeclaration.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,gCAAgC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}
+{"version":3,"file":"createNamespaceExportDeclaration.mjs","sources":["../../../src/factory/declarations/createNamespaceExportDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,gCAAgC,GAAG,CAC9C,IAAyB,KAEzB,IAAI,CAAC,4BAA4B,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createPropertyDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createPropertyDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link PropertyDeclaration}: a class field such as `x: number;`.\n *\n * The `modifiers` precede the property name, so `public readonly` prints in\n * that order. Any decorators among the modifiers are hoisted onto their own\n * lines above the property. The `name` is the field key, and the\n * `questionOrExclamationToken` appends either the optional marker (`?`) or the\n * definite-assignment marker (`!`) after the name.\n *\n * The optional `type` prints after a colon, and the optional `initializer`\n * prints after an `=`. The printer terminates the field with a semicolon.\n *\n * Given `public readonly` modifiers, the name `id`, a `string` type, and a\n * string-literal initializer of `\"x\"`, the printed field is:\n *\n * ```ts\n * public readonly id: string = \"x\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param questionOrExclamationToken The optional (`?`) or definite-assignment\n *   (`!`) marker, if any.\n * @param type The type.\n * @param initializer The initializer, if any.\n * @returns The created {@link PropertyDeclaration}.\n */\nexport const createPropertyDeclaration = (modifiers, name, questionOrExclamationToken, type, initializer) => make(\"PropertyDeclaration\", {\n    modifiers,\n    name: asPropertyName(name),\n    questionOrExclamationToken,\n    type,\n    initializer,\n});\n//# sourceMappingURL=createPropertyDeclaration.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;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,0BAA0B,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,qBAAqB,EAAE;AACzI,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,0BAA0B;AAC9B,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC;;;;"}
+{"version":3,"file":"createPropertyDeclaration.mjs","sources":["../../../src/factory/declarations/createPropertyDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BG;MACU,yBAAyB,GAAG,CACvC,SAA8C,EAC9C,IAA2B,EAC3B,0BAA6C,EAC7C,IAA0B,EAC1B,WAAmC,KAEnC,IAAI,CAAC,qBAAqB,EAAE;IAC1B,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,0BAA0B;IAC1B,IAAI;IACJ,WAAW;AACZ,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createSemicolonClassElement.mjs","sources":["../../../esm-tmp/factory/declarations/createSemicolonClassElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link SemicolonClassElement}: a stray `;` in a class body.\n *\n * This is an empty class member, a lone semicolon that TypeScript permits\n * between real members. It carries no name or body. Placed inside a class, the\n * printer emits it as a single semicolon on its own line:\n *\n * ```ts\n * class C {}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link SemicolonClassElement}.\n */\nexport const createSemicolonClassElement = () => make(\"SemicolonClassElement\", {});\n//# sourceMappingURL=createSemicolonClassElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,2BAA2B,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createSemicolonClassElement.mjs","sources":["../../../src/factory/declarations/createSemicolonClassElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;AAaG;AACI,MAAM,2BAA2B,GAAG,MACzC,IAAI,CAAC,uBAAuB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createSetAccessorDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createSetAccessorDeclaration.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link SetAccessorDeclaration}: a `set x(value) { ... }` accessor.\n *\n * The `modifiers` precede the `set` keyword, so a `public` modifier prints\n * `public set`. The `name` is the accessor key. A setter takes exactly one\n * value parameter, supplied through `parameters`, and has no return type. The\n * `body` block holds the statements, indented one per line.\n *\n * Given a `public` modifier, the name `value`, a single `value: number`\n * parameter, and a body assigning `this._value = value`, the printed accessor\n * is:\n *\n * ```ts\n * public set value(value: number) {\n *   this._value = value;\n * }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param parameters The parameters.\n * @param body The body.\n * @returns The created {@link SetAccessorDeclaration}.\n */\nexport const createSetAccessorDeclaration = (modifiers, name, parameters, body) => make(\"SetAccessorDeclaration\", {\n    modifiers,\n    name: asPropertyName(name),\n    parameters,\n    body,\n});\n//# sourceMappingURL=createSetAccessorDeclaration.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;AACA;AACA;AACY,MAAC,4BAA4B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,wBAAwB,EAAE;AAClH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;AAC9B,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createSetAccessorDeclaration.mjs","sources":["../../../src/factory/declarations/createSetAccessorDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,4BAA4B,GAAG,CAC1C,SAA8C,EAC9C,IAA2B,EAC3B,UAA2C,EAC3C,IAAuB,KAEvB,IAAI,CAAC,wBAAwB,EAAE;IAC7B,SAAS;AACT,IAAA,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC;IAC1B,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createTypeAliasDeclaration.mjs","sources":["../../../esm-tmp/factory/declarations/createTypeAliasDeclaration.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link TypeAliasDeclaration}: a `type X = ...;`.\n *\n * The `modifiers` precede the `type` keyword, so an `export` modifier prints\n * `export type`. The `name` accepts a string or identifier, and\n * `typeParameters` add the generic `<...>` list when present. The `type` is the\n * aliased type printed after the `=`, and the printer terminates the statement\n * with a semicolon.\n *\n * Given an `export` modifier, the name `ID`, and a `string` type, the printed\n * declaration is:\n *\n * ```ts\n * export type ID = string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param name The name.\n * @param typeParameters The generic type parameters, if any.\n * @param type The type.\n * @returns The created {@link TypeAliasDeclaration}.\n */\nexport const createTypeAliasDeclaration = (modifiers, name, typeParameters, type) => make(\"TypeAliasDeclaration\", {\n    modifiers,\n    name: asName(name),\n    typeParameters,\n    type,\n});\n//# sourceMappingURL=createTypeAliasDeclaration.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,0BAA0B,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,KAAK,IAAI,CAAC,sBAAsB,EAAE;AAClH,IAAI,SAAS;AACb,IAAI,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;AACtB,IAAI,cAAc;AAClB,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createTypeAliasDeclaration.mjs","sources":["../../../src/factory/declarations/createTypeAliasDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,0BAA0B,GAAG,CACxC,SAA8C,EAC9C,IAAyB,EACzB,cAA+D,EAC/D,IAAc,KAEd,IAAI,CAAC,sBAAsB,EAAE;IAC3B,SAAS;AACT,IAAA,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IAClB,cAAc;IACd,IAAI;AACL,CAAA;;;;"}

package/lib/factory/expressions/createAdd.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `+` operator: addition or string

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

@@ -1 +1 @@
-{"version":3,"file":"createAdd.mjs","sources":["../../../esm-tmp/factory/expressions/createAdd.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `+` operator: addition or string\n * concatenation.\n *\n * Shorthand for {@link createBinaryExpression} with the `PlusToken` 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 createAdd = (left, right) => createBinaryExpression(left, SyntaxKind.PlusToken, right);\n//# sourceMappingURL=createAdd.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,SAAS,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK;;;;"}
+{"version":3,"file":"createAdd.mjs","sources":["../../../src/factory/expressions/createAdd.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,SAAS,GAAG,CACvB,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createArrayBindingPattern.mjs","sources":["../../../esm-tmp/factory/expressions/createArrayBindingPattern.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayBindingPattern}: the `[a, b]` binding used in array\n * destructuring.\n *\n * The elements are {@link BindingElement} nodes or omitted-element holes. The\n * printer wraps them in square brackets, separated by a comma and a space.\n *\n * Given two binding elements named `a` and `b`, the printer emits:\n *\n * ```ts\n * [a, b];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The binding elements.\n * @returns The created {@link ArrayBindingPattern}.\n */\nexport const createArrayBindingPattern = (elements) => make(\"ArrayBindingPattern\", { elements });\n//# sourceMappingURL=createArrayBindingPattern.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;;;;"}
+{"version":3,"file":"createArrayBindingPattern.mjs","sources":["../../../src/factory/expressions/createArrayBindingPattern.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,QAAwC,KAChB,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createArrayLiteralExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createArrayLiteralExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrayLiteralExpression}: an `[...]` array literal.\n *\n * The elements may include {@link SpreadElement} and omitted holes. When\n * `multiLine` is `false` (the default) the printer keeps the array on one line\n * with comma-and-space separators. When `multiLine` is `true` it places each\n * element on its own indented line and appends a trailing comma.\n *\n * Given elements `1`, `2`, `3` on a single line, the printer emits:\n *\n * ```ts\n * [1, 2, 3];\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The element expressions.\n * @param multiLine When `true`, print one entry per line.\n * @returns The created {@link ArrayLiteralExpression}.\n */\nexport const createArrayLiteralExpression = (elements = [], multiLine) => make(\"ArrayLiteralExpression\", { elements, multiLine });\n//# sourceMappingURL=createArrayLiteralExpression.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,4BAA4B,GAAG,CAAC,QAAQ,GAAG,EAAE,EAAE,SAAS,KAAK,IAAI,CAAC,wBAAwB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}
+{"version":3,"file":"createArrayLiteralExpression.mjs","sources":["../../../src/factory/expressions/createArrayLiteralExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;MACU,4BAA4B,GAAG,CAC1C,QAAA,GAAkC,EAAE,EACpC,SAAmB,KAEnB,IAAI,CAAC,wBAAwB,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createArrowFunction.mjs","sources":["../../../esm-tmp/factory/expressions/createArrowFunction.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link ArrowFunction}: a `(params) => body` arrow function.\n *\n * The `body` is either a {@link Block} for a statement body or an\n * {@link Expression} for a concise body. The optional `modifiers`,\n * `typeParameters` and return `type` are printed when present. The\n * `_equalsGreaterThanToken` parameter exists only for signature parity with the\n * legacy factory and is ignored: the printer always emits `=>` between the\n * parameter list and the body.\n *\n * Given one parameter `x` and a concise body of `x`, the printer emits:\n *\n * ```ts\n * (x) => x;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, 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 _equalsGreaterThanToken Ignored; present only to mirror the legacy\n *   signature.\n * @param body The block or expression body.\n * @returns The created {@link ArrowFunction}.\n */\nexport const createArrowFunction = (modifiers, typeParameters, parameters, type, _equalsGreaterThanToken, body) => make(\"ArrowFunction\", { modifiers, typeParameters, parameters, type, body });\n//# sourceMappingURL=createArrowFunction.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;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,uBAAuB,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createArrowFunction.mjs","sources":["../../../src/factory/expressions/createArrowFunction.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,mBAAmB,GAAG,CACjC,SAA8C,EAC9C,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,uBAA0C,EAC1C,IAAwB,KAExB,IAAI,CAAC,eAAe,EAAE,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createAsExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createAsExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link AsExpression}: a TypeScript `expression as type` assertion.\n *\n * The printer writes the expression, the `as` keyword and the target type, each\n * separated by a single space.\n *\n * Given expression `value` and type `string`, the printer emits:\n *\n * ```ts\n * value as string;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The expression being asserted.\n * @param type The target type.\n * @returns The created {@link AsExpression}.\n */\nexport const createAsExpression = (expression, type) => make(\"AsExpression\", { expression, type });\n//# sourceMappingURL=createAsExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}
+{"version":3,"file":"createAsExpression.mjs","sources":["../../../src/factory/expressions/createAsExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;MACU,kBAAkB,GAAG,CAChC,UAAsB,EACtB,IAAc,KACG,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;;;;"}

package/lib/factory/expressions/createAssignment.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `=` operator: a simple assignment.

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

@@ -1 +1 @@
-{"version":3,"file":"createAssignment.mjs","sources":["../../../esm-tmp/factory/expressions/createAssignment.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `=` operator: a simple assignment.\n *\n * Shorthand for {@link createBinaryExpression} with the `EqualsToken` operator.\n * The left operand is the assignment target and the right operand is the value.\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 assignment target.\n * @param right The value to assign.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createAssignment = (left, right) => createBinaryExpression(left, SyntaxKind.EqualsToken, right);\n//# sourceMappingURL=createAssignment.js.map"],"names":[],"mappings":";;;AAEA;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,WAAW,EAAE,KAAK;;;;"}
+{"version":3,"file":"createAssignment.mjs","sources":["../../../src/factory/expressions/createAssignment.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,WAAW,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createAwaitExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createAwaitExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create an {@link AwaitExpression}: an `await` of an operand.\n *\n * The printer writes the `await` keyword followed by a single space and the\n * operand expression.\n *\n * Given operand `promise`, the printer emits:\n *\n * ```ts\n * await promise;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The awaited expression.\n * @returns The created {@link AwaitExpression}.\n */\nexport const createAwaitExpression = (expression) => make(\"AwaitExpression\", { expression });\n//# sourceMappingURL=createAwaitExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createAwaitExpression.mjs","sources":["../../../src/factory/expressions/createAwaitExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAsB,KACF,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createBinaryExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createBinaryExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link BinaryExpression}: two operands joined by an infix operator.\n *\n * The operator may be given as a `SyntaxKind` string (e.g. `\"+\"`, `\"===\"`,\n * `\"&&\"`) or as an operator {@link Token}, in which case its `token` value is\n * used. This is the base builder behind the operator-specific shorthands such\n * as {@link createAdd}, {@link createStrictEquality} and\n * {@link createLogicalAnd}.\n *\n * The printer surrounds the operator with a single space on each side.\n *\n * Given operands `a`, `b` and the `+` operator, 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 operator The operator token or its `SyntaxKind`.\n * @param right The right-hand operand.\n * @returns The created {@link BinaryExpression}.\n */\nexport const createBinaryExpression = (left, operator, right) => make(\"BinaryExpression\", {\n    left,\n    operator: typeof operator === \"object\" ? operator.token : operator,\n    right,\n});\n//# sourceMappingURL=createBinaryExpression.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;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC1F,IAAI,IAAI;AACR,IAAI,QAAQ,EAAE,OAAO,QAAQ,KAAK,QAAQ,GAAG,QAAQ,CAAC,KAAK,GAAG,QAAQ;AACtE,IAAI,KAAK;AACT,CAAC;;;;"}
+{"version":3,"file":"createBinaryExpression.mjs","sources":["../../../src/factory/expressions/createBinaryExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAIA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,sBAAsB,GAAG,CACpC,IAAgB,EAChB,QAA4B,EAC5B,KAAiB,KAEjB,IAAI,CAAC,kBAAkB,EAAE;IACvB,IAAI;AACJ,IAAA,QAAQ,EAAE,OAAO,QAAQ,KAAK,QAAQ,GAAI,QAAgB,CAAC,KAAK,GAAG,QAAQ;IAC3E,KAAK;AACN,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createBindingElement.mjs","sources":["../../../esm-tmp/factory/expressions/createBindingElement.js"],"sourcesContent":["import { asPropertyName } from \"../internal/asPropertyName\";\nimport { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link BindingElement}: one entry of an array or object binding\n * pattern.\n *\n * A `dotDotDotToken` marks a rest element. A `propertyName` (accepted as a\n * string or {@link PropertyName}, normalized with {@link asPropertyName}) maps a\n * source property to a different local `name`. A string `name` is wrapped with\n * {@link createIdentifier}. An `initializer` supplies a default value.\n *\n * The printer renders the parts as `...`, `propertyName: name` and `= default`,\n * each present only when supplied. A plain element named `a` prints as `a`;\n * with an initializer `def` it prints as `c = def`; a rest element named `rest`\n * prints as `...rest`. With a property name `src` mapping to local `dst` it\n * prints:\n *\n * ```ts\n * src: dst;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param dotDotDotToken The rest token, if this is a rest element.\n * @param propertyName The source property name, if renamed.\n * @param name The local binding name.\n * @param initializer The default-value initializer, if any.\n * @returns The created {@link BindingElement}.\n */\nexport const createBindingElement = (dotDotDotToken, propertyName, name, initializer) => make(\"BindingElement\", {\n    dotDotDotToken,\n    propertyName: propertyName === undefined ? undefined : asPropertyName(propertyName),\n    name: typeof name === \"string\" ? createIdentifier(name) : name,\n    initializer,\n});\n//# sourceMappingURL=createBindingElement.js.map"],"names":[],"mappings":";;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,cAAc,EAAE,YAAY,EAAE,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAChH,IAAI,cAAc;AAClB,IAAI,YAAY,EAAE,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,cAAc,CAAC,YAAY,CAAC;AACvF,IAAI,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;AAClE,IAAI,WAAW;AACf,CAAC;;;;"}
+{"version":3,"file":"createBindingElement.mjs","sources":["../../../src/factory/expressions/createBindingElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACI,MAAM,oBAAoB,GAAG,CAClC,cAAiC,EACjC,YAA+C,EAC/C,IAA0B,EAC1B,WAAwB,KAExB,IAAI,CAAC,gBAAgB,EAAE;IACrB,cAAc;AACd,IAAA,YAAY,EACV,YAAY,KAAK,SAAS,GAAG,SAAS,GAAG,cAAc,CAAC,YAAY,CAAC;AACvE,IAAA,IAAI,EAAE,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAC9D,WAAW;AACZ,CAAA;;;;"}

package/lib/factory/expressions/createBitwiseAnd.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `&` operator: bitwise AND.

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

@@ -1 +1 @@
-{"version":3,"file":"createBitwiseAnd.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseAnd.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `&` operator: bitwise AND.\n *\n * Shorthand for {@link createBinaryExpression} with the `AmpersandToken`\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 createBitwiseAnd = (left, right) => createBinaryExpression(left, SyntaxKind.AmpersandToken, right);\n//# sourceMappingURL=createBitwiseAnd.js.map"],"names":[],"mappings":";;;AAEA;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,cAAc,EAAE,KAAK;;;;"}
+{"version":3,"file":"createBitwiseAnd.mjs","sources":["../../../src/factory/expressions/createBitwiseAnd.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,cAAc,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createBitwiseNot.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a {@link PrefixUnaryExpression} with the `~` operator: bitwise NOT.

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

@@ -1 +1 @@
-{"version":3,"file":"createBitwiseNot.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseNot.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a {@link PrefixUnaryExpression} with the `~` operator: bitwise NOT.\n *\n * Shorthand for {@link createPrefixUnaryExpression} with the `TildeToken`\n * operator. The printer writes the operator directly before the operand with no\n * separating space.\n *\n * Given operand `a`, the printer emits:\n *\n * ```ts\n * ~a;\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 createBitwiseNot = (operand) => createPrefixUnaryExpression(SyntaxKind.TildeToken, operand);\n//# sourceMappingURL=createBitwiseNot.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;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,UAAU,EAAE,OAAO;;;;"}
+{"version":3,"file":"createBitwiseNot.mjs","sources":["../../../src/factory/expressions/createBitwiseNot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,gBAAgB,GAAG,CAAC,OAAmB,KAClD,2BAA2B,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createBitwiseOr.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `|` operator: bitwise OR.

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

@@ -1 +1 @@
-{"version":3,"file":"createBitwiseOr.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseOr.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `|` operator: bitwise OR.\n *\n * Shorthand for {@link createBinaryExpression} with the `BarToken` operator. The\n * 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 createBitwiseOr = (left, right) => createBinaryExpression(left, SyntaxKind.BarToken, right);\n//# sourceMappingURL=createBitwiseOr.js.map"],"names":[],"mappings":";;;AAEA;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,QAAQ,EAAE,KAAK;;;;"}
+{"version":3,"file":"createBitwiseOr.mjs","sources":["../../../src/factory/expressions/createBitwiseOr.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,eAAe,GAAG,CAC7B,IAAgB,EAChB,KAAiB,KACI,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createBitwiseXor.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `^` operator: bitwise XOR.

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

@@ -1 +1 @@
-{"version":3,"file":"createBitwiseXor.mjs","sources":["../../../esm-tmp/factory/expressions/createBitwiseXor.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `^` operator: bitwise XOR.\n *\n * Shorthand for {@link createBinaryExpression} with the `CaretToken` 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 createBitwiseXor = (left, right) => createBinaryExpression(left, SyntaxKind.CaretToken, right);\n//# sourceMappingURL=createBitwiseXor.js.map"],"names":[],"mappings":";;;AAEA;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,UAAU,EAAE,KAAK;;;;"}
+{"version":3,"file":"createBitwiseXor.mjs","sources":["../../../src/factory/expressions/createBitwiseXor.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCallChain.mjs","sources":["../../../esm-tmp/factory/expressions/createCallChain.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallChain}: a call that participates in an optional chain.\n *\n * The `questionDotToken` is the `?.` token. When it sits directly before the\n * argument list the printer emits an optional call `fn?.(args)`; when the\n * callee is a property-access chain the `?.` appears at that link and the call\n * itself uses plain parentheses. The optional `typeArguments` are printed in\n * `<...>` before the arguments, and a missing `argumentsArray` is treated as an\n * empty list.\n *\n * Given a property-access chain `obj?.fn` and one argument `a`, the printer\n * emits:\n *\n * ```ts\n * obj?.fn(a);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The callee expression.\n * @param questionDotToken The `?.` token, if the call link is optional.\n * @param typeArguments The generic type arguments, if any.\n * @param argumentsArray The call arguments.\n * @returns The created {@link CallChain}.\n */\nexport const createCallChain = (expression, questionDotToken, typeArguments, argumentsArray) => make(\"CallChain\", {\n    expression,\n    questionDotToken,\n    typeArguments,\n    arguments: argumentsArray ?? [],\n});\n//# sourceMappingURL=createCallChain.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;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC,WAAW,EAAE;AAClH,IAAI,UAAU;AACd,IAAI,gBAAgB;AACpB,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc,IAAI,EAAE;AACnC,CAAC;;;;"}
+{"version":3,"file":"createCallChain.mjs","sources":["../../../src/factory/expressions/createCallChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,eAAe,GAAG,CAC7B,UAAsB,EACtB,gBAAmC,EACnC,aAA8C,EAC9C,cAAiD,KAEjD,IAAI,CAAC,WAAW,EAAE;IAChB,UAAU;IACV,gBAAgB;IAChB,aAAa;IACb,SAAS,EAAE,cAAc,IAAI,EAAE;AAChC,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createCallExpression.mjs","sources":["../../../esm-tmp/factory/expressions/createCallExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link CallExpression}: a function or method call.\n *\n * The optional `typeArguments` are printed in `<...>` before the argument list.\n * The arguments are printed comma separated inside the parentheses, and a\n * missing `argumentsArray` is treated as an empty list.\n *\n * Given callee `fn` and arguments `a`, `b`, the printer emits:\n *\n * ```ts\n * fn(a, b);\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param expression The callee expression.\n * @param typeArguments The generic type arguments, if any.\n * @param argumentsArray The call arguments.\n * @returns The created {@link CallExpression}.\n */\nexport const createCallExpression = (expression, typeArguments, argumentsArray) => make(\"CallExpression\", {\n    expression,\n    typeArguments,\n    arguments: argumentsArray ?? [],\n});\n//# sourceMappingURL=createCallExpression.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,oBAAoB,GAAG,CAAC,UAAU,EAAE,aAAa,EAAE,cAAc,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAC1G,IAAI,UAAU;AACd,IAAI,aAAa;AACjB,IAAI,SAAS,EAAE,cAAc,IAAI,EAAE;AACnC,CAAC;;;;"}
+{"version":3,"file":"createCallExpression.mjs","sources":["../../../src/factory/expressions/createCallExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,oBAAoB,GAAG,CAClC,UAAsB,EACtB,aAA8C,EAC9C,cAAiD,KAEjD,IAAI,CAAC,gBAAgB,EAAE;IACrB,UAAU;IACV,aAAa;IACb,SAAS,EAAE,cAAc,IAAI,EAAE;AAChC,CAAA;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createClassExpression.mjs","sources":["../../../src/factory/expressions/createClassExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAWA;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,qBAAqB,GAAG,CACnC,SAA8C,EAC9C,IAAqC,EACrC,cAA+D,EAC/D,eAAsD,EACtD,OAAgC,KAEhC,IAAI,CAAC,iBAAiB,EAAE;IACtB,SAAS;AACT,IAAA,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;IACnD,cAAc;IACd,eAAe;IACf,OAAO;AACR,CAAA;;;;"}

package/lib/factory/expressions/createComma.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `,` operator: the comma operator,

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createComma.mjs","sources":["../../../src/factory/expressions/createComma.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;;AAmBG;MACU,WAAW,GAAG,CACzB,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createCommaListExpression.mjs","sources":["../../../src/factory/expressions/createCommaListExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,yBAAyB,GAAG,CACvC,QAA+B,KACP,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createComputedPropertyName.mjs","sources":["../../../src/factory/expressions/createComputedPropertyName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,0BAA0B,GAAG,CACxC,UAAsB,KACG,IAAI,CAAC,sBAAsB,EAAE,EAAE,UAAU,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createConditionalExpression.mjs","sources":["../../../src/factory/expressions/createConditionalExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,2BAA2B,GAAG,CACzC,SAAqB,EACrB,cAAiC,EACjC,QAAoB,EACpB,WAA8B,EAC9B,SAAqB,KAErB,IAAI,CAAC,uBAAuB,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createDeleteExpression.mjs","sources":["../../../src/factory/expressions/createDeleteExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,sBAAsB,GAAG,CACpC,UAAsB,KACD,IAAI,CAAC,kBAAkB,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/expressions/createDivide.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `/` operator: division.

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createDivide.mjs","sources":["../../../src/factory/expressions/createDivide.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,YAAY,GAAG,CAC1B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,KAAK;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createElementAccessChain.mjs","sources":["../../../src/factory/expressions/createElementAccessChain.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,wBAAwB,GAAG,CACtC,UAAsB,EACtB,gBAAmC,EACnC,KAA0B,KAE1B,IAAI,CAAC,oBAAoB,EAAE;IACzB,UAAU;IACV,gBAAgB;AAChB,IAAA,kBAAkB,EAChB,OAAO,KAAK,KAAK,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,GAAG,KAAK;AAClE,CAAA;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createElementAccessExpression.mjs","sources":["../../../src/factory/expressions/createElementAccessExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,6BAA6B,GAAG,CAC3C,UAAsB,EACtB,KAA0B,KAE1B,IAAI,CAAC,yBAAyB,EAAE;IAC9B,UAAU;AACV,IAAA,kBAAkB,EAChB,OAAO,KAAK,KAAK,QAAQ,GAAG,oBAAoB,CAAC,KAAK,CAAC,GAAG,KAAK;AAClE,CAAA;;;;"}

package/lib/factory/expressions/createEquality.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `==` operator: loose equality with

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createEquality.mjs","sources":["../../../src/factory/expressions/createEquality.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,iBAAiB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createExponent.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `**` operator: exponentiation.

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createExponent.mjs","sources":["../../../src/factory/expressions/createExponent.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,cAAc,GAAG,CAC5B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,qBAAqB,EAAE,KAAK;;;;"}

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

@@ -1 +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;;;;"}
+{"version":3,"file":"createFunctionExpression.mjs","sources":["../../../src/factory/expressions/createFunctionExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACI,MAAM,wBAAwB,GAAG,CACtC,SAA8C,EAC9C,aAAgC,EAChC,IAAqC,EACrC,cAA+D,EAC/D,UAA2C,EAC3C,IAA0B,EAC1B,IAAW,KAEX,IAAI,CAAC,oBAAoB,EAAE;IACzB,SAAS;IACT,aAAa;AACb,IAAA,IAAI,EAAE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC;IACnD,cAAc;IACd,UAAU;IACV,IAAI;IACJ,IAAI;AACL,CAAA;;;;"}

package/lib/factory/expressions/createGreaterThan.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `>` operator: greater-than

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

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

package/lib/factory/expressions/createGreaterThanEquals.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `>=` operator: greater-than-or-

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

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

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

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

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

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

package/lib/factory/expressions/createInequality.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `!=` operator: loose inequality

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

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

package/lib/factory/expressions/createLeftShift.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `<<` operator: bitwise left shift.

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

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

package/lib/factory/expressions/createLessThan.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `<` operator: less-than comparison.

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

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

package/lib/factory/expressions/createLessThanEquals.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `<=` operator: less-than-or-equal

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

@@ -1 +1 @@
-{"version":3,"file":"createLessThanEquals.mjs","sources":["../../../esm-tmp/factory/expressions/createLessThanEquals.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `<=` operator: less-than-or-equal\n * comparison.\n *\n * Shorthand for {@link createBinaryExpression} with the `LessThanEqualsToken`\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 createLessThanEquals = (left, right) => createBinaryExpression(left, SyntaxKind.LessThanEqualsToken, right);\n//# sourceMappingURL=createLessThanEquals.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,oBAAoB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,mBAAmB,EAAE,KAAK;;;;"}
+{"version":3,"file":"createLessThanEquals.mjs","sources":["../../../src/factory/expressions/createLessThanEquals.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,oBAAoB,GAAG,CAClC,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,mBAAmB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLogicalAnd.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `&&` operator: logical AND with

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

@@ -1 +1 @@
-{"version":3,"file":"createLogicalAnd.mjs","sources":["../../../esm-tmp/factory/expressions/createLogicalAnd.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createBinaryExpression } from \"./createBinaryExpression\";\n/**\n * Create a {@link BinaryExpression} with the `&&` operator: logical AND with\n * short-circuit evaluation.\n *\n * Shorthand for {@link createBinaryExpression} with the\n * `AmpersandAmpersandToken` operator. The printer surrounds the operator with a\n * 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 createLogicalAnd = (left, right) => createBinaryExpression(left, SyntaxKind.AmpersandAmpersandToken, right);\n//# sourceMappingURL=createLogicalAnd.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,uBAAuB,EAAE,KAAK;;;;"}
+{"version":3,"file":"createLogicalAnd.mjs","sources":["../../../src/factory/expressions/createLogicalAnd.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;;;AAkBG;MACU,gBAAgB,GAAG,CAC9B,IAAgB,EAChB,KAAiB,KAEjB,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,uBAAuB,EAAE,KAAK;;;;"}

package/lib/factory/expressions/createLogicalNot.mjs

@@ -1,5 +1,6 @@
-import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createPrefixUnaryExpression } from './createPrefixUnaryExpression.mjs';
 
 /**
  * Create a {@link PrefixUnaryExpression} with the `!` operator: logical NOT.

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

@@ -1 +1 @@
-{"version":3,"file":"createLogicalNot.mjs","sources":["../../../esm-tmp/factory/expressions/createLogicalNot.js"],"sourcesContent":["import { SyntaxKind } from \"../../syntax\";\nimport { createPrefixUnaryExpression } from \"./createPrefixUnaryExpression\";\n/**\n * Create a {@link PrefixUnaryExpression} with the `!` operator: logical NOT.\n *\n * Shorthand for {@link createPrefixUnaryExpression} with the `ExclamationToken`\n * operator. The printer writes the operator directly before the operand with no\n * separating space.\n *\n * Given operand `a`, the printer emits:\n *\n * ```ts\n * !a;\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 createLogicalNot = (operand) => createPrefixUnaryExpression(SyntaxKind.ExclamationToken, operand);\n//# sourceMappingURL=createLogicalNot.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;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,gBAAgB,EAAE,OAAO;;;;"}
+{"version":3,"file":"createLogicalNot.mjs","sources":["../../../src/factory/expressions/createLogicalNot.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,gBAAgB,GAAG,CAAC,OAAmB,KAClD,2BAA2B,CAAC,UAAU,CAAC,gBAAgB,EAAE,OAAO;;;;"}

package/lib/factory/expressions/createLogicalOr.mjs

@@ -1,5 +1,6 @@
-import { createBinaryExpression } from './createBinaryExpression.mjs';
 import { SyntaxKind } from '../../syntax/SyntaxKind.mjs';
+import '../../syntax/NodeFlags.mjs';
+import { createBinaryExpression } from './createBinaryExpression.mjs';
 
 /**
  * Create a {@link BinaryExpression} with the `||` operator: logical OR with