@ttsc/factory 0.15.9 → 0.15.11

package/lib/factory/jsdoc/createJSDocAuthorTag.mjs

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocAuthorTag}: an `@author` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `author` when omitted. The
+ * `comment` is the trailing text naming the author.
+ *
+ * With the default tag name and a `Jeongho Nam` comment, the printer emits:
+ *
+ * ```ts
+ * @author Jeongho Nam
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `author`.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocAuthorTag}.
+ */
+const createJSDocAuthorTag = (tagName, comment) => make("JSDocAuthorTag", {
+    tagName: tagName ?? createIdentifier("author"),
+    comment,
+});
+
+export { createJSDocAuthorTag };
+//# sourceMappingURL=createJSDocAuthorTag.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,37 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocCallbackTag}: a `@callback` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `callback` when omitted. The
+ * `typeExpression` is the {@link JSDocSignature} describing the callback,
+ * `fullName` is the callback's name, and `comment` is the trailing description.
+ * The printer prints the tag and name on the first line, then the signature's
+ * `@param` and `@returns` tags on their own lines.
+ *
+ * With the default tag name, a name of `MyCb`, and a signature taking `{number}
+ * x` and returning `{void}`, the printer emits:
+ *
+ * ```ts
+ * @callback MyCb
+ * @param {number} x
+ * @returns {void}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `callback`.
+ * @param typeExpression The callback signature.
+ * @param fullName The full callback name, if any.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocCallbackTag}.
+ */
+const createJSDocCallbackTag = (tagName, typeExpression, fullName, comment) => make("JSDocCallbackTag", {
+    tagName: tagName ?? createIdentifier("callback"),
+    typeExpression,
+    fullName,
+    comment,
+});
+
+export { createJSDocCallbackTag };
+//# sourceMappingURL=createJSDocCallbackTag.mjs.map

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDoc}: a `/** ... *\/` comment block.
+ *
+ * The `comment` is the leading summary text, and `tags` are the block tags that
+ * follow it. The printer wraps the whole thing in the `/**` and `*\/`
+ * delimiters and prefixes each interior line with `*`.
+ *
+ * With a `Just a summary.` comment and no tags, the printer emits:
+ *
+ * ```ts
+ * /**
+ *  * Just a summary.
+ *  *\/
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param comment The leading comment text, if any.
+ * @param tags The tags, if any.
+ * @returns The created {@link JSDoc}.
+ */
+const createJSDocComment = (comment, tags) => make("JSDoc", {
+    comment,
+    tags,
+});
+
+export { createJSDocComment };
+//# sourceMappingURL=createJSDocComment.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,27 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocDeprecatedTag}: a `@deprecated` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `deprecated` when omitted. The
+ * `comment` is the trailing text explaining the deprecation.
+ *
+ * With the default tag name and a `use foo` comment, the printer emits:
+ *
+ * ```ts
+ * @deprecated use foo
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `deprecated`.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocDeprecatedTag}.
+ */
+const createJSDocDeprecatedTag = (tagName, comment) => make("JSDocDeprecatedTag", {
+    tagName: tagName ?? createIdentifier("deprecated"),
+    comment,
+});
+
+export { createJSDocDeprecatedTag };
+//# sourceMappingURL=createJSDocDeprecatedTag.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,31 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocEnumTag}: an `@enum` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `enum` when omitted. The
+ * `typeExpression` supplies the brace-wrapped member type, and `comment` is the
+ * trailing description, if any.
+ *
+ * With the default tag name and a `{number}` type expression, the printer
+ * emits:
+ *
+ * ```ts
+ * @enum {number}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `enum`.
+ * @param typeExpression The type expression.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocEnumTag}.
+ */
+const createJSDocEnumTag = (tagName, typeExpression, comment) => make("JSDocEnumTag", {
+    tagName: tagName ?? createIdentifier("enum"),
+    typeExpression,
+    comment,
+});
+
+export { createJSDocEnumTag };
+//# sourceMappingURL=createJSDocEnumTag.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocFunctionType}: a JSDoc `function(...)` type.
+ *
+ * The `parameters` are the function parameters, printed inside the parentheses.
+ * The `type` is the return type, printed after a colon when present.
+ *
+ * With no parameters and a `number` return type, the printer emits:
+ *
+ * ```ts
+ * function(): number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param parameters The parameters.
+ * @param type The return type, if any.
+ * @returns The created {@link JSDocFunctionType}.
+ */
+const createJSDocFunctionType = (parameters, type) => make("JSDocFunctionType", {
+    parameters,
+    type,
+});
+
+export { createJSDocFunctionType };
+//# sourceMappingURL=createJSDocFunctionType.mjs.map

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,34 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocImportTag}: an `@import` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `import` when omitted. The
+ * `importClause` names the bindings to bring in, the `moduleSpecifier` is the
+ * source module, and `comment` is the trailing description. The printer mirrors
+ * an ordinary import statement after the tag name.
+ *
+ * With the default tag name, a named import clause for `Foo`, and a `"./mod"`
+ * module specifier, the printer emits:
+ *
+ * ```ts
+ * @import { Foo } from "./mod"
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `import`.
+ * @param importClause The import clause, if any.
+ * @param moduleSpecifier The module specifier.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocImportTag}.
+ */
+const createJSDocImportTag = (tagName, importClause, moduleSpecifier, comment) => make("JSDocImportTag", {
+    tagName: tagName ?? createIdentifier("import"),
+    importClause,
+    moduleSpecifier,
+    comment,
+});
+
+export { createJSDocImportTag };
+//# sourceMappingURL=createJSDocImportTag.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocLink}: an inline `{@link ...}` reference.
+ *
+ * The `name` is the linked target, if any, and `text` is the trailing label.
+ * The printer appends the text to the name verbatim, with no separator inserted
+ * between them, so any space you want before the label must be part of `text`.
+ * When `name` is omitted, only the text is printed.
+ *
+ * With a `Foo` name and a ` the foo` text (note the leading space), the printer
+ * emits:
+ *
+ * ```ts
+ * {@link Foo the foo}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The linked name, if any.
+ * @param text The trailing link text.
+ * @returns The created {@link JSDocLink}.
+ */
+const createJSDocLink = (name, text) => make("JSDocLink", {
+    name,
+    text,
+});
+
+export { createJSDocLink };
+//# sourceMappingURL=createJSDocLink.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocLinkCode}: an inline `{@linkcode ...}` reference.
+ *
+ * The `name` is the linked target, if any, and `text` is the trailing label,
+ * rendered as code by documentation tooling. The printer appends the text to
+ * the name verbatim, with no separator inserted between them, so any space you
+ * want before the label must be part of `text`.
+ *
+ * With a `Foo` name and a ` the foo` text (note the leading space), the printer
+ * emits:
+ *
+ * ```ts
+ * {@linkcode Foo the foo}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The linked name, if any.
+ * @param text The trailing link text.
+ * @returns The created {@link JSDocLinkCode}.
+ */
+const createJSDocLinkCode = (name, text) => make("JSDocLinkCode", {
+    name,
+    text,
+});
+
+export { createJSDocLinkCode };
+//# sourceMappingURL=createJSDocLinkCode.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,29 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocLinkPlain}: an inline `{@linkplain ...}` reference.
+ *
+ * The `name` is the linked target, if any, and `text` is the trailing label,
+ * rendered as plain text by documentation tooling. The printer appends the text
+ * to the name verbatim, with no separator inserted between them, so any space
+ * you want before the label must be part of `text`.
+ *
+ * With a `Foo` name and a ` the foo` text (note the leading space), the printer
+ * emits:
+ *
+ * ```ts
+ * {@linkplain Foo the foo}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The linked name, if any.
+ * @param text The trailing link text.
+ * @returns The created {@link JSDocLinkPlain}.
+ */
+const createJSDocLinkPlain = (name, text) => make("JSDocLinkPlain", {
+    name,
+    text,
+});
+
+export { createJSDocLinkPlain };
+//# sourceMappingURL=createJSDocLinkPlain.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocMemberName}: a JSDoc `#`-joined member reference.
+ *
+ * The `left` is the owning name and `right` is the member. The printer joins
+ * them with a `#`, the JSDoc separator for an instance member.
+ *
+ * With a left of `Foo` and a right of `bar`, the printer emits:
+ *
+ * ```ts
+ * Foo#bar
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param left The left-hand side.
+ * @param right The right-hand side.
+ * @returns The created {@link JSDocMemberName}.
+ */
+const createJSDocMemberName = (left, right) => make("JSDocMemberName", {
+    left,
+    right,
+});
+
+export { createJSDocMemberName };
+//# sourceMappingURL=createJSDocMemberName.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocNameReference}: a JSDoc reference to a declared name.
+ *
+ * The `name` is the referenced entity or member name. The printer emits that
+ * name directly, with no surrounding decoration. This node is what tags such as
+ * `@see` carry as their target.
+ *
+ * With a `Foo` name, the printer emits:
+ *
+ * ```ts
+ * Foo;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param name The referenced name.
+ * @returns The created {@link JSDocNameReference}.
+ */
+const createJSDocNameReference = (name) => make("JSDocNameReference", {
+    name,
+});
+
+export { createJSDocNameReference };
+//# sourceMappingURL=createJSDocNameReference.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,25 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocNamepathType}: a JSDoc namepath type.
+ *
+ * The `type` is the wrapped type. This node carries no marker of its own, so
+ * the printer emits the wrapped type alone with no surrounding prefix or
+ * suffix.
+ *
+ * With a `number` type, the printer emits:
+ *
+ * ```ts
+ * number;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The wrapped type.
+ * @returns The created {@link JSDocNamepathType}.
+ */
+const createJSDocNamepathType = (type) => make("JSDocNamepathType", {
+    type,
+});
+
+export { createJSDocNamepathType };
+//# sourceMappingURL=createJSDocNamepathType.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,33 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocNonNullableType}: a JSDoc `!`-marked non-nullable type.
+ *
+ * The `type` is the wrapped type. The `postfix` flag controls placement of the
+ * `!` marker: when `true` it prints after the type, when `false` it prints
+ * before.
+ *
+ * With a `number` type and `postfix` of `true`, the printer emits:
+ *
+ * ```ts
+ * number!;
+ * ```
+ *
+ * The same type with `postfix` of `false` instead emits:
+ *
+ * ```ts
+ * !number;
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The wrapped type.
+ * @param postfix Whether the `!` is written after the type.
+ * @returns The created {@link JSDocNonNullableType}.
+ */
+const createJSDocNonNullableType = (type, postfix = false) => make("JSDocNonNullableType", {
+    type,
+    postfix,
+});
+
+export { createJSDocNonNullableType };
+//# sourceMappingURL=createJSDocNonNullableType.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,33 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocNullableType}: a JSDoc `?`-marked nullable type.
+ *
+ * The `type` is the wrapped type. The `postfix` flag controls placement of the
+ * `?` marker: when `true` it prints after the type, when `false` it prints
+ * before.
+ *
+ * With a `number` type and `postfix` of `true`, the printer emits:
+ *
+ * ```ts
+ * number?
+ * ```
+ *
+ * The same type with `postfix` of `false` instead emits:
+ *
+ * ```ts
+ * ?number
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The wrapped type.
+ * @param postfix Whether the `?` is written after the type.
+ * @returns The created {@link JSDocNullableType}.
+ */
+const createJSDocNullableType = (type, postfix = false) => make("JSDocNullableType", {
+    type,
+    postfix,
+});
+
+export { createJSDocNullableType };
+//# sourceMappingURL=createJSDocNullableType.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,23 @@
+import { make } from '../internal/make.mjs';
+
+/**
+ * Create a {@link JSDocOptionalType}: a JSDoc `=`-marked optional type.
+ *
+ * The `type` is the wrapped type. The printer appends an `=` marker after it.
+ *
+ * With a `number` type, the printer emits:
+ *
+ * ```ts
+ * number=
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param type The wrapped type.
+ * @returns The created {@link JSDocOptionalType}.
+ */
+const createJSDocOptionalType = (type) => make("JSDocOptionalType", {
+    type,
+});
+
+export { createJSDocOptionalType };
+//# sourceMappingURL=createJSDocOptionalType.mjs.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,35 @@
+import { make } from '../internal/make.mjs';
+import { createIdentifier } from '../names/createIdentifier.mjs';
+
+/**
+ * Create a {@link JSDocOverloadTag}: an `@overload` JSDoc tag.
+ *
+ * The `tagName` defaults to an identifier named `overload` when omitted. The
+ * `typeExpression` is the {@link JSDocSignature} describing the overload, and
+ * `comment` is the trailing description. The printer prints the tag on the
+ * first line, then the signature's `@param` and `@returns` tags on their own
+ * lines.
+ *
+ * With the default tag name and a signature taking `{number} x` and returning
+ * `{void}`, the printer emits:
+ *
+ * ```ts
+ * @overload
+ * @param {number} x
+ * @returns {void}
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param tagName The tag name; defaults to `overload`.
+ * @param typeExpression The overload signature.
+ * @param comment The trailing comment, if any.
+ * @returns The created {@link JSDocOverloadTag}.
+ */
+const createJSDocOverloadTag = (tagName, typeExpression, comment) => make("JSDocOverloadTag", {
+    tagName: tagName ?? createIdentifier("overload"),
+    typeExpression,
+    comment,
+});
+
+export { createJSDocOverloadTag };
+//# sourceMappingURL=createJSDocOverloadTag.mjs.map

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

@@ -0,0 +1 @@
+{"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;;;;"}