@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/imports/createImportClause.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportClause}: the part of an import statement between
+ * `import` and `from`.
+ *
+ * The `name` is the default-import binding, if any. The `namedBindings` slot
+ * holds either a {@link NamedImports} brace group or a {@link NamespaceImport}. A
+ * default binding and named bindings can appear together, joined by a comma.
+ * Set `isTypeOnly` to prefix the clause with `type`.
+ *
+ * Given a default binding `Def` plus named import `a`, this prints:
+ *
+ * ```ts
+ * (Def, { a });
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param name The name.
+ * @param namedBindings The named or namespace bindings, if any.
+ * @returns The created {@link ImportClause}.
+ */
+const createImportClause = (isTypeOnly, name, namedBindings) => make("ImportClause", { isTypeOnly, name, namedBindings });
+
+export { createImportClause };
+//# sourceMappingURL=createImportClause.mjs.map

package/lib/factory/imports/createImportClause.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImportClause.mjs","sources":["../../../src/factory/imports/createImportClause.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,kBAAkB,GAAG,CAChC,UAAmB,EACnB,IAA4B,EAC5B,aAAyD,KACxC,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE;;;;"}

package/lib/factory/imports/createImportDeclaration.mjs

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+import { createStringLiteral } from '../literals/createStringLiteral.mjs';
+
+/**
+ * Create an {@link ImportDeclaration}: an `import ... from "..."` statement.
+ *
+ * The `importClause` carries the default binding, namespace binding, and named
+ * bindings. Omit it to emit a side-effect-only import that just runs the module
+ * for its effects. The `moduleSpecifier` is the `from` target; pass a raw
+ * string and it is wrapped in a string literal for you, or pass an expression
+ * node directly.
+ *
+ * Given a named import of `a` from `"./mod"`, this prints:
+ *
+ * ```ts
+ * import { a } from "./mod";
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param modifiers The leading modifiers and decorators, if any.
+ * @param importClause The import clause; omitted for a side-effect-only import.
+ * @param moduleSpecifier The module specifier (the `from` target).
+ * @returns The created {@link ImportDeclaration}.
+ */
+const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => make("ImportDeclaration", {
+    modifiers,
+    importClause,
+    moduleSpecifier: typeof moduleSpecifier === "string"
+        ? createStringLiteral(moduleSpecifier)
+        : moduleSpecifier,
+});
+
+export { createImportDeclaration };
+//# sourceMappingURL=createImportDeclaration.mjs.map

package/lib/factory/imports/createImportDeclaration.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImportDeclaration.mjs","sources":["../../../src/factory/imports/createImportDeclaration.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,uBAAuB,GAAG,CACrC,SAA8C,EAC9C,YAAsC,EACtC,eAAoC,KAEpC,IAAI,CAAC,mBAAmB,EAAE;IACxB,SAAS;IACT,YAAY;AACZ,IAAA,eAAe,EACb,OAAO,eAAe,KAAK;AACzB,UAAE,mBAAmB,CAAC,eAAe;AACrC,UAAE,eAAe;AACtB,CAAA;;;;"}

package/lib/factory/imports/createImportSpecifier.mjs

@@ -0,0 +1,28 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}
+ * brace group.
+ *
+ * Pass `propertyName` to alias an export under a different local name, which
+ * prints as `propertyName as name`; leave it undefined for a plain binding. The
+ * `name` accepts a raw string and is wrapped in an identifier for you. Set
+ * `isTypeOnly` to prefix the single specifier with `type`.
+ *
+ * Given source name `x` aliased to `y`, this prints:
+ *
+ * ```ts
+ * x as y;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param isTypeOnly Whether this is a type-only import/export.
+ * @param propertyName The original (source) name, when aliased.
+ * @param name The name.
+ * @returns The created {@link ImportSpecifier}.
+ */
+const createImportSpecifier = (isTypeOnly, propertyName, name) => make("ImportSpecifier", { isTypeOnly, propertyName, name: asName(name) });
+
+export { createImportSpecifier };
+//# sourceMappingURL=createImportSpecifier.mjs.map

package/lib/factory/imports/createImportSpecifier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createImportSpecifier.mjs","sources":["../../../src/factory/imports/createImportSpecifier.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,qBAAqB,GAAG,CACnC,UAAmB,EACnB,YAAoC,EACpC,IAAyB,KAEzB,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/imports/createNamedExports.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamedExports}: the `{ ... }` binding group inside an export
+ * declaration.
+ *
+ * Each element is an {@link ExportSpecifier} naming one binding, optionally
+ * aliased with `as`. This node is the `exportClause` slot of an
+ * {@link ExportDeclaration}; on its own it prints just the brace group, and the
+ * printer adds a trailing comma when the list breaks across lines.
+ *
+ * Given specifiers for `a` and `b`, this prints:
+ *
+ * ```ts
+ * { a, b }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The elements.
+ * @returns The created {@link NamedExports}.
+ */
+const createNamedExports = (elements) => make("NamedExports", { elements });
+
+export { createNamedExports };
+//# sourceMappingURL=createNamedExports.mjs.map

package/lib/factory/imports/createNamedExports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamedExports.mjs","sources":["../../../src/factory/imports/createNamedExports.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,kBAAkB,GAAG,CAChC,QAAoC,KACnB,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/imports/createNamedImports.mjs

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamedImports}: the `{ ... }` binding group inside an import
+ * clause.
+ *
+ * Each element is an {@link ImportSpecifier} naming one binding, optionally
+ * aliased with `as`. This node is the `namedBindings` slot of an
+ * {@link ImportClause}; on its own it prints just the brace group, and the
+ * printer adds a trailing comma when the list breaks across lines.
+ *
+ * Given specifiers for `a` and `b`, this prints:
+ *
+ * ```ts
+ * { a, b }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param elements The elements.
+ * @returns The created {@link NamedImports}.
+ */
+const createNamedImports = (elements) => make("NamedImports", { elements });
+
+export { createNamedImports };
+//# sourceMappingURL=createNamedImports.mjs.map

package/lib/factory/imports/createNamedImports.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamedImports.mjs","sources":["../../../src/factory/imports/createNamedImports.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,kBAAkB,GAAG,CAChC,QAAoC,KACnB,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE;;;;"}

package/lib/factory/imports/createNamespaceExport.mjs

@@ -0,0 +1,25 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamespaceExport}: the `* as ns` clause that re-exports an
+ * entire module under a single namespace name.
+ *
+ * This node fills the `exportClause` slot of an {@link ExportDeclaration} that
+ * carries a `from` specifier. The `name` accepts a raw string and is wrapped in
+ * an identifier for you.
+ *
+ * Given the namespace name `ns`, this prints:
+ *
+ * ```ts
+ * * as ns
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @returns The created {@link NamespaceExport}.
+ */
+const createNamespaceExport = (name) => make("NamespaceExport", { name: asName(name) });
+
+export { createNamespaceExport };
+//# sourceMappingURL=createNamespaceExport.mjs.map

package/lib/factory/imports/createNamespaceExport.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamespaceExport.mjs","sources":["../../../src/factory/imports/createNamespaceExport.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;AAiBG;MACU,qBAAqB,GAAG,CACnC,IAAyB,KACL,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/imports/createNamespaceImport.mjs

@@ -0,0 +1,24 @@
+import { asName } from '../internal/asName.mjs';
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link NamespaceImport}: the `* as ns` binding that imports an entire
+ * module under a single namespace name.
+ *
+ * This node fills the `namedBindings` slot of an {@link ImportClause}. The
+ * `name` accepts a raw string and is wrapped in an identifier for you.
+ *
+ * Given the namespace name `ns`, this prints:
+ *
+ * ```ts
+ * * as ns
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The name.
+ * @returns The created {@link NamespaceImport}.
+ */
+const createNamespaceImport = (name) => make("NamespaceImport", { name: asName(name) });
+
+export { createNamespaceImport };
+//# sourceMappingURL=createNamespaceImport.mjs.map

package/lib/factory/imports/createNamespaceImport.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNamespaceImport.mjs","sources":["../../../src/factory/imports/createNamespaceImport.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;MACU,qBAAqB,GAAG,CACnC,IAAyB,KACL,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}

package/lib/factory/index.mjs

@@ -0,0 +1,268 @@
+export { createHeritageClause } from './clauses/createHeritageClause.mjs';
+export { createJsxAttribute } from './jsx/createJsxAttribute.mjs';
+export { createJsxAttributes } from './jsx/createJsxAttributes.mjs';
+export { createJsxClosingElement } from './jsx/createJsxClosingElement.mjs';
+export { createJsxElement } from './jsx/createJsxElement.mjs';
+export { createJsxExpression } from './jsx/createJsxExpression.mjs';
+export { createJsxFragment } from './jsx/createJsxFragment.mjs';
+export { createJsxJsxClosingFragment } from './jsx/createJsxJsxClosingFragment.mjs';
+export { createJsxNamespacedName } from './jsx/createJsxNamespacedName.mjs';
+export { createJsxOpeningElement } from './jsx/createJsxOpeningElement.mjs';
+export { createJsxOpeningFragment } from './jsx/createJsxOpeningFragment.mjs';
+export { createJsxSelfClosingElement } from './jsx/createJsxSelfClosingElement.mjs';
+export { createJsxSpreadAttribute } from './jsx/createJsxSpreadAttribute.mjs';
+export { createJsxText } from './jsx/createJsxText.mjs';
+export { createPartiallyEmittedExpression } from './expressions/createPartiallyEmittedExpression.mjs';
+export { createBundle } from './file/createBundle.mjs';
+export { createImportAttribute } from './imports/createImportAttribute.mjs';
+export { createImportAttributes } from './imports/createImportAttributes.mjs';
+export { createStringLiteralFromNode } from './literals/createStringLiteralFromNode.mjs';
+export { createLoopVariable } from './names/createLoopVariable.mjs';
+export { createModifiersFromModifierFlags } from './names/createModifiersFromModifierFlags.mjs';
+export { createTempVariable } from './names/createTempVariable.mjs';
+export { createUniqueName } from './names/createUniqueName.mjs';
+export { createUniquePrivateName } from './names/createUniquePrivateName.mjs';
+export { createNotEmittedStatement } from './statements/createNotEmittedStatement.mjs';
+export { createNotEmittedTypeElement } from './types/createNotEmittedTypeElement.mjs';
+export { createJSDocComment } from './jsdoc/createJSDocComment.mjs';
+export { createJSDocAllType } from './jsdoc/createJSDocAllType.mjs';
+export { createJSDocAugmentsTag } from './jsdoc/createJSDocAugmentsTag.mjs';
+export { createJSDocAuthorTag } from './jsdoc/createJSDocAuthorTag.mjs';
+export { createJSDocCallbackTag } from './jsdoc/createJSDocCallbackTag.mjs';
+export { createJSDocClassTag } from './jsdoc/createJSDocClassTag.mjs';
+export { createJSDocDeprecatedTag } from './jsdoc/createJSDocDeprecatedTag.mjs';
+export { createJSDocEnumTag } from './jsdoc/createJSDocEnumTag.mjs';
+export { createJSDocFunctionType } from './jsdoc/createJSDocFunctionType.mjs';
+export { createJSDocImplementsTag } from './jsdoc/createJSDocImplementsTag.mjs';
+export { createJSDocImportTag } from './jsdoc/createJSDocImportTag.mjs';
+export { createJSDocLink } from './jsdoc/createJSDocLink.mjs';
+export { createJSDocLinkCode } from './jsdoc/createJSDocLinkCode.mjs';
+export { createJSDocLinkPlain } from './jsdoc/createJSDocLinkPlain.mjs';
+export { createJSDocMemberName } from './jsdoc/createJSDocMemberName.mjs';
+export { createJSDocNamepathType } from './jsdoc/createJSDocNamepathType.mjs';
+export { createJSDocNameReference } from './jsdoc/createJSDocNameReference.mjs';
+export { createJSDocNonNullableType } from './jsdoc/createJSDocNonNullableType.mjs';
+export { createJSDocNullableType } from './jsdoc/createJSDocNullableType.mjs';
+export { createJSDocOptionalType } from './jsdoc/createJSDocOptionalType.mjs';
+export { createJSDocOverloadTag } from './jsdoc/createJSDocOverloadTag.mjs';
+export { createJSDocOverrideTag } from './jsdoc/createJSDocOverrideTag.mjs';
+export { createJSDocParameterTag } from './jsdoc/createJSDocParameterTag.mjs';
+export { createJSDocPrivateTag } from './jsdoc/createJSDocPrivateTag.mjs';
+export { createJSDocPropertyTag } from './jsdoc/createJSDocPropertyTag.mjs';
+export { createJSDocProtectedTag } from './jsdoc/createJSDocProtectedTag.mjs';
+export { createJSDocPublicTag } from './jsdoc/createJSDocPublicTag.mjs';
+export { createJSDocReadonlyTag } from './jsdoc/createJSDocReadonlyTag.mjs';
+export { createJSDocReturnTag } from './jsdoc/createJSDocReturnTag.mjs';
+export { createJSDocSatisfiesTag } from './jsdoc/createJSDocSatisfiesTag.mjs';
+export { createJSDocSeeTag } from './jsdoc/createJSDocSeeTag.mjs';
+export { createJSDocSignature } from './jsdoc/createJSDocSignature.mjs';
+export { createJSDocTemplateTag } from './jsdoc/createJSDocTemplateTag.mjs';
+export { createJSDocText } from './jsdoc/createJSDocText.mjs';
+export { createJSDocThisTag } from './jsdoc/createJSDocThisTag.mjs';
+export { createJSDocThrowsTag } from './jsdoc/createJSDocThrowsTag.mjs';
+export { createJSDocTypedefTag } from './jsdoc/createJSDocTypedefTag.mjs';
+export { createJSDocTypeExpression } from './jsdoc/createJSDocTypeExpression.mjs';
+export { createJSDocTypeLiteral } from './jsdoc/createJSDocTypeLiteral.mjs';
+export { createJSDocTypeTag } from './jsdoc/createJSDocTypeTag.mjs';
+export { createJSDocUnknownTag } from './jsdoc/createJSDocUnknownTag.mjs';
+export { createJSDocUnknownType } from './jsdoc/createJSDocUnknownType.mjs';
+export { createJSDocVariadicType } from './jsdoc/createJSDocVariadicType.mjs';
+export { createParameterDeclaration } from './clauses/createParameterDeclaration.mjs';
+export { createClassDeclaration } from './declarations/createClassDeclaration.mjs';
+export { createClassStaticBlockDeclaration } from './declarations/createClassStaticBlockDeclaration.mjs';
+export { createConstructorDeclaration } from './declarations/createConstructorDeclaration.mjs';
+export { createEnumDeclaration } from './declarations/createEnumDeclaration.mjs';
+export { createEnumMember } from './declarations/createEnumMember.mjs';
+export { createExternalModuleReference } from './declarations/createExternalModuleReference.mjs';
+export { createFunctionDeclaration } from './declarations/createFunctionDeclaration.mjs';
+export { createGetAccessorDeclaration } from './declarations/createGetAccessorDeclaration.mjs';
+export { createImportEqualsDeclaration } from './declarations/createImportEqualsDeclaration.mjs';
+export { createInterfaceDeclaration } from './declarations/createInterfaceDeclaration.mjs';
+export { createMethodDeclaration } from './declarations/createMethodDeclaration.mjs';
+export { createModuleBlock } from './declarations/createModuleBlock.mjs';
+export { createModuleDeclaration } from './declarations/createModuleDeclaration.mjs';
+export { createNamespaceExportDeclaration } from './declarations/createNamespaceExportDeclaration.mjs';
+export { createPropertyDeclaration } from './declarations/createPropertyDeclaration.mjs';
+export { createSemicolonClassElement } from './declarations/createSemicolonClassElement.mjs';
+export { createSetAccessorDeclaration } from './declarations/createSetAccessorDeclaration.mjs';
+export { createTypeAliasDeclaration } from './declarations/createTypeAliasDeclaration.mjs';
+export { createAdd } from './expressions/createAdd.mjs';
+export { createArrayBindingPattern } from './expressions/createArrayBindingPattern.mjs';
+export { createArrayLiteralExpression } from './expressions/createArrayLiteralExpression.mjs';
+export { createArrowFunction } from './expressions/createArrowFunction.mjs';
+export { createAsExpression } from './expressions/createAsExpression.mjs';
+export { createAssignment } from './expressions/createAssignment.mjs';
+export { createAwaitExpression } from './expressions/createAwaitExpression.mjs';
+export { createBinaryExpression } from './expressions/createBinaryExpression.mjs';
+export { createBindingElement } from './expressions/createBindingElement.mjs';
+export { createBitwiseAnd } from './expressions/createBitwiseAnd.mjs';
+export { createBitwiseNot } from './expressions/createBitwiseNot.mjs';
+export { createBitwiseOr } from './expressions/createBitwiseOr.mjs';
+export { createBitwiseXor } from './expressions/createBitwiseXor.mjs';
+export { createCallChain } from './expressions/createCallChain.mjs';
+export { createCallExpression } from './expressions/createCallExpression.mjs';
+export { createClassExpression } from './expressions/createClassExpression.mjs';
+export { createComma } from './expressions/createComma.mjs';
+export { createCommaListExpression } from './expressions/createCommaListExpression.mjs';
+export { createComputedPropertyName } from './expressions/createComputedPropertyName.mjs';
+export { createConditionalExpression } from './expressions/createConditionalExpression.mjs';
+export { createDeleteExpression } from './expressions/createDeleteExpression.mjs';
+export { createDivide } from './expressions/createDivide.mjs';
+export { createElementAccessChain } from './expressions/createElementAccessChain.mjs';
+export { createElementAccessExpression } from './expressions/createElementAccessExpression.mjs';
+export { createEquality } from './expressions/createEquality.mjs';
+export { createExponent } from './expressions/createExponent.mjs';
+export { createFunctionExpression } from './expressions/createFunctionExpression.mjs';
+export { createGreaterThan } from './expressions/createGreaterThan.mjs';
+export { createGreaterThanEquals } from './expressions/createGreaterThanEquals.mjs';
+export { createImmediatelyInvokedArrowFunction } from './expressions/createImmediatelyInvokedArrowFunction.mjs';
+export { createImmediatelyInvokedFunctionExpression } from './expressions/createImmediatelyInvokedFunctionExpression.mjs';
+export { createInequality } from './expressions/createInequality.mjs';
+export { createLeftShift } from './expressions/createLeftShift.mjs';
+export { createLessThan } from './expressions/createLessThan.mjs';
+export { createLessThanEquals } from './expressions/createLessThanEquals.mjs';
+export { createLogicalAnd } from './expressions/createLogicalAnd.mjs';
+export { createLogicalNot } from './expressions/createLogicalNot.mjs';
+export { createLogicalOr } from './expressions/createLogicalOr.mjs';
+export { createMetaProperty } from './expressions/createMetaProperty.mjs';
+export { createModulo } from './expressions/createModulo.mjs';
+export { createMultiply } from './expressions/createMultiply.mjs';
+export { createNewExpression } from './expressions/createNewExpression.mjs';
+export { createNonNullChain } from './expressions/createNonNullChain.mjs';
+export { createNonNullExpression } from './expressions/createNonNullExpression.mjs';
+export { createObjectBindingPattern } from './expressions/createObjectBindingPattern.mjs';
+export { createObjectLiteralExpression } from './expressions/createObjectLiteralExpression.mjs';
+export { createOmittedExpression } from './expressions/createOmittedExpression.mjs';
+export { createParenthesizedExpression } from './expressions/createParenthesizedExpression.mjs';
+export { createPostfixDecrement } from './expressions/createPostfixDecrement.mjs';
+export { createPostfixIncrement } from './expressions/createPostfixIncrement.mjs';
+export { createPostfixUnaryExpression } from './expressions/createPostfixUnaryExpression.mjs';
+export { createPrefixDecrement } from './expressions/createPrefixDecrement.mjs';
+export { createPrefixIncrement } from './expressions/createPrefixIncrement.mjs';
+export { createPrefixMinus } from './expressions/createPrefixMinus.mjs';
+export { createPrefixPlus } from './expressions/createPrefixPlus.mjs';
+export { createPrefixUnaryExpression } from './expressions/createPrefixUnaryExpression.mjs';
+export { createPropertyAccessChain } from './expressions/createPropertyAccessChain.mjs';
+export { createPropertyAccessExpression } from './expressions/createPropertyAccessExpression.mjs';
+export { createPropertyAssignment } from './expressions/createPropertyAssignment.mjs';
+export { createRegularExpressionLiteral } from './expressions/createRegularExpressionLiteral.mjs';
+export { createRightShift } from './expressions/createRightShift.mjs';
+export { createSatisfiesExpression } from './expressions/createSatisfiesExpression.mjs';
+export { createShorthandPropertyAssignment } from './expressions/createShorthandPropertyAssignment.mjs';
+export { createSpreadAssignment } from './expressions/createSpreadAssignment.mjs';
+export { createSpreadElement } from './expressions/createSpreadElement.mjs';
+export { createStrictEquality } from './expressions/createStrictEquality.mjs';
+export { createStrictInequality } from './expressions/createStrictInequality.mjs';
+export { createSubtract } from './expressions/createSubtract.mjs';
+export { createTaggedTemplateExpression } from './expressions/createTaggedTemplateExpression.mjs';
+export { createTemplateExpression } from './expressions/createTemplateExpression.mjs';
+export { createTemplateSpan } from './expressions/createTemplateSpan.mjs';
+export { createTypeAssertion } from './expressions/createTypeAssertion.mjs';
+export { createTypeOfExpression } from './expressions/createTypeOfExpression.mjs';
+export { createUnsignedRightShift } from './expressions/createUnsignedRightShift.mjs';
+export { createVoidExpression } from './expressions/createVoidExpression.mjs';
+export { createVoidZero } from './expressions/createVoidZero.mjs';
+export { createYieldExpression } from './expressions/createYieldExpression.mjs';
+export { createNodeArray } from './file/createNodeArray.mjs';
+export { createSourceFile } from './file/createSourceFile.mjs';
+export { updateSourceFile } from './file/updateSourceFile.mjs';
+export { createExportAssignment } from './imports/createExportAssignment.mjs';
+export { createExportDeclaration } from './imports/createExportDeclaration.mjs';
+export { createExportDefault } from './imports/createExportDefault.mjs';
+export { createExportSpecifier } from './imports/createExportSpecifier.mjs';
+export { createExternalModuleExport } from './imports/createExternalModuleExport.mjs';
+export { createImportClause } from './imports/createImportClause.mjs';
+export { createImportDeclaration } from './imports/createImportDeclaration.mjs';
+export { createImportSpecifier } from './imports/createImportSpecifier.mjs';
+export { createNamedExports } from './imports/createNamedExports.mjs';
+export { createNamedImports } from './imports/createNamedImports.mjs';
+export { createNamespaceExport } from './imports/createNamespaceExport.mjs';
+export { createNamespaceImport } from './imports/createNamespaceImport.mjs';
+export { createBigIntLiteral } from './literals/createBigIntLiteral.mjs';
+export { createNoSubstitutionTemplateLiteral } from './literals/createNoSubstitutionTemplateLiteral.mjs';
+export { createNumericLiteral } from './literals/createNumericLiteral.mjs';
+export { createStringLiteral } from './literals/createStringLiteral.mjs';
+export { createTemplateHead } from './literals/createTemplateHead.mjs';
+export { createTemplateMiddle } from './literals/createTemplateMiddle.mjs';
+export { createTemplateTail } from './literals/createTemplateTail.mjs';
+export { createDecorator } from './names/createDecorator.mjs';
+export { createFalse } from './names/createFalse.mjs';
+export { createIdentifier } from './names/createIdentifier.mjs';
+export { createModifier } from './names/createModifier.mjs';
+export { createNull } from './names/createNull.mjs';
+export { createPrivateIdentifier } from './names/createPrivateIdentifier.mjs';
+export { createQualifiedName } from './names/createQualifiedName.mjs';
+export { createSuper } from './names/createSuper.mjs';
+export { createThis } from './names/createThis.mjs';
+export { createToken } from './names/createToken.mjs';
+export { createTrue } from './names/createTrue.mjs';
+export { createBlock } from './statements/createBlock.mjs';
+export { createBreakStatement } from './statements/createBreakStatement.mjs';
+export { createCaseBlock } from './statements/createCaseBlock.mjs';
+export { createCaseClause } from './statements/createCaseClause.mjs';
+export { createCatchClause } from './statements/createCatchClause.mjs';
+export { createContinueStatement } from './statements/createContinueStatement.mjs';
+export { createDebuggerStatement } from './statements/createDebuggerStatement.mjs';
+export { createDefaultClause } from './statements/createDefaultClause.mjs';
+export { createDoStatement } from './statements/createDoStatement.mjs';
+export { createEmptyStatement } from './statements/createEmptyStatement.mjs';
+export { createExpressionStatement } from './statements/createExpressionStatement.mjs';
+export { createForInStatement } from './statements/createForInStatement.mjs';
+export { createForOfStatement } from './statements/createForOfStatement.mjs';
+export { createForStatement } from './statements/createForStatement.mjs';
+export { createIfStatement } from './statements/createIfStatement.mjs';
+export { createLabeledStatement } from './statements/createLabeledStatement.mjs';
+export { createReturnStatement } from './statements/createReturnStatement.mjs';
+export { createSwitchStatement } from './statements/createSwitchStatement.mjs';
+export { createThrowStatement } from './statements/createThrowStatement.mjs';
+export { createTryStatement } from './statements/createTryStatement.mjs';
+export { createVariableDeclaration } from './statements/createVariableDeclaration.mjs';
+export { createVariableDeclarationList } from './statements/createVariableDeclarationList.mjs';
+export { createVariableStatement } from './statements/createVariableStatement.mjs';
+export { createWhileStatement } from './statements/createWhileStatement.mjs';
+export { createWithStatement } from './statements/createWithStatement.mjs';
+export { createArrayTypeNode } from './types/createArrayTypeNode.mjs';
+export { createCallSignature } from './types/createCallSignature.mjs';
+export { createConditionalTypeNode } from './types/createConditionalTypeNode.mjs';
+export { createConstructorTypeNode } from './types/createConstructorTypeNode.mjs';
+export { createConstructSignature } from './types/createConstructSignature.mjs';
+export { createExpressionWithTypeArguments } from './types/createExpressionWithTypeArguments.mjs';
+export { createFunctionTypeNode } from './types/createFunctionTypeNode.mjs';
+export { createImportTypeNode } from './types/createImportTypeNode.mjs';
+export { createIndexedAccessTypeNode } from './types/createIndexedAccessTypeNode.mjs';
+export { createIndexSignature } from './types/createIndexSignature.mjs';
+export { createInferTypeNode } from './types/createInferTypeNode.mjs';
+export { createIntersectionTypeNode } from './types/createIntersectionTypeNode.mjs';
+export { createKeywordTypeNode } from './types/createKeywordTypeNode.mjs';
+export { createLiteralTypeNode } from './types/createLiteralTypeNode.mjs';
+export { createMappedTypeNode } from './types/createMappedTypeNode.mjs';
+export { createMethodSignature } from './types/createMethodSignature.mjs';
+export { createNamedTupleMember } from './types/createNamedTupleMember.mjs';
+export { createOptionalTypeNode } from './types/createOptionalTypeNode.mjs';
+export { createParenthesizedType } from './types/createParenthesizedType.mjs';
+export { createPropertySignature } from './types/createPropertySignature.mjs';
+export { createRestTypeNode } from './types/createRestTypeNode.mjs';
+export { createTemplateLiteralType } from './types/createTemplateLiteralType.mjs';
+export { createTemplateLiteralTypeSpan } from './types/createTemplateLiteralTypeSpan.mjs';
+export { createThisTypeNode } from './types/createThisTypeNode.mjs';
+export { createTupleTypeNode } from './types/createTupleTypeNode.mjs';
+export { createTypeLiteralNode } from './types/createTypeLiteralNode.mjs';
+export { createTypeOperatorNode } from './types/createTypeOperatorNode.mjs';
+export { createTypeParameterDeclaration } from './types/createTypeParameterDeclaration.mjs';
+export { createTypePredicateNode } from './types/createTypePredicateNode.mjs';
+export { createTypeQueryNode } from './types/createTypeQueryNode.mjs';
+export { createTypeReferenceNode } from './types/createTypeReferenceNode.mjs';
+export { createUnionTypeNode } from './types/createUnionTypeNode.mjs';
+
+/**
+ * Hand-written, dependency-free re-implementation of the legacy TypeScript AST
+ * node factory (`ts.factory`).
+ *
+ * This module is a pure re-export barrel: each `createXxx` builder lives in its
+ * own file and is re-exported here. `src/index.ts` aggregates them into the
+ * `factory` namespace via `export * as factory`, which lets bundlers tree-shake
+ * unused builders. No `typescript` module is imported anywhere.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+//# sourceMappingURL=index.mjs.map

package/lib/factory/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../src/factory/index.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;AAUG"}

package/lib/factory/internal/asEntityName.mjs

@@ -0,0 +1,7 @@
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/** @internal */
+const asEntityName = (name) => typeof name === "string" ? createIdentifier(name) : name;
+
+export { asEntityName };
+//# sourceMappingURL=asEntityName.mjs.map

package/lib/factory/internal/asEntityName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asEntityName.mjs","sources":["../../../src/factory/internal/asEntityName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;AACO,MAAM,YAAY,GAAG,CAAC,IAAyB,KACpD,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}

package/lib/factory/internal/asName.mjs

@@ -0,0 +1,11 @@
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Coerce a `string | Identifier` into an {@link Identifier}.
+ *
+ * @internal
+ */
+const asName = (name) => typeof name === "string" ? createIdentifier(name) : name;
+
+export { asName };
+//# sourceMappingURL=asName.mjs.map

package/lib/factory/internal/asName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asName.mjs","sources":["../../../src/factory/internal/asName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;AAIG;AACI,MAAM,MAAM,GAAG,CAAC,IAAyB,KAC9C,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}

package/lib/factory/internal/asPropertyName.mjs

@@ -0,0 +1,7 @@
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/** @internal */
+const asPropertyName = (name) => typeof name === "string" ? createIdentifier(name) : name;
+
+export { asPropertyName };
+//# sourceMappingURL=asPropertyName.mjs.map

package/lib/factory/internal/asPropertyName.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asPropertyName.mjs","sources":["../../../src/factory/internal/asPropertyName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;AACO,MAAM,cAAc,GAAG,CAAC,IAA2B,KACxD,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}

package/lib/factory/internal/make.mjs

@@ -0,0 +1,14 @@
+/**
+ * Construct an outline node of the given `kind`.
+ *
+ * Generic over the node kind, so the `props` object is type-checked against the
+ * exact node interface (every required field present, no stray fields, correct
+ * types) and the return type is the concrete node — the factory is type-safe
+ * end to end.
+ *
+ * @internal
+ */
+const make = (kind, props) => ({ kind, ...props });
+
+export { make };
+//# sourceMappingURL=make.mjs.map

package/lib/factory/internal/make.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"make.mjs","sources":["../../../src/factory/internal/make.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;AASG;AACI,MAAM,IAAI,GAAG,CAClB,IAAO,EACP,KAA+C,MAE9C,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE;;;;"}

package/lib/factory/jsdoc/createJSDocAllType.mjs

@@ -0,0 +1,21 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocAllType}: the JSDoc `*` wildcard type.
+ *
+ * This node takes no inputs. It represents the "any" wildcard written as a bare
+ * asterisk in a JSDoc type expression.
+ *
+ * The printer emits:
+ *
+ * ```ts
+ * *
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @returns The created {@link JSDocAllType}.
+ */
+const createJSDocAllType = () => make("JSDocAllType", {});
+
+export { createJSDocAllType };
+//# sourceMappingURL=createJSDocAllType.mjs.map

package/lib/factory/jsdoc/createJSDocAllType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocAllType.mjs","sources":["../../../src/factory/jsdoc/createJSDocAllType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,kBAAkB,GAAG,MAAoB,IAAI,CAAC,cAAc,EAAE,EAAE;;;;"}

package/lib/factory/jsdoc/createJSDocAugmentsTag.mjs

@@ -0,0 +1,30 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocAugmentsTag}: an `@augments` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `augments` when omitted. The
+ * `className` is the base class expression, which the printer wraps in braces.
+ * The `comment` is the trailing description, if any.
+ *
+ * With the default tag name and a `Base` class expression, the printer emits:
+ *
+ * ```ts
+ * @augments {Base}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `augments`.
+ * @param className The augmented class.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocAugmentsTag}.
+ */
+const createJSDocAugmentsTag = (tagName, className, comment) => make("JSDocAugmentsTag", {
+    tagName: tagName ?? createIdentifier("augments"),
+    class: className,
+    comment,
+});
+
+export { createJSDocAugmentsTag };
+//# sourceMappingURL=createJSDocAugmentsTag.mjs.map

package/lib/factory/jsdoc/createJSDocAugmentsTag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createJSDocAugmentsTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocAugmentsTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,SAAsC,EACtC,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AAChD,IAAA,KAAK,EAAE,SAAS;IAChB,OAAO;AACR,CAAA;;;;"}