@ttsc/factory 0.15.10 → 0.16.0

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

@@ -1 +1 @@
-{"version":3,"file":"createImportDeclaration.mjs","sources":["../../../esm-tmp/factory/imports/createImportDeclaration.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createStringLiteral } from \"../literals/createStringLiteral\";\n/**\n * Create an {@link ImportDeclaration}: an `import ... from \"...\"` statement.\n *\n * The `importClause` carries the default binding, namespace binding, and named\n * bindings. Omit it to emit a side-effect-only import that just runs the module\n * for its effects. The `moduleSpecifier` is the `from` target; pass a raw\n * string and it is wrapped in a string literal for you, or pass an expression\n * node directly.\n *\n * Given a named import of `a` from `\"./mod\"`, this prints:\n *\n * ```ts\n * import { a } from \"./mod\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param modifiers The leading modifiers and decorators, if any.\n * @param importClause The import clause; omitted for a side-effect-only import.\n * @param moduleSpecifier The module specifier (the `from` target).\n * @returns The created {@link ImportDeclaration}.\n */\nexport const createImportDeclaration = (modifiers, importClause, moduleSpecifier) => make(\"ImportDeclaration\", {\n    modifiers,\n    importClause,\n    moduleSpecifier: typeof moduleSpecifier === \"string\"\n        ? createStringLiteral(moduleSpecifier)\n        : moduleSpecifier,\n});\n//# sourceMappingURL=createImportDeclaration.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,uBAAuB,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,eAAe,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC/G,IAAI,SAAS;AACb,IAAI,YAAY;AAChB,IAAI,eAAe,EAAE,OAAO,eAAe,KAAK;AAChD,UAAU,mBAAmB,CAAC,eAAe;AAC7C,UAAU,eAAe;AACzB,CAAC;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createImportSpecifier.mjs","sources":["../../../esm-tmp/factory/imports/createImportSpecifier.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create an {@link ImportSpecifier}: one entry inside a {@link NamedImports}\n * brace group.\n *\n * Pass `propertyName` to alias an export under a different local name, which\n * prints as `propertyName as name`; leave it undefined for a plain binding. The\n * `name` accepts a raw string and is wrapped in an identifier for you. Set\n * `isTypeOnly` to prefix the single specifier with `type`.\n *\n * Given source name `x` aliased to `y`, this prints:\n *\n * ```ts\n * x as y;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param isTypeOnly Whether this is a type-only import/export.\n * @param propertyName The original (source) name, when aliased.\n * @param name The name.\n * @returns The created {@link ImportSpecifier}.\n */\nexport const createImportSpecifier = (isTypeOnly, propertyName, name) => make(\"ImportSpecifier\", { isTypeOnly, propertyName, name: asName(name) });\n//# sourceMappingURL=createImportSpecifier.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,UAAU,EAAE,YAAY,EAAE,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createNamedExports.mjs","sources":["../../../esm-tmp/factory/imports/createNamedExports.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NamedExports}: the `{ ... }` binding group inside an export\n * declaration.\n *\n * Each element is an {@link ExportSpecifier} naming one binding, optionally\n * aliased with `as`. This node is the `exportClause` slot of an\n * {@link ExportDeclaration}; on its own it prints just the brace group, and the\n * printer adds a trailing comma when the list breaks across lines.\n *\n * Given specifiers for `a` and `b`, this prints:\n *\n * ```ts\n * { a, b }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The elements.\n * @returns The created {@link NamedExports}.\n */\nexport const createNamedExports = (elements) => make(\"NamedExports\", { elements });\n//# sourceMappingURL=createNamedExports.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,kBAAkB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createNamedImports.mjs","sources":["../../../esm-tmp/factory/imports/createNamedImports.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link NamedImports}: the `{ ... }` binding group inside an import\n * clause.\n *\n * Each element is an {@link ImportSpecifier} naming one binding, optionally\n * aliased with `as`. This node is the `namedBindings` slot of an\n * {@link ImportClause}; on its own it prints just the brace group, and the\n * printer adds a trailing comma when the list breaks across lines.\n *\n * Given specifiers for `a` and `b`, this prints:\n *\n * ```ts\n * { a, b }\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param elements The elements.\n * @returns The created {@link NamedImports}.\n */\nexport const createNamedImports = (elements) => make(\"NamedImports\", { elements });\n//# sourceMappingURL=createNamedImports.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,kBAAkB,GAAG,CAAC,QAAQ,KAAK,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createNamespaceExport.mjs","sources":["../../../esm-tmp/factory/imports/createNamespaceExport.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link NamespaceExport}: the `* as ns` clause that re-exports an\n * entire module under a single namespace name.\n *\n * This node fills the `exportClause` slot of an {@link ExportDeclaration} that\n * carries a `from` specifier. The `name` accepts a raw string and is wrapped in\n * an identifier for you.\n *\n * Given the namespace name `ns`, this prints:\n *\n * ```ts\n * * as ns\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @returns The created {@link NamespaceExport}.\n */\nexport const createNamespaceExport = (name) => make(\"NamespaceExport\", { name: asName(name) });\n//# sourceMappingURL=createNamespaceExport.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createNamespaceImport.mjs","sources":["../../../esm-tmp/factory/imports/createNamespaceImport.js"],"sourcesContent":["import { asName } from \"../internal/asName\";\nimport { make } from \"../internal/make\";\n/**\n * Create a {@link NamespaceImport}: the `* as ns` binding that imports an entire\n * module under a single namespace name.\n *\n * This node fills the `namedBindings` slot of an {@link ImportClause}. The\n * `name` accepts a raw string and is wrapped in an identifier for you.\n *\n * Given the namespace name `ns`, this prints:\n *\n * ```ts\n * * as ns\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @returns The created {@link NamespaceImport}.\n */\nexport const createNamespaceImport = (name) => make(\"NamespaceImport\", { name: asName(name) });\n//# sourceMappingURL=createNamespaceImport.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE;;;;"}
+{"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.map

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

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

@@ -1 +1 @@
-{"version":3,"file":"asEntityName.mjs","sources":["../../../esm-tmp/factory/internal/asEntityName.js"],"sourcesContent":["import { createIdentifier } from \"../names/createIdentifier\";\n/** @internal */\nexport const asEntityName = (name) => typeof name === \"string\" ? createIdentifier(name) : name;\n//# sourceMappingURL=asEntityName.js.map"],"names":[],"mappings":";;AACA;AACY,MAAC,YAAY,GAAG,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"asName.mjs","sources":["../../../esm-tmp/factory/internal/asName.js"],"sourcesContent":["import { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Coerce a `string | Identifier` into an {@link Identifier}.\n *\n * @internal\n */\nexport const asName = (name) => typeof name === \"string\" ? createIdentifier(name) : name;\n//# sourceMappingURL=asName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,MAAM,GAAG,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"asPropertyName.mjs","sources":["../../../esm-tmp/factory/internal/asPropertyName.js"],"sourcesContent":["import { createIdentifier } from \"../names/createIdentifier\";\n/** @internal */\nexport const asPropertyName = (name) => typeof name === \"string\" ? createIdentifier(name) : name;\n//# sourceMappingURL=asPropertyName.js.map"],"names":[],"mappings":";;AACA;AACY,MAAC,cAAc,GAAG,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,QAAQ,GAAG,gBAAgB,CAAC,IAAI,CAAC,GAAG;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"make.mjs","sources":["../../../esm-tmp/factory/internal/make.js"],"sourcesContent":["/**\n * Construct an outline node of the given `kind`.\n *\n * Generic over the node kind, so the `props` object is type-checked against the\n * exact node interface (every required field present, no stray fields, correct\n * types) and the return type is the concrete node — the factory is type-safe\n * end to end.\n *\n * @internal\n */\nexport const make = (kind, props) => ({ kind, ...props });\n//# sourceMappingURL=make.js.map"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createJSDocAllType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocAllType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocAllType}: the JSDoc `*` wildcard type.\n *\n * This node takes no inputs. It represents the \"any\" wildcard written as a bare\n * asterisk in a JSDoc type expression.\n *\n * The printer emits:\n *\n * ```ts\n * *\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JSDocAllType}.\n */\nexport const createJSDocAllType = () => make(\"JSDocAllType\", {});\n//# sourceMappingURL=createJSDocAllType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,EAAE;;;;"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"file":"createJSDocAugmentsTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocAugmentsTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocAugmentsTag}: an `@augments` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `augments` when omitted. The\n * `className` is the base class expression, which the printer wraps in braces.\n * The `comment` is the trailing description, if any.\n *\n * With the default tag name and a `Base` class expression, the printer emits:\n *\n * ```ts\n * @augments {Base}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `augments`.\n * @param className The augmented class.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocAugmentsTag}.\n */\nexport const createJSDocAugmentsTag = (tagName, className, comment) => make(\"JSDocAugmentsTag\", {\n    tagName: tagName ?? createIdentifier(\"augments\"),\n    class: className,\n    comment,\n});\n//# sourceMappingURL=createJSDocAugmentsTag.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,sBAAsB,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAChG,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,KAAK,EAAE,SAAS;AACpB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"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;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocAuthorTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocAuthorTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocAuthorTag}: an `@author` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `author` when omitted. The\n * `comment` is the trailing text naming the author.\n *\n * With the default tag name and a `Jeongho Nam` comment, the printer emits:\n *\n * ```ts\n * @author Jeongho Nam\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `author`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocAuthorTag}.\n */\nexport const createJSDocAuthorTag = (tagName, comment) => make(\"JSDocAuthorTag\", {\n    tagName: tagName ?? createIdentifier(\"author\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocAuthorTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACjF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;AAClD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocAuthorTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocAuthorTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,oBAAoB,GAAG,CAClC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;IAC9C,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocCallbackTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocCallbackTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocCallbackTag}: a `@callback` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `callback` when omitted. The\n * `typeExpression` is the {@link JSDocSignature} describing the callback,\n * `fullName` is the callback's name, and `comment` is the trailing description.\n * The printer prints the tag and name on the first line, then the signature's\n * `@param` and `@returns` tags on their own lines.\n *\n * With the default tag name, a name of `MyCb`, and a signature taking `{number}\n * x` and returning `{void}`, the printer emits:\n *\n * ```ts\n * @callback MyCb\n * @param {number} x\n * @returns {void}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `callback`.\n * @param typeExpression The callback signature.\n * @param fullName The full callback name, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocCallbackTag}.\n */\nexport const createJSDocCallbackTag = (tagName, typeExpression, fullName, comment) => make(\"JSDocCallbackTag\", {\n    tagName: tagName ?? createIdentifier(\"callback\"),\n    typeExpression,\n    fullName,\n    comment,\n});\n//# sourceMappingURL=createJSDocCallbackTag.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,sBAAsB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC/G,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,cAAc;AAClB,IAAI,QAAQ;AACZ,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocCallbackTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocCallbackTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,cAA8B,EAC9B,QAAqB,EACrB,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAChD,cAAc;IACd,QAAQ;IACR,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocClassTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocClassTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocClassTag}: a `@class` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `class` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @class\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `class`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocClassTag}.\n */\nexport const createJSDocClassTag = (tagName, comment) => make(\"JSDocClassTag\", {\n    tagName: tagName ?? createIdentifier(\"class\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocClassTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,eAAe,EAAE;AAC/E,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC;AACjD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocClassTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocClassTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,mBAAmB,GAAG,CACjC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,eAAe,EAAE;AACpB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC;IAC7C,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocComment.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocComment.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDoc}: a `/** ... *\\/` comment block.\n *\n * The `comment` is the leading summary text, and `tags` are the block tags that\n * follow it. The printer wraps the whole thing in the `/**` and `*\\/`\n * delimiters and prefixes each interior line with `*`.\n *\n * With a `Just a summary.` comment and no tags, the printer emits:\n *\n * ```ts\n * /**\n *  * Just a summary.\n *  *\\/\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param comment The leading comment text, if any.\n * @param tags The tags, if any.\n * @returns The created {@link JSDoc}.\n */\nexport const createJSDocComment = (comment, tags) => make(\"JSDoc\", {\n    comment,\n    tags,\n});\n//# sourceMappingURL=createJSDocComment.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,IAAI,CAAC,OAAO,EAAE;AACnE,IAAI,OAAO;AACX,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocComment.mjs","sources":["../../../src/factory/jsdoc/createJSDocComment.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,kBAAkB,GAAG,CAChC,OAAsD,EACtD,IAAsC,KAEtC,IAAI,CAAC,OAAO,EAAE;IACZ,OAAO;IACP,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocDeprecatedTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocDeprecatedTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocDeprecatedTag}: a `@deprecated` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `deprecated` when omitted. The\n * `comment` is the trailing text explaining the deprecation.\n *\n * With the default tag name and a `use foo` comment, the printer emits:\n *\n * ```ts\n * @deprecated use foo\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `deprecated`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocDeprecatedTag}.\n */\nexport const createJSDocDeprecatedTag = (tagName, comment) => make(\"JSDocDeprecatedTag\", {\n    tagName: tagName ?? createIdentifier(\"deprecated\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocDeprecatedTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,oBAAoB,EAAE;AACzF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,YAAY,CAAC;AACtD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocDeprecatedTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocDeprecatedTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,wBAAwB,GAAG,CACtC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,oBAAoB,EAAE;AACzB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,YAAY,CAAC;IAClD,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocEnumTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocEnumTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocEnumTag}: an `@enum` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `enum` when omitted. The\n * `typeExpression` supplies the brace-wrapped member type, and `comment` is the\n * trailing description, if any.\n *\n * With the default tag name and a `{number}` type expression, the printer\n * emits:\n *\n * ```ts\n * @enum {number}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `enum`.\n * @param typeExpression The type expression.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocEnumTag}.\n */\nexport const createJSDocEnumTag = (tagName, typeExpression, comment) => make(\"JSDocEnumTag\", {\n    tagName: tagName ?? createIdentifier(\"enum\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocEnumTag.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,kBAAkB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE;AAC7F,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;AAChD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocEnumTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocEnumTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,kBAAkB,GAAG,CAChC,OAA+B,EAC/B,cAAmC,EACnC,OAA0C,KAE1C,IAAI,CAAC,cAAc,EAAE;AACnB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAC5C,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocFunctionType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocFunctionType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocFunctionType}: a JSDoc `function(...)` type.\n *\n * The `parameters` are the function parameters, printed inside the parentheses.\n * The `type` is the return type, printed after a colon when present.\n *\n * With no parameters and a `number` return type, the printer emits:\n *\n * ```ts\n * function(): number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param parameters The parameters.\n * @param type The return type, if any.\n * @returns The created {@link JSDocFunctionType}.\n */\nexport const createJSDocFunctionType = (parameters, type) => make(\"JSDocFunctionType\", {\n    parameters,\n    type,\n});\n//# sourceMappingURL=createJSDocFunctionType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACvF,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocFunctionType.mjs","sources":["../../../src/factory/jsdoc/createJSDocFunctionType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CACrC,UAA2C,EAC3C,IAA0B,KAE1B,IAAI,CAAC,mBAAmB,EAAE;IACxB,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocImplementsTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocImplementsTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocImplementsTag}: an `@implements` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `implements` when omitted. The\n * `className` is the implemented interface or class expression, which the\n * printer wraps in braces. The `comment` is the trailing description, if any.\n *\n * With the default tag name and an `Iface` class expression, the printer emits:\n *\n * ```ts\n * @implements {Iface}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `implements`.\n * @param className The implemented class.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocImplementsTag}.\n */\nexport const createJSDocImplementsTag = (tagName, className, comment) => make(\"JSDocImplementsTag\", {\n    tagName: tagName ?? createIdentifier(\"implements\"),\n    class: className,\n    comment,\n});\n//# sourceMappingURL=createJSDocImplementsTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC,oBAAoB,EAAE;AACpG,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,YAAY,CAAC;AACtD,IAAI,KAAK,EAAE,SAAS;AACpB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocImplementsTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocImplementsTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,wBAAwB,GAAG,CACtC,OAA+B,EAC/B,SAAsC,EACtC,OAA0C,KAE1C,IAAI,CAAC,oBAAoB,EAAE;AACzB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,YAAY,CAAC;AAClD,IAAA,KAAK,EAAE,SAAS;IAChB,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocImportTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocImportTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocImportTag}: an `@import` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `import` when omitted. The\n * `importClause` names the bindings to bring in, the `moduleSpecifier` is the\n * source module, and `comment` is the trailing description. The printer mirrors\n * an ordinary import statement after the tag name.\n *\n * With the default tag name, a named import clause for `Foo`, and a `\"./mod\"`\n * module specifier, the printer emits:\n *\n * ```ts\n * @import { Foo } from \"./mod\"\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `import`.\n * @param importClause The import clause, if any.\n * @param moduleSpecifier The module specifier.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocImportTag}.\n */\nexport const createJSDocImportTag = (tagName, importClause, moduleSpecifier, comment) => make(\"JSDocImportTag\", {\n    tagName: tagName ?? createIdentifier(\"import\"),\n    importClause,\n    moduleSpecifier,\n    comment,\n});\n//# sourceMappingURL=createJSDocImportTag.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;AACY,MAAC,oBAAoB,GAAG,CAAC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAChH,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;AAClD,IAAI,YAAY;AAChB,IAAI,eAAe;AACnB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocImportTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocImportTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,oBAAoB,GAAG,CAClC,OAA+B,EAC/B,YAAsC,EACtC,eAA2B,EAC3B,OAA0C,KAE1C,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;IAC9C,YAAY;IACZ,eAAe;IACf,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocLink.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocLink.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocLink}: an inline `{@link ...}` reference.\n *\n * The `name` is the linked target, if any, and `text` is the trailing label.\n * The printer appends the text to the name verbatim, with no separator inserted\n * between them, so any space you want before the label must be part of `text`.\n * When `name` is omitted, only the text is printed.\n *\n * With a `Foo` name and a ` the foo` text (note the leading space), the printer\n * emits:\n *\n * ```ts\n * {@link Foo the foo}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The linked name, if any.\n * @param text The trailing link text.\n * @returns The created {@link JSDocLink}.\n */\nexport const createJSDocLink = (name, text) => make(\"JSDocLink\", {\n    name,\n    text,\n});\n//# sourceMappingURL=createJSDocLink.js.map"],"names":[],"mappings":";;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,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;AACjE,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocLink.mjs","sources":["../../../src/factory/jsdoc/createJSDocLink.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,eAAe,GAAG,CAC7B,IAA8C,EAC9C,IAAY,KAEZ,IAAI,CAAC,WAAW,EAAE;IAChB,IAAI;IACJ,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocLinkCode.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocLinkCode.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocLinkCode}: an inline `{@linkcode ...}` reference.\n *\n * The `name` is the linked target, if any, and `text` is the trailing label,\n * rendered as code by documentation tooling. The printer appends the text to\n * the name verbatim, with no separator inserted between them, so any space you\n * want before the label must be part of `text`.\n *\n * With a `Foo` name and a ` the foo` text (note the leading space), the printer\n * emits:\n *\n * ```ts\n * {@linkcode Foo the foo}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The linked name, if any.\n * @param text The trailing link text.\n * @returns The created {@link JSDocLinkCode}.\n */\nexport const createJSDocLinkCode = (name, text) => make(\"JSDocLinkCode\", {\n    name,\n    text,\n});\n//# sourceMappingURL=createJSDocLinkCode.js.map"],"names":[],"mappings":";;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,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,eAAe,EAAE;AACzE,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocLinkCode.mjs","sources":["../../../src/factory/jsdoc/createJSDocLinkCode.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,mBAAmB,GAAG,CACjC,IAA8C,EAC9C,IAAY,KAEZ,IAAI,CAAC,eAAe,EAAE;IACpB,IAAI;IACJ,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocLinkPlain.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocLinkPlain.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocLinkPlain}: an inline `{@linkplain ...}` reference.\n *\n * The `name` is the linked target, if any, and `text` is the trailing label,\n * rendered as plain text by documentation tooling. The printer appends the text\n * to the name verbatim, with no separator inserted between them, so any space\n * you want before the label must be part of `text`.\n *\n * With a `Foo` name and a ` the foo` text (note the leading space), the printer\n * emits:\n *\n * ```ts\n * {@linkplain Foo the foo}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The linked name, if any.\n * @param text The trailing link text.\n * @returns The created {@link JSDocLinkPlain}.\n */\nexport const createJSDocLinkPlain = (name, text) => make(\"JSDocLinkPlain\", {\n    name,\n    text,\n});\n//# sourceMappingURL=createJSDocLinkPlain.js.map"],"names":[],"mappings":";;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,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC,gBAAgB,EAAE;AAC3E,IAAI,IAAI;AACR,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocLinkPlain.mjs","sources":["../../../src/factory/jsdoc/createJSDocLinkPlain.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,oBAAoB,GAAG,CAClC,IAA8C,EAC9C,IAAY,KAEZ,IAAI,CAAC,gBAAgB,EAAE;IACrB,IAAI;IACJ,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocMemberName.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocMemberName.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocMemberName}: a JSDoc `#`-joined member reference.\n *\n * The `left` is the owning name and `right` is the member. The printer joins\n * them with a `#`, the JSDoc separator for an instance member.\n *\n * With a left of `Foo` and a right of `bar`, the printer emits:\n *\n * ```ts\n * Foo#bar\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param left The left-hand side.\n * @param right The right-hand side.\n * @returns The created {@link JSDocMemberName}.\n */\nexport const createJSDocMemberName = (left, right) => make(\"JSDocMemberName\", {\n    left,\n    right,\n});\n//# sourceMappingURL=createJSDocMemberName.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,iBAAiB,EAAE;AAC9E,IAAI,IAAI;AACR,IAAI,KAAK;AACT,CAAC;;;;"}
+{"version":3,"file":"createJSDocMemberName.mjs","sources":["../../../src/factory/jsdoc/createJSDocMemberName.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,qBAAqB,GAAG,CACnC,IAAkC,EAClC,KAAiB,KAEjB,IAAI,CAAC,iBAAiB,EAAE;IACtB,IAAI;IACJ,KAAK;AACN,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocNameReference.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocNameReference.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocNameReference}: a JSDoc reference to a declared name.\n *\n * The `name` is the referenced entity or member name. The printer emits that\n * name directly, with no surrounding decoration. This node is what tags such as\n * `@see` carry as their target.\n *\n * With a `Foo` name, the printer emits:\n *\n * ```ts\n * Foo;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The referenced name.\n * @returns The created {@link JSDocNameReference}.\n */\nexport const createJSDocNameReference = (name) => make(\"JSDocNameReference\", {\n    name,\n});\n//# sourceMappingURL=createJSDocNameReference.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,wBAAwB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,oBAAoB,EAAE;AAC7E,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocNameReference.mjs","sources":["../../../src/factory/jsdoc/createJSDocNameReference.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,wBAAwB,GAAG,CACtC,IAAkC,KAElC,IAAI,CAAC,oBAAoB,EAAE;IACzB,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocNamepathType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocNamepathType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocNamepathType}: a JSDoc namepath type.\n *\n * The `type` is the wrapped type. This node carries no marker of its own, so\n * the printer emits the wrapped type alone with no surrounding prefix or\n * suffix.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * number;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocNamepathType}.\n */\nexport const createJSDocNamepathType = (type) => make(\"JSDocNamepathType\", {\n    type,\n});\n//# sourceMappingURL=createJSDocNamepathType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3E,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocNamepathType.mjs","sources":["../../../src/factory/jsdoc/createJSDocNamepathType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CAAC,IAAc,KACpD,IAAI,CAAC,mBAAmB,EAAE;IACxB,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocNonNullableType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocNonNullableType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocNonNullableType}: a JSDoc `!`-marked non-nullable type.\n *\n * The `type` is the wrapped type. The `postfix` flag controls placement of the\n * `!` marker: when `true` it prints after the type, when `false` it prints\n * before.\n *\n * With a `number` type and `postfix` of `true`, the printer emits:\n *\n * ```ts\n * number!;\n * ```\n *\n * The same type with `postfix` of `false` instead emits:\n *\n * ```ts\n * !number;\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @param postfix Whether the `!` is written after the type.\n * @returns The created {@link JSDocNonNullableType}.\n */\nexport const createJSDocNonNullableType = (type, postfix = false) => make(\"JSDocNonNullableType\", {\n    type,\n    postfix,\n});\n//# sourceMappingURL=createJSDocNonNullableType.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,0BAA0B,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,KAAK,IAAI,CAAC,sBAAsB,EAAE;AAClG,IAAI,IAAI;AACR,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocNonNullableType.mjs","sources":["../../../src/factory/jsdoc/createJSDocNonNullableType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,0BAA0B,GAAG,CACxC,IAAc,EACd,OAAA,GAAmB,KAAK,KAExB,IAAI,CAAC,sBAAsB,EAAE;IAC3B,IAAI;IACJ,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocNullableType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocNullableType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocNullableType}: a JSDoc `?`-marked nullable type.\n *\n * The `type` is the wrapped type. The `postfix` flag controls placement of the\n * `?` marker: when `true` it prints after the type, when `false` it prints\n * before.\n *\n * With a `number` type and `postfix` of `true`, the printer emits:\n *\n * ```ts\n * number?\n * ```\n *\n * The same type with `postfix` of `false` instead emits:\n *\n * ```ts\n * ?number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @param postfix Whether the `?` is written after the type.\n * @returns The created {@link JSDocNullableType}.\n */\nexport const createJSDocNullableType = (type, postfix = false) => make(\"JSDocNullableType\", {\n    type,\n    postfix,\n});\n//# sourceMappingURL=createJSDocNullableType.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,uBAAuB,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC5F,IAAI,IAAI;AACR,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocNullableType.mjs","sources":["../../../src/factory/jsdoc/createJSDocNullableType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,uBAAuB,GAAG,CACrC,IAAc,EACd,OAAA,GAAmB,KAAK,KAExB,IAAI,CAAC,mBAAmB,EAAE;IACxB,IAAI;IACJ,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocOptionalType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocOptionalType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocOptionalType}: a JSDoc `=`-marked optional type.\n *\n * The `type` is the wrapped type. The printer appends an `=` marker after it.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * number=\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocOptionalType}.\n */\nexport const createJSDocOptionalType = (type) => make(\"JSDocOptionalType\", {\n    type,\n});\n//# sourceMappingURL=createJSDocOptionalType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3E,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocOptionalType.mjs","sources":["../../../src/factory/jsdoc/createJSDocOptionalType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,uBAAuB,GAAG,CAAC,IAAc,KACpD,IAAI,CAAC,mBAAmB,EAAE;IACxB,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocOverloadTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocOverloadTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocOverloadTag}: an `@overload` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `overload` when omitted. The\n * `typeExpression` is the {@link JSDocSignature} describing the overload, and\n * `comment` is the trailing description. The printer prints the tag on the\n * first line, then the signature's `@param` and `@returns` tags on their own\n * lines.\n *\n * With the default tag name and a signature taking `{number} x` and returning\n * `{void}`, the printer emits:\n *\n * ```ts\n * @overload\n * @param {number} x\n * @returns {void}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `overload`.\n * @param typeExpression The overload signature.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocOverloadTag}.\n */\nexport const createJSDocOverloadTag = (tagName, typeExpression, comment) => make(\"JSDocOverloadTag\", {\n    tagName: tagName ?? createIdentifier(\"overload\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocOverloadTag.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;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AACrG,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocOverloadTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocOverloadTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,cAA8B,EAC9B,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAChD,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocOverrideTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocOverrideTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocOverrideTag}: an `@override` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `override` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @override\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `override`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocOverrideTag}.\n */\nexport const createJSDocOverrideTag = (tagName, comment) => make(\"JSDocOverrideTag\", {\n    tagName: tagName ?? createIdentifier(\"override\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocOverrideTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AACrF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocOverrideTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocOverrideTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAChD,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocParameterTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocParameterTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocParameterTag}: a `@param` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `param` when omitted. The\n * `name` is the documented parameter, `isBracketed` wraps that name in square\n * brackets to mark it optional, and `typeExpression` supplies the brace-wrapped\n * type. The `isNameFirst` flag controls ordering: when `true` the name prints\n * before the type, when `false` the type prints first. The `comment` is the\n * trailing description.\n *\n * With the default tag name, name `x`, a `{number}` type expression, and a `the\n * x` comment, `isNameFirst` of `true` prints the name ahead of the type:\n *\n * ```ts\n * @param x {number} the x\n * ```\n *\n * The same inputs with `isNameFirst` of `false` print the type first:\n *\n * ```ts\n * @param {number} x the x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `param`.\n * @param name The parameter name.\n * @param isBracketed Whether the name was wrapped in brackets.\n * @param typeExpression The type expression, if any.\n * @param isNameFirst Whether the name was written before the type.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocParameterTag}.\n */\nexport const createJSDocParameterTag = (tagName, name, isBracketed, typeExpression, isNameFirst = false, comment) => make(\"JSDocParameterTag\", {\n    tagName: tagName ?? createIdentifier(\"param\"),\n    name,\n    isBracketed,\n    typeExpression,\n    isNameFirst: !!isNameFirst,\n    comment,\n});\n//# sourceMappingURL=createJSDocParameterTag.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;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,GAAG,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC/I,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC;AACjD,IAAI,IAAI;AACR,IAAI,WAAW;AACf,IAAI,cAAc;AAClB,IAAI,WAAW,EAAE,CAAC,CAAC,WAAW;AAC9B,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocParameterTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocParameterTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;MACU,uBAAuB,GAAG,CACrC,OAA+B,EAC/B,IAAgB,EAChB,WAAoB,EACpB,cAAoC,EACpC,WAAA,GAAuB,KAAK,EAC5B,OAA0C,KAE1C,IAAI,CAAC,mBAAmB,EAAE;AACxB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,OAAO,CAAC;IAC7C,IAAI;IACJ,WAAW;IACX,cAAc;IACd,WAAW,EAAE,CAAC,CAAC,WAAW;IAC1B,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocPrivateTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocPrivateTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocPrivateTag}: a `@private` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `private` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @private\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `private`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocPrivateTag}.\n */\nexport const createJSDocPrivateTag = (tagName, comment) => make(\"JSDocPrivateTag\", {\n    tagName: tagName ?? createIdentifier(\"private\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocPrivateTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACnF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;AACnD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocPrivateTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocPrivateTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,iBAAiB,EAAE;AACtB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAC/C,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocPropertyTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocPropertyTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocPropertyTag}: a `@prop` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `prop` when omitted. The `name`\n * is the documented property, `isBracketed` wraps that name in square brackets\n * to mark it optional, and `typeExpression` supplies the brace-wrapped type.\n * The `isNameFirst` flag controls ordering: when `true` the name prints before\n * the type, when `false` the type prints first. The `comment` is the trailing\n * description.\n *\n * With the default tag name, name `x`, a `{number}` type expression, `the x`\n * comment, and `isNameFirst` of `true`, the printer emits:\n *\n * ```ts\n * @prop x {number} the x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `prop`.\n * @param name The property name.\n * @param isBracketed Whether the name was wrapped in brackets.\n * @param typeExpression The type expression, if any.\n * @param isNameFirst Whether the name was written before the type.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocPropertyTag}.\n */\nexport const createJSDocPropertyTag = (tagName, name, isBracketed, typeExpression, isNameFirst = false, comment) => make(\"JSDocPropertyTag\", {\n    tagName: tagName ?? createIdentifier(\"prop\"),\n    name,\n    isBracketed,\n    typeExpression,\n    isNameFirst: !!isNameFirst,\n    comment,\n});\n//# sourceMappingURL=createJSDocPropertyTag.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;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,GAAG,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC7I,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;AAChD,IAAI,IAAI;AACR,IAAI,WAAW;AACf,IAAI,cAAc;AAClB,IAAI,WAAW,EAAE,CAAC,CAAC,WAAW;AAC9B,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocPropertyTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocPropertyTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;MACU,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,IAAgB,EAChB,WAAoB,EACpB,cAAoC,EACpC,WAAA,GAAuB,KAAK,EAC5B,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAC5C,IAAI;IACJ,WAAW;IACX,cAAc;IACd,WAAW,EAAE,CAAC,CAAC,WAAW;IAC1B,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocProtectedTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocProtectedTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocProtectedTag}: a `@protected` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `protected` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @protected\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `protected`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocProtectedTag}.\n */\nexport const createJSDocProtectedTag = (tagName, comment) => make(\"JSDocProtectedTag\", {\n    tagName: tagName ?? createIdentifier(\"protected\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocProtectedTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACvF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,WAAW,CAAC;AACrD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocProtectedTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocProtectedTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,uBAAuB,GAAG,CACrC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,mBAAmB,EAAE;AACxB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,WAAW,CAAC;IACjD,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocPublicTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocPublicTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocPublicTag}: a `@public` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `public` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @public\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `public`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocPublicTag}.\n */\nexport const createJSDocPublicTag = (tagName, comment) => make(\"JSDocPublicTag\", {\n    tagName: tagName ?? createIdentifier(\"public\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocPublicTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,oBAAoB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACjF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;AAClD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocPublicTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocPublicTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,oBAAoB,GAAG,CAClC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,QAAQ,CAAC;IAC9C,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocReadonlyTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocReadonlyTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocReadonlyTag}: a `@readonly` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `readonly` when omitted. The\n * `comment` is the trailing description, if any.\n *\n * With the default tag name and no comment, the printer emits:\n *\n * ```ts\n * @readonly\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `readonly`.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocReadonlyTag}.\n */\nexport const createJSDocReadonlyTag = (tagName, comment) => make(\"JSDocReadonlyTag\", {\n    tagName: tagName ?? createIdentifier(\"readonly\"),\n    comment,\n});\n//# sourceMappingURL=createJSDocReadonlyTag.js.map"],"names":[],"mappings":";;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AACrF,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocReadonlyTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocReadonlyTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAChD,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocReturnTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocReturnTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocReturnTag}: a `@returns` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `returns` when omitted. The\n * `typeExpression` supplies the brace-wrapped return type, and `comment` is the\n * trailing description. When the type expression is omitted, the printer drops\n * the braces and emits only the tag name and comment.\n *\n * With the default tag name, a `{number}` type expression, and a `the count`\n * comment, the printer emits:\n *\n * ```ts\n * @returns {number} the count\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `returns`.\n * @param typeExpression The type expression, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocReturnTag}.\n */\nexport const createJSDocReturnTag = (tagName, typeExpression, comment) => make(\"JSDocReturnTag\", {\n    tagName: tagName ?? createIdentifier(\"returns\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocReturnTag.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,oBAAoB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACjG,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;AACnD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocReturnTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocReturnTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,oBAAoB,GAAG,CAClC,OAA+B,EAC/B,cAAoC,EACpC,OAA0C,KAE1C,IAAI,CAAC,gBAAgB,EAAE;AACrB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAC/C,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocSatisfiesTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocSatisfiesTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocSatisfiesTag}: a `@satisfies` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `satisfies` when omitted. The\n * `typeExpression` supplies the brace-wrapped target type, and `comment` is the\n * trailing description.\n *\n * With the default tag name, a `{Foo}` type expression, and an `ok` comment,\n * the printer emits:\n *\n * ```ts\n * @satisfies {Foo} ok\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `satisfies`.\n * @param typeExpression The type expression.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocSatisfiesTag}.\n */\nexport const createJSDocSatisfiesTag = (tagName, typeExpression, comment) => make(\"JSDocSatisfiesTag\", {\n    tagName: tagName ?? createIdentifier(\"satisfies\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocSatisfiesTag.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,uBAAuB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,mBAAmB,EAAE;AACvG,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,WAAW,CAAC;AACrD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocSatisfiesTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocSatisfiesTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,uBAAuB,GAAG,CACrC,OAA+B,EAC/B,cAAmC,EACnC,OAA0C,KAE1C,IAAI,CAAC,mBAAmB,EAAE;AACxB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,WAAW,CAAC;IACjD,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocSeeTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocSeeTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocSeeTag}: a `@see` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `see` when omitted. The\n * `nameExpression` is the referenced name, if any, and `comment` is the\n * trailing description.\n *\n * With the default tag name, a `Foo` name reference, and a `more` comment, the\n * printer emits:\n *\n * ```ts\n * @see Foo more\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `see`.\n * @param nameExpression The referenced name, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocSeeTag}.\n */\nexport const createJSDocSeeTag = (tagName, nameExpression, comment) => make(\"JSDocSeeTag\", {\n    tagName: tagName ?? createIdentifier(\"see\"),\n    name: nameExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocSeeTag.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,iBAAiB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,aAAa,EAAE;AAC3F,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC;AAC/C,IAAI,IAAI,EAAE,cAAc;AACxB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocSeeTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocSeeTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,iBAAiB,GAAG,CAC/B,OAA+B,EAC/B,cAA8C,EAC9C,OAA0C,KAE1C,IAAI,CAAC,aAAa,EAAE;AAClB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,KAAK,CAAC;AAC3C,IAAA,IAAI,EAAE,cAAc;IACpB,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocSignature.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocSignature.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocSignature}: the synthetic signature behind `@callback`\n * and `@overload` tags.\n *\n * The `typeParameters` are the `@template` tags, `parameters` are the `@param`\n * tags, and `type` is the `@returns` tag. The printer emits each on its own\n * line, in that order.\n *\n * With no type parameters, a single `@param {number} x the x` tag, and an\n * `@returns {boolean}` tag, the printer emits:\n *\n * ```ts\n * @param {number} x the x\n * @returns {boolean}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param typeParameters The `@template` type parameters, if any.\n * @param parameters The `@param` tags.\n * @param type The `@return` tag, if any.\n * @returns The created {@link JSDocSignature}.\n */\nexport const createJSDocSignature = (typeParameters, parameters, type) => make(\"JSDocSignature\", {\n    typeParameters,\n    parameters,\n    type,\n});\n//# sourceMappingURL=createJSDocSignature.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,oBAAoB,GAAG,CAAC,cAAc,EAAE,UAAU,EAAE,IAAI,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACjG,IAAI,cAAc;AAClB,IAAI,UAAU;AACd,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocSignature.mjs","sources":["../../../src/factory/jsdoc/createJSDocSignature.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,oBAAoB,GAAG,CAClC,cAAuD,EACvD,UAAwC,EACxC,IAAqB,KAErB,IAAI,CAAC,gBAAgB,EAAE;IACrB,cAAc;IACd,UAAU;IACV,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocTemplateTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTemplateTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocTemplateTag}: a `@template` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `template` when omitted. The\n * `constraint` is the shared brace-wrapped bound applied to every declared\n * parameter, if any. The `typeParameters` are the declared names, and `comment`\n * is the trailing description.\n *\n * With the default tag name, a `{string}` constraint, and a single `T` type\n * parameter, the printer emits:\n *\n * ```ts\n * @template {string} T\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `template`.\n * @param constraint The shared constraint, if any.\n * @param typeParameters The declared type parameters.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocTemplateTag}.\n */\nexport const createJSDocTemplateTag = (tagName, constraint, typeParameters, comment) => make(\"JSDocTemplateTag\", {\n    tagName: tagName ?? createIdentifier(\"template\"),\n    constraint,\n    typeParameters,\n    comment,\n});\n//# sourceMappingURL=createJSDocTemplateTag.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;AACY,MAAC,sBAAsB,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,kBAAkB,EAAE;AACjH,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;AACpD,IAAI,UAAU;AACd,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocTemplateTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocTemplateTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,sBAAsB,GAAG,CACpC,OAA+B,EAC/B,UAA2C,EAC3C,cAAmD,EACnD,OAA0C,KAE1C,IAAI,CAAC,kBAAkB,EAAE;AACvB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,UAAU,CAAC;IAChD,UAAU;IACV,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocText.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocText.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocText}: a run of plain text inside a JSDoc comment.\n *\n * The `text` is the literal content. The printer emits it verbatim, with no\n * decoration. This node holds the prose that sits between inline tags in a\n * comment body.\n *\n * With a `hello world` text, the printer emits:\n *\n * ```ts\n * hello world\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param text The textual content.\n * @returns The created {@link JSDocText}.\n */\nexport const createJSDocText = (text) => make(\"JSDocText\", {\n    text,\n});\n//# sourceMappingURL=createJSDocText.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW,EAAE;AAC3D,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocText.mjs","sources":["../../../src/factory/jsdoc/createJSDocText.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,eAAe,GAAG,CAAC,IAAY,KAC1C,IAAI,CAAC,WAAW,EAAE;IAChB,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocThisTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocThisTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocThisTag}: a `@this` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `this` when omitted. The\n * `typeExpression` supplies the brace-wrapped `this` type, and `comment` is the\n * trailing description, if any.\n *\n * With the default tag name and a `{Foo}` type expression, the printer emits:\n *\n * ```ts\n * @this {Foo}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `this`.\n * @param typeExpression The type expression.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocThisTag}.\n */\nexport const createJSDocThisTag = (tagName, typeExpression, comment) => make(\"JSDocThisTag\", {\n    tagName: tagName ?? createIdentifier(\"this\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocThisTag.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,kBAAkB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE;AAC7F,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;AAChD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocThisTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocThisTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;AAkBG;AACI,MAAM,kBAAkB,GAAG,CAChC,OAA+B,EAC/B,cAAmC,EACnC,OAA0C,KAE1C,IAAI,CAAC,cAAc,EAAE;AACnB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAC5C,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocThrowsTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocThrowsTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocThrowsTag}: a `@throws` JSDoc tag.\n *\n * The `tagName` is the identifier after the `@`, such as `throws`. The\n * `typeExpression` supplies the brace-wrapped thrown type, and `comment` is the\n * trailing description.\n *\n * With a tag name of `throws`, an `{Error}` type expression, and an `on\n * failure` comment, the printer emits:\n *\n * ```ts\n * @throws {Error} on failure\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param typeExpression The type expression, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocThrowsTag}.\n */\nexport const createJSDocThrowsTag = (tagName, typeExpression, comment) => make(\"JSDocThrowsTag\", {\n    tagName,\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocThrowsTag.js.map"],"names":[],"mappings":";;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,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;AACjG,IAAI,OAAO;AACX,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocThrowsTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocThrowsTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,oBAAoB,GAAG,CAClC,OAAmB,EACnB,cAA+C,EAC/C,OAA0C,KAE1C,IAAI,CAAC,gBAAgB,EAAE;IACrB,OAAO;IACP,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocTypeExpression.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeExpression.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocTypeExpression}: a brace-wrapped JSDoc type.\n *\n * The `type` is the wrapped type. The printer surrounds it with curly braces,\n * producing the `{Type}` form that JSDoc tags use to carry their type.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * {number}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocTypeExpression}.\n */\nexport const createJSDocTypeExpression = (type) => make(\"JSDocTypeExpression\", {\n    type,\n});\n//# sourceMappingURL=createJSDocTypeExpression.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,yBAAyB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,qBAAqB,EAAE;AAC/E,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocTypeExpression.mjs","sources":["../../../src/factory/jsdoc/createJSDocTypeExpression.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,yBAAyB,GAAG,CACvC,IAAc,KAEd,IAAI,CAAC,qBAAqB,EAAE;IAC1B,IAAI;AACL,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocTypeLiteral.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeLiteral.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocTypeLiteral}: an object-shape type built from `@prop`\n * tags.\n *\n * The `jsDocPropertyTags` are the member property tags, which the printer emits\n * one per line. The `isArrayType` flag, when `true`, appends `[]` to mark the\n * literal as an array of that shape.\n *\n * With a single `@prop {number} x` member tag and `isArrayType` of `false`, the\n * printer emits:\n *\n * ```ts\n * @prop {number} x\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param jsDocPropertyTags The member `@property` tags, if any.\n * @param isArrayType Whether the literal represents an array of its type.\n * @returns The created {@link JSDocTypeLiteral}.\n */\nexport const createJSDocTypeLiteral = (jsDocPropertyTags, isArrayType = false) => make(\"JSDocTypeLiteral\", {\n    jsDocPropertyTags,\n    isArrayType,\n});\n//# sourceMappingURL=createJSDocTypeLiteral.js.map"],"names":[],"mappings":";;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,iBAAiB,EAAE,WAAW,GAAG,KAAK,KAAK,IAAI,CAAC,kBAAkB,EAAE;AAC3G,IAAI,iBAAiB;AACrB,IAAI,WAAW;AACf,CAAC;;;;"}
+{"version":3,"file":"createJSDocTypeLiteral.mjs","sources":["../../../src/factory/jsdoc/createJSDocTypeLiteral.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,sBAAsB,GAAG,CACpC,iBAA+C,EAC/C,WAAA,GAAuB,KAAK,KAE5B,IAAI,CAAC,kBAAkB,EAAE;IACvB,iBAAiB;IACjB,WAAW;AACZ,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocTypeTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypeTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocTypeTag}: a `@type` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `type` when omitted. The\n * `typeExpression` supplies the brace-wrapped type, and `comment` is the\n * trailing description, if any.\n *\n * With the default tag name and a `{number}` type expression, the printer\n * emits:\n *\n * ```ts\n * @type {number}\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `type`.\n * @param typeExpression The type expression.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocTypeTag}.\n */\nexport const createJSDocTypeTag = (tagName, typeExpression, comment) => make(\"JSDocTypeTag\", {\n    tagName: tagName ?? createIdentifier(\"type\"),\n    typeExpression,\n    comment,\n});\n//# sourceMappingURL=createJSDocTypeTag.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,kBAAkB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,KAAK,IAAI,CAAC,cAAc,EAAE;AAC7F,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;AAChD,IAAI,cAAc;AAClB,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocTypeTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocTypeTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AASA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,kBAAkB,GAAG,CAChC,OAA+B,EAC/B,cAAmC,EACnC,OAA0C,KAE1C,IAAI,CAAC,cAAc,EAAE;AACnB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAC5C,cAAc;IACd,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocTypedefTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocTypedefTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\nimport { createIdentifier } from \"../names/createIdentifier\";\n/**\n * Create a {@link JSDocTypedefTag}: a `@typedef` JSDoc tag.\n *\n * The `tagName` defaults to an identifier named `typedef` when omitted. The\n * `typeExpression` is the aliased type, either a brace-wrapped type expression\n * or a {@link JSDocTypeLiteral}. The `fullName` is the alias name, printed after\n * the type, and `comment` is the trailing description.\n *\n * With the default tag name, a `{number}` type expression, and a `Count` name,\n * the printer emits:\n *\n * ```ts\n * @typedef {number} Count\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name; defaults to `typedef`.\n * @param typeExpression The aliased type, if any.\n * @param fullName The full alias name, if any.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocTypedefTag}.\n */\nexport const createJSDocTypedefTag = (tagName, typeExpression, fullName, comment) => make(\"JSDocTypedefTag\", {\n    tagName: tagName ?? createIdentifier(\"typedef\"),\n    typeExpression,\n    fullName,\n    comment,\n});\n//# sourceMappingURL=createJSDocTypedefTag.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;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AAC7G,IAAI,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;AACnD,IAAI,cAAc;AAClB,IAAI,QAAQ;AACZ,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocTypedefTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocTypedefTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAA+B,EAC/B,cAAuD,EACvD,QAAqB,EACrB,OAA0C,KAE1C,IAAI,CAAC,iBAAiB,EAAE;AACtB,IAAA,OAAO,EAAE,OAAO,IAAI,gBAAgB,CAAC,SAAS,CAAC;IAC/C,cAAc;IACd,QAAQ;IACR,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocUnknownTag.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocUnknownTag.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocUnknownTag}: a JSDoc tag whose name is not one of the\n * recognized tags.\n *\n * The `tagName` is the identifier after the `@`, and `comment` is the trailing\n * text. This is the fallback node for any custom or unrecognized tag.\n *\n * With a tag name of `custom` and a `hello` comment, the printer emits:\n *\n * ```ts\n * @custom hello\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @param comment The trailing comment, if any.\n * @returns The created {@link JSDocUnknownTag}.\n */\nexport const createJSDocUnknownTag = (tagName, comment) => make(\"JSDocUnknownTag\", {\n    tagName,\n    comment,\n});\n//# sourceMappingURL=createJSDocUnknownTag.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,iBAAiB,EAAE;AACnF,IAAI,OAAO;AACX,IAAI,OAAO;AACX,CAAC;;;;"}
+{"version":3,"file":"createJSDocUnknownTag.mjs","sources":["../../../src/factory/jsdoc/createJSDocUnknownTag.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,qBAAqB,GAAG,CACnC,OAAmB,EACnB,OAA0C,KAE1C,IAAI,CAAC,iBAAiB,EAAE;IACtB,OAAO;IACP,OAAO;AACR,CAAA;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocUnknownType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocUnknownType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocUnknownType}: the JSDoc `?` unknown type.\n *\n * This node takes no inputs. It represents the unknown-type marker written as a\n * bare question mark in a JSDoc type expression.\n *\n * The printer emits:\n *\n * ```ts\n * ?\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @returns The created {@link JSDocUnknownType}.\n */\nexport const createJSDocUnknownType = () => make(\"JSDocUnknownType\", {});\n//# sourceMappingURL=createJSDocUnknownType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,sBAAsB,GAAG,MAAM,IAAI,CAAC,kBAAkB,EAAE,EAAE;;;;"}
+{"version":3,"file":"createJSDocUnknownType.mjs","sources":["../../../src/factory/jsdoc/createJSDocUnknownType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GAAG,MACpC,IAAI,CAAC,kBAAkB,EAAE,EAAE;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"createJSDocVariadicType.mjs","sources":["../../../esm-tmp/factory/jsdoc/createJSDocVariadicType.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JSDocVariadicType}: a JSDoc `...`-marked variadic type.\n *\n * The `type` is the wrapped element type. The printer prepends a `...` marker\n * before it.\n *\n * With a `number` type, the printer emits:\n *\n * ```ts\n * ...number\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param type The wrapped type.\n * @returns The created {@link JSDocVariadicType}.\n */\nexport const createJSDocVariadicType = (type) => make(\"JSDocVariadicType\", {\n    type,\n});\n//# sourceMappingURL=createJSDocVariadicType.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,EAAE;AAC3E,IAAI,IAAI;AACR,CAAC;;;;"}
+{"version":3,"file":"createJSDocVariadicType.mjs","sources":["../../../src/factory/jsdoc/createJSDocVariadicType.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;AAeG;AACI,MAAM,uBAAuB,GAAG,CAAC,IAAc,KACpD,IAAI,CAAC,mBAAmB,EAAE;IACxB,IAAI;AACL,CAAA;;;;"}

package/lib/factory/jsx/createJsxAttribute.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createJsxAttribute.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxAttribute.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxAttribute}: a single `name=value` prop on a JSX element.\n *\n * The name is a plain identifier or a {@link JsxNamespacedName} like\n * `xlink:href`. The initializer is the value: a string literal, or a\n * {@link JsxExpression} brace such as `{value}`. Pass `undefined` for a bare\n * boolean-style attribute, which prints the name alone with no `=value`.\n *\n * Given the name `bar` and a string-literal initializer `\"x\"`, the printer\n * emits:\n *\n * ```tsx\n * bar = \"x\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param name The name.\n * @param initializer The initializer, if any.\n * @returns The created {@link JsxAttribute}.\n */\nexport const createJsxAttribute = (name, initializer) => make(\"JsxAttribute\", {\n    name,\n    initializer,\n});\n//# sourceMappingURL=createJsxAttribute.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,kBAAkB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC,cAAc,EAAE;AAC9E,IAAI,IAAI;AACR,IAAI,WAAW;AACf,CAAC;;;;"}
+{"version":3,"file":"createJsxAttribute.mjs","sources":["../../../src/factory/jsx/createJsxAttribute.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAOA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,kBAAkB,GAAG,CAChC,IAAsB,EACtB,WAA0C,KAE1C,IAAI,CAAC,cAAc,EAAE;IACnB,IAAI;IACJ,WAAW;AACZ,CAAA;;;;"}

package/lib/factory/jsx/createJsxAttributes.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createJsxAttributes.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxAttributes.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxAttributes}: the ordered collection of props on a JSX\n * element.\n *\n * Each entry is either a {@link JsxAttribute} (`name=value`) or a\n * {@link JsxSpreadAttribute} (`{...props}`). This node is what an opening or\n * self-closing element holds as its `attributes`; an empty list prints to\n * nothing.\n *\n * Printed on its own, the collection leads with a separating space before each\n * attribute. Given a single `bar=\"x\"` property, the printer emits (note the\n * leading space):\n *\n * ```tsx\n * bar = \"x\";\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param properties The attribute properties.\n * @returns The created {@link JsxAttributes}.\n */\nexport const createJsxAttributes = (properties) => make(\"JsxAttributes\", { properties });\n//# sourceMappingURL=createJsxAttributes.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,mBAAmB,GAAG,CAAC,UAAU,KAAK,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}
+{"version":3,"file":"createJsxAttributes.mjs","sources":["../../../src/factory/jsx/createJsxAttributes.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;AAoBG;AACI,MAAM,mBAAmB,GAAG,CACjC,UAAuC,KACrB,IAAI,CAAC,eAAe,EAAE,EAAE,UAAU,EAAE;;;;"}

package/lib/factory/jsx/createJsxClosingElement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createJsxClosingElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxClosingElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxClosingElement}: the `</Tag>` that closes a paired\n * {@link JsxElement}.\n *\n * This is the trailing half of a `<Tag>...</Tag>` pair. The tag name must match\n * the one on the corresponding {@link JsxOpeningElement}; the factory does not\n * enforce that, so the caller is responsible for passing the same name.\n *\n * Given the tag name `Foo`, the printer emits:\n *\n * ```tsx\n * </Foo>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param tagName The tag name.\n * @returns The created {@link JsxClosingElement}.\n */\nexport const createJsxClosingElement = (tagName) => make(\"JsxClosingElement\", { tagName });\n//# sourceMappingURL=createJsxClosingElement.js.map"],"names":[],"mappings":";;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,uBAAuB,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE;;;;"}
+{"version":3,"file":"createJsxClosingElement.mjs","sources":["../../../src/factory/jsx/createJsxClosingElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,uBAAuB,GAAG,CACrC,OAAmB,KACG,IAAI,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE;;;;"}

package/lib/factory/jsx/createJsxElement.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"createJsxElement.mjs","sources":["../../../esm-tmp/factory/jsx/createJsxElement.js"],"sourcesContent":["import { make } from \"../internal/make\";\n/**\n * Create a {@link JsxElement}: a paired `<Tag>...</Tag>` element with children.\n *\n * The element is built from three already-created pieces: the\n * {@link JsxOpeningElement} that carries the tag name and attributes, the list\n * of children rendered between the tags, and the {@link JsxClosingElement} that\n * repeats the tag name. The children may be {@link JsxText}, nested elements,\n * fragments, or {@link JsxExpression} braces, in source order.\n *\n * Given an opening `<Foo bar=\"x\">`, a single `Hello` text child, and a closing\n * `</Foo>`, the printer emits:\n *\n * ```tsx\n * <Foo bar=\"x\">Hello</Foo>\n * ```\n *\n * @author Jeongho Nam - https://github.com/samchon\n * @param openingElement The opening element.\n * @param children The children.\n * @param closingElement The closing element.\n * @returns The created {@link JsxElement}.\n */\nexport const createJsxElement = (openingElement, children, closingElement) => make(\"JsxElement\", {\n    openingElement,\n    children,\n    closingElement,\n});\n//# sourceMappingURL=createJsxElement.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,gBAAgB,GAAG,CAAC,cAAc,EAAE,QAAQ,EAAE,cAAc,KAAK,IAAI,CAAC,YAAY,EAAE;AACjG,IAAI,cAAc;AAClB,IAAI,QAAQ;AACZ,IAAI,cAAc;AAClB,CAAC;;;;"}
+{"version":3,"file":"createJsxElement.mjs","sources":["../../../src/factory/jsx/createJsxElement.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAQA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,MAAM,gBAAgB,GAAG,CAC9B,cAAiC,EACjC,QAA6B,EAC7B,cAAiC,KAEjC,IAAI,CAAC,YAAY,EAAE;IACjB,cAAc;IACd,QAAQ;IACR,cAAc;AACf,CAAA;;;;"}