@depup/nextra 4.6.1-depup.0

package/dist/server/tsdoc/base.js

@@ -0,0 +1,284 @@
+import path from "path";
+import slash from "slash";
+import { Project, SyntaxKind, ts } from "ts-morph";
+import { CWD } from "../constants.js";
+import { logger } from "../utils.js";
+const project = new Project({
+  tsConfigFilePath: "./tsconfig.json",
+  skipAddingFilesFromTsConfig: true,
+  compilerOptions: {
+    // Do not show `undefined` value in type for optional value
+    exactOptionalPropertyTypes: true,
+    // Show `null` value in type if exist
+    strictNullChecks: true
+  }
+});
+const DEFAULT_FILENAME = "$.ts";
+let compilerObject;
+function generateDefinition({
+  code,
+  exportName = "default",
+  flattened = false
+}) {
+  compilerObject ??= project.getTypeChecker().compilerObject;
+  const sourceFile = project.createSourceFile(DEFAULT_FILENAME, code, {
+    overwrite: true
+  });
+  const output = [];
+  for (const [key, declaration2] of sourceFile.getExportedDeclarations()) {
+    if (key === exportName) output.push(...declaration2);
+  }
+  const declaration = output[0];
+  if (!declaration) {
+    throw new Error(`Can't find "${exportName}" declaration`);
+  }
+  const declarationFilePath = declaration.getSourceFile().getFilePath();
+  const filePath = slash(path.relative(CWD, declarationFilePath));
+  const symbol = declaration.getSymbolOrThrow();
+  const { comment, tags } = getCommentAndTags(declaration);
+  const description = ts.displayPartsToString(comment);
+  tags.returns &&= replaceJsDocLinks(tags.returns);
+  const definition = {
+    // Skip adding `filePath` to snapshots on test env, since we have tests on Mac and on Windows, they fail
+    ...// process.env.NODE_ENV !== 'test' &&
+    filePath !== DEFAULT_FILENAME && { filePath },
+    name: symbol.getName(),
+    ...description && { description },
+    ...Object.keys(tags).length && { tags }
+  };
+  const declarationType = declaration.getType();
+  const callSignatures = declarationType.getCallSignatures();
+  const isFunction = callSignatures.length > 0;
+  if (!isFunction) {
+    const entries = declarationType.getProperties().flatMap(
+      (prop) => getDocEntry({
+        symbol: prop,
+        declaration,
+        flattened
+      })
+    ).filter((entry) => !entry.tags || !("internal" in entry.tags));
+    if (!entries.length) {
+      const typeName = declarationType.getText();
+      if (typeName === "any") {
+        throw new Error(
+          'Your type is resolved as "any", it seems like you have an issue in "generateDefinition.code" argument.'
+        );
+      }
+      throw new Error(
+        `No properties found, check if your type "${typeName}" exist.`
+      );
+    }
+    return {
+      ...definition,
+      entries
+    };
+  }
+  return {
+    ...definition,
+    signatures: callSignatures.map((signature) => {
+      const params = signature.getParameters();
+      const typeParams = params.flatMap(
+        (param) => getDocEntry({
+          symbol: param,
+          declaration,
+          flattened
+        })
+      );
+      const returnType = signature.getDeclaration().getSignature().getReturnType();
+      let flattenedReturnType = flattened && shouldFlattenType(returnType) ? returnType.getProperties().flatMap(
+        (childProp) => getDocEntry({
+          symbol: childProp,
+          declaration,
+          flattened
+        })
+      ) : [];
+      if (!flattenedReturnType.length) {
+        flattenedReturnType = {
+          type: getFormattedText(returnType)
+        };
+      }
+      return {
+        params: typeParams,
+        returns: flattenedReturnType
+      };
+    })
+  };
+}
+function getCommentAndTags(declaration) {
+  const symbol = declaration.getSymbolOrThrow();
+  const comment = symbol.compilerSymbol.getDocumentationComment(compilerObject);
+  if (!comment.length) {
+    const aliasSymbol = declaration.getType().getAliasSymbol();
+    if (aliasSymbol) {
+      return {
+        comment: aliasSymbol.compilerSymbol.getDocumentationComment(compilerObject),
+        tags: getTags(aliasSymbol)
+      };
+    }
+  }
+  return {
+    comment,
+    tags: getTags(symbol)
+  };
+}
+function getDocEntry({
+  symbol,
+  declaration,
+  flattened,
+  prefix = ""
+}) {
+  const originalSubType = project.getTypeChecker().getTypeOfSymbolAtLocation(symbol, declaration);
+  const valueDeclaration = symbol.getValueDeclaration();
+  const isFunctionParameter = valueDeclaration && valueDeclaration.getKind() === SyntaxKind.Parameter;
+  const subType = isFunctionParameter ? originalSubType.getNonNullableType() : originalSubType;
+  if (flattened && shouldFlattenType(subType)) {
+    return subType.getProperties().flatMap((childProp) => {
+      const childPrefix = isFunctionParameter ? symbol.getName().replace(/^_+/, "") : symbol.getName();
+      const newPrefix = typeof +childPrefix === "number" && !Number.isNaN(+childPrefix) ? `[${childPrefix}]` + (originalSubType.isNullable() ? "?" : "") : childPrefix;
+      return getDocEntry({
+        symbol: childProp,
+        declaration,
+        flattened,
+        prefix: prexify(prefix, newPrefix)
+      });
+    });
+  }
+  const tags = getTags(symbol);
+  const name = symbol.getName();
+  const typeDescription = replaceJsDocLinks(
+    ts.displayPartsToString(
+      symbol.compilerSymbol.getDocumentationComment(compilerObject)
+    )
+  ).replace(/^- /, "");
+  const isOptional = isFunctionParameter ? (
+    // @ts-expect-error -- fixme
+    valueDeclaration.isOptional()
+  ) : symbol.isOptional();
+  const typeName = getTypeName({
+    tags,
+    symbol,
+    subType,
+    valueDeclaration
+  });
+  return {
+    name: prexify(prefix, name),
+    type: typeName,
+    ...typeDescription && { description: typeDescription },
+    ...Object.keys(tags).length && { tags },
+    ...isOptional && { optional: isOptional }
+  };
+}
+function printType(paramType) {
+  const inlineParamAlias = paramType.getNonNullableType().getAliasSymbol();
+  const paramTags = inlineParamAlias && getTags(inlineParamAlias);
+  const hasLine = paramTags && "inline" in paramTags;
+  if (!hasLine) {
+    return getFormattedText(paramType);
+  }
+  const typeText = inlineParamAlias.getDeclaredType().getText(
+    void 0,
+    ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.InTypeAlias
+    // | ts.TypeFormatFlags.WriteArrayAsGenericType
+    // | ts.TypeFormatFlags.UseFullyQualifiedType
+  );
+  return typeText;
+}
+function getTypeName({
+  tags,
+  symbol,
+  subType,
+  valueDeclaration
+}) {
+  const aliasSymbol = subType.getAliasSymbol();
+  const subTypeTags = aliasSymbol ? getTags(aliasSymbol) : {};
+  const typeName = (tags.remarks || subTypeTags.remarks)?.match(
+    /^`(?<name>.+)`/
+  )?.groups.name;
+  if (typeName) {
+    return typeName;
+  }
+  const declarationNode = symbol.getDeclarations().find(
+    (d) => ts.isPropertySignature(d.compilerNode) || ts.isParameter(d.compilerNode)
+  );
+  const typeNode = declarationNode?.asKind(SyntaxKind.PropertySignature) ?? declarationNode?.asKind(SyntaxKind.Parameter);
+  const t = typeNode?.getTypeNode()?.getText();
+  const useTypeNode = t && (t.startsWith("Partial<") || ["React.ReactNode", "React.ReactElement"].includes(t));
+  if (useTypeNode) {
+    return t;
+  }
+  const isInline = "inline" in tags || "inline" in subTypeTags;
+  if (!isInline) {
+    const typeOf = valueDeclaration?.getType() ?? symbol.getDeclaredType();
+    return typeOf.isUnknown() ? "unknown" : getFormattedText(subType);
+  }
+  const [signature] = subType.getCallSignatures();
+  const isFunction = !!signature;
+  if (isFunction) {
+    const params = signature.getParameters().map((param) => {
+      const paramDecl = param.getDeclarations()[0];
+      const paramType = project.getTypeChecker().getTypeOfSymbolAtLocation(param, paramDecl);
+      const paramTypeStr = printType(paramType);
+      const optional = paramDecl.asKindOrThrow(SyntaxKind.Parameter).isOptional();
+      return `${param.getName()}${optional ? "?" : ""}: ${paramTypeStr}`;
+    });
+    return `(${params.join(", ")}) => ${getFormattedText(signature.getReturnType())}`;
+  }
+  const [aliasDecl] = aliasSymbol.getDeclarations();
+  if (!aliasDecl) {
+    throw new Error("Can't find alias declaration for type.");
+  }
+  const inlineNode = aliasDecl.asKindOrThrow(SyntaxKind.TypeAliasDeclaration).getTypeNodeOrThrow();
+  return inlineNode.getText();
+}
+function prexify(prefix, name) {
+  return prefix ? [prefix, name].join(".") : name;
+}
+function shouldFlattenType(t) {
+  if (!t.isObject() || t.isArray() || t.isTuple() || // Is not function
+  t.getCallSignatures().length > 0 || // Is not `unknown`
+  t.getText() === "{}" || // Is not an empty object
+  !t.getProperties().length) {
+    return false;
+  }
+  try {
+    const baseName = t.getSymbolOrThrow().getName();
+    if (IGNORED_TYPES.has(baseName)) return false;
+    return t.isInterface() || baseName === "__type" || baseName === "__object";
+  } catch {
+    logger.error(`Symbol "${t.getText()}" isn't found.`);
+    return false;
+  }
+}
+const IGNORED_TYPES = /* @__PURE__ */ new Set([
+  "Date",
+  "RegExp",
+  "ReactElement",
+  "Element",
+  "CSSProperties"
+]);
+function getTags(prop) {
+  const tags = /* @__PURE__ */ Object.create(null);
+  for (const tag of prop.getJsDocTags()) {
+    const tagName = tag.getName();
+    const tagValue = ts.displayPartsToString(tag.getText());
+    if (tagName in tags) {
+      tags[tagName] += `
+${tagValue}`;
+    } else {
+      tags[tagName] = tagValue;
+    }
+  }
+  return tags;
+}
+function getFormattedText(t) {
+  return t.getText(
+    void 0,
+    ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+  );
+}
+function replaceJsDocLinks(md) {
+  return md.replaceAll(/{@link (?<link>[^}]*)}/g, "$1");
+}
+export {
+  generateDefinition
+};

package/dist/server/tsdoc/index.d.ts

@@ -0,0 +1,6 @@
+export { TSDoc } from './tsdoc.js';
+export { generateDefinition } from './base.js';
+export { generateTsFromZod } from './zod-to-ts.js';
+export { BaseArgs, GeneratedDefinition, GeneratedFunction, GeneratedType, ReturnField, Tags, TypeField } from './types.js';
+import 'react';
+import 'zod';

package/dist/server/tsdoc/index.js

@@ -0,0 +1,10 @@
+import "server-only";
+import { TSDoc } from "./tsdoc.js";
+import { generateDefinition } from "./base.js";
+import { generateTsFromZod } from "./zod-to-ts.js";
+export * from "./types.js";
+export {
+  TSDoc,
+  generateDefinition,
+  generateTsFromZod
+};

package/dist/server/tsdoc/tsdoc.d.ts

@@ -0,0 +1,102 @@
+import { FC, ReactNode } from 'react';
+import { generateDefinition } from './base.js';
+import './types.js';
+
+type TSDocProps = {
+    /**
+     * Parsed `type`, `interface` or `function` definition from
+     * [`generateDefinition` function](https://nextra.site/api/generatedefinition).
+     */
+    definition: ReturnType<typeof generateDefinition>;
+    /**
+     * Override the function to render markdown into JSX nodes.
+     * @default
+     * async function renderMarkdownDefault(description?: string): Promise<ReactNode> {
+     *   if (!description) return
+     *   const rawJs = await compileMdx(description)
+     *   return <MDXRemote compiledSource={rawJs} />
+     * }
+     */
+    renderMarkdown?: typeof renderMarkdownDefault;
+    /**
+     * Type links map.
+     * @default {}
+     */
+    typeLinkMap?: Record<string, string>;
+    /**
+     * Custom content to display when a function has no parameters.
+     * @default <Callout type="info">This function does not accept any parameters.</Callout>
+     */
+    noParametersContent?: ReactNode;
+};
+declare function renderMarkdownDefault(description?: string): Promise<ReactNode>;
+/**
+ * A built-in component lets you generate documentation from `type`, `interface`, and `function`
+ * definitions  using [TSDoc](https://tsdoc.org) annotations.
+ *
+ * ## What it generates
+ *
+ * ### For `type` and `interface`
+ *
+ * Generates a **properties table** with:
+ *
+ * - Name
+ * - Type and description
+ * - Default Value
+ * - Permalink
+ *
+ * ### For `function`
+ *
+ * 1. **Parameters table**, including:
+ *
+ *    - Name
+ *    - Type and description
+ *    - Default value
+ *    - Permalink
+ *
+ * 2. **Return signature table**, including:
+ *    - Description
+ *    - Return values table
+ *
+ * > [!TIP]
+ * >
+ * > - Permalink is a `#` anchor link for easy reference to individual rows.
+ * > - Descriptions are parsed from inline TSDoc comments or the `@description`
+ * >   tag.
+ * > - Supports full Markdown/MDX syntax in descriptions.
+ * > - Default values are extracted from the `@default` or `@defaultValue` tags.
+ * > - Return descriptions come from the `@returns` tag.
+ *
+ * > [!WARNING]
+ * >
+ * > **Server Component Only** – TSDoc component cannot be used in a client
+ * > component.<br />
+ * > **Available from:** Nextra 4.3 (alpha).<br />
+ * > **Dependency:** Uses TypeScript Compiler API from
+ * > [`ts-morph`](https://github.com/dsherret/ts-morph).
+ *
+ * @example
+ * To generate the props table for the `TSDoc` component shown on this page:
+ *
+ * ```mdx
+ * import { generateDefinition, TSDoc } from 'nextra/tsdoc'
+ *
+ * <TSDoc
+ *   definition={generateDefinition({
+ *     code: `
+ * import type { TSDoc } from 'nextra/tsdoc'
+ * type MyProps = React.ComponentProps<typeof TSDoc>
+ * export default MyProps`
+ *   })}
+ * />
+ * ```
+ *
+ * ### Overriding a type
+ *
+ * You can override the inferred type using the `@remarks` tag using backticks (`).
+ *
+ * <ExampleTSDoc />
+ */
+declare const TSDoc: FC<TSDocProps>;
+
+export { TSDoc };

package/dist/server/tsdoc/tsdoc.js

@@ -0,0 +1,262 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import cn from "clsx";
+import Slugger from "github-slugger";
+import { Callout } from "../../client/components/callout.js";
+import { Tabs } from "../../client/components/tabs/index.js";
+import { Anchor } from "../../client/mdx-components/anchor.js";
+import { Code } from "../../client/mdx-components/code.js";
+import { MDXRemote } from "../../client/mdx-remote.js";
+import { compileMdx } from "../compile.js";
+const Link = ({ className, ...props }) => {
+  return /* @__PURE__ */ jsx(
+    Anchor,
+    {
+      className: cn(
+        "x:text-primary-600 x:underline x:hover:no-underline x:decoration-from-font x:[text-underline-position:from-font]",
+        className
+      ),
+      ...props
+    }
+  );
+};
+async function renderMarkdownDefault(description) {
+  if (!description) return;
+  const rawJs = await compileMdx(description);
+  return /* @__PURE__ */ jsx(MDXRemote, { compiledSource: rawJs });
+}
+const classes = {
+  card: cn(
+    "x:rounded-xl nextra-border x:hover:bg-primary-50 x:dark:hover:bg-primary-500/10"
+  ),
+  anchor: cn(
+    "x:absolute x:top-0 x:right-0 x:text-lg x:font-black",
+    'x:before:content-["#"] x:hover:text-black x:dark:hover:text-white',
+    "x:px-3 x:py-[min(1%,12px)]"
+    // Increase click box
+  )
+};
+const TSDoc = ({
+  definition,
+  renderMarkdown = renderMarkdownDefault,
+  typeLinkMap = {},
+  noParametersContent = /* @__PURE__ */ jsx(Callout, { type: "info", children: "This function does not accept any parameters." })
+}) => {
+  if ("entries" in definition) {
+    return /* @__PURE__ */ jsx(
+      FieldsTable,
+      {
+        fields: definition.entries,
+        typeLinkMap,
+        renderMarkdown
+      }
+    );
+  }
+  const { signatures, tags } = definition;
+  const withSignatures = signatures.length > 1;
+  if (!withSignatures) {
+    return /* @__PURE__ */ jsx(FunctionSignature, { signature: signatures[0] });
+  }
+  return /* @__PURE__ */ jsx(
+    Tabs,
+    {
+      items: signatures.map((_, index) => `Function Signature ${index + 1}`),
+      children: signatures.map((signature, index) => /* @__PURE__ */ jsx(Tabs.Tab, { children: /* @__PURE__ */ jsx(FunctionSignature, { signature, index: index + 1 }) }, index))
+    }
+  );
+  async function FunctionSignature({
+    signature,
+    index = ""
+  }) {
+    const slugger = new Slugger();
+    const description = await renderMarkdown(tags?.returns);
+    const unnamedReturnId = `returns${index}`;
+    return /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("b", { className: "x:mt-[1.25em] x:block", children: "Parameters:" }),
+      signature.params.length ? /* @__PURE__ */ jsx(
+        FieldsTable,
+        {
+          fields: signature.params,
+          typeLinkMap,
+          renderMarkdown
+        }
+      ) : noParametersContent,
+      /* @__PURE__ */ jsx("b", { className: "x:mt-[1.25em] x:block", children: "Returns:" }),
+      Array.isArray(signature.returns) ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        description,
+        /* @__PURE__ */ jsxs("table", { className: "x:my-6 x:w-full x:text-sm", children: [
+          /* @__PURE__ */ jsx("thead", { className: "nextra-border x:border-b x:text-left x:max-lg:hidden", children: /* @__PURE__ */ jsxs("tr", { children: [
+            /* @__PURE__ */ jsx("th", { className: "x:py-1.5", children: "Name" }),
+            /* @__PURE__ */ jsx("th", { className: "x:p-1.5 x:px-3", children: "Type" })
+          ] }) }),
+          /* @__PURE__ */ jsx("tbody", { children: signature.returns.map(async (prop) => {
+            const id = slugger.slug(prop.name);
+            const description2 = await renderMarkdown(
+              prop.description || prop.tags?.description
+            );
+            return /* @__PURE__ */ jsxs(Row, { id, children: [
+              /* @__PURE__ */ jsx(
+                NameCell,
+                {
+                  id,
+                  optional: prop.optional,
+                  name: prop.name
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                TypeAndDescriptionCell,
+                {
+                  type: prop.type,
+                  description: description2,
+                  typeLinkMap
+                }
+              )
+            ] }, id);
+          }) })
+        ] })
+      ] }) : /* @__PURE__ */ jsxs(
+        "div",
+        {
+          id: unnamedReturnId,
+          className: cn(
+            classes.card,
+            'x:text-sm x:relative x:p-3 x:border x:before:content-["Type:_"] x:mt-5'
+          ),
+          children: [
+            /* @__PURE__ */ jsx("a", { href: `#${unnamedReturnId}`, className: cn(classes.anchor) }),
+            /* @__PURE__ */ jsx(Code, { children: linkify(signature.returns.type, typeLinkMap) }),
+            description && /* @__PURE__ */ jsx("div", { className: "x:mt-2", children: description })
+          ]
+        }
+      )
+    ] });
+  }
+};
+const Row = ({ children, id }) => {
+  return /* @__PURE__ */ jsx(
+    "tr",
+    {
+      id,
+      className: cn(
+        classes.card,
+        "x:group x:mb-5 x:max-lg:block x:max-lg:border x:lg:border-b",
+        "x:lg:not-target:[&>td>a]:opacity-0"
+      ),
+      children
+    }
+  );
+};
+const NameCell = ({ name, id, optional }) => {
+  return /* @__PURE__ */ jsxs(
+    "td",
+    {
+      className: cn(
+        "x:relative x:max-lg:block",
+        name && "x:py-3 x:max-lg:px-3"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(
+          "a",
+          {
+            href: `#${id}`,
+            className: cn(
+              classes.anchor,
+              "x:group-hover:opacity-100! x:lg:top-1/2 x:lg:right-full x:lg:-translate-y-1/2"
+            )
+          }
+        ),
+        name && /* @__PURE__ */ jsx(
+          Code,
+          {
+            className: cn(
+              "x:max-md:break-all",
+              // add `?` via CSS `content` property so value will be not selectable
+              optional && 'x:after:content-["?"]'
+            ),
+            children: name
+          }
+        )
+      ]
+    }
+  );
+};
+const TypeAndDescriptionCell = ({ type, description, typeLinkMap }) => {
+  return /* @__PURE__ */ jsxs(
+    "td",
+    {
+      className: 'x:p-3 x:max-lg:block x:max-lg:before:content-["Type:_"]',
+      children: [
+        /* @__PURE__ */ jsx(Code, { children: linkify(type, typeLinkMap) }),
+        description && /* @__PURE__ */ jsx("div", { className: "x:mt-2", children: description })
+      ]
+    }
+  );
+};
+const FieldsTable = ({ fields, typeLinkMap, renderMarkdown }) => {
+  const slugger = new Slugger();
+  return /* @__PURE__ */ jsxs("table", { className: "x:my-8 x:w-full x:text-sm", children: [
+    /* @__PURE__ */ jsx("thead", { className: "nextra-border x:border-b x:text-left x:max-lg:hidden", children: /* @__PURE__ */ jsxs("tr", { children: [
+      /* @__PURE__ */ jsx("th", { className: "x:py-1.5", children: "Name" }),
+      /* @__PURE__ */ jsx("th", { className: "x:p-1.5 x:px-3", children: "Type" }),
+      /* @__PURE__ */ jsx("th", { className: "x:py-1.5", children: "Default" })
+    ] }) }),
+    /* @__PURE__ */ jsx("tbody", { children: fields.map(async (field) => {
+      const id = slugger.slug(field.name);
+      const tags = field.tags ?? {};
+      const defaultValue = tags.default || tags.defaultValue;
+      const description = await renderMarkdown(
+        [
+          field.description || tags.description,
+          tags.deprecated && `**Deprecated**: ${tags.deprecated}`
+        ].filter(Boolean).join("\n")
+      );
+      return /* @__PURE__ */ jsxs(Row, { id, children: [
+        /* @__PURE__ */ jsx(NameCell, { id, optional: field.optional, name: field.name }),
+        /* @__PURE__ */ jsx(
+          TypeAndDescriptionCell,
+          {
+            type: field.type,
+            description,
+            typeLinkMap
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "td",
+          {
+            className: cn(
+              "x:max-lg:block",
+              // For the mobile view, we want to hide the default column entirely if there is no
+              // content for it. We want this because otherwise, the default padding applied to
+              // table cells will add some extra blank space we don't want.
+              defaultValue ? (
+                // add `Default: ` via CSS `content` property so value will be not selectable
+                'x:py-3 x:max-lg:pt-0 x:max-lg:px-3 x:max-lg:before:content-["Default:_"]'
+              ) : 'x:lg:after:content-["\u2013"]'
+            ),
+            children: defaultValue && /* @__PURE__ */ jsx(Code, { className: "x:whitespace-pre-wrap x:inline-block", children: linkify(defaultValue, typeLinkMap) })
+          }
+        )
+      ] }, id);
+    }) })
+  ] });
+};
+function linkify(type, typeLinkMap = {}) {
+  const result = [];
+  for (const chunk of type.match(/(\w+|\W+)/g)) {
+    const href = typeLinkMap[chunk];
+    if (href) {
+      result.push(
+        /* @__PURE__ */ jsx(Link, { href, children: /* @__PURE__ */ jsx(Fragment, { children: chunk }) }, result.length)
+      );
+      continue;
+    }
+    if (typeof result.at(-1) === "string") {
+      result[result.length - 1] += chunk;
+      continue;
+    }
+    result.push(chunk);
+  }
+  return result;
+}
+export {
+  TSDoc
+};