init

node_modules/@microsoft/tsdoc/lib/__tests__/DocNodeTransforms.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DocNodeTransforms.test.d.ts.map

node_modules/@microsoft/tsdoc/lib/__tests__/DocNodeTransforms.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocNodeTransforms.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/DocNodeTransforms.test.ts"],"names":[],"mappings":""}

node_modules/@microsoft/tsdoc/lib/__tests__/DocNodeTransforms.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocNodeTransforms.test.js","sourceRoot":"","sources":["../../src/__tests__/DocNodeTransforms.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,WAAW,EAAE,MAAM,IAAI,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAyB,WAAW,EAAE,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AAEpE,IAAI,CAAC,iCAAiC,EAAE;IACtC,IAAM,MAAM,GAAW;QACrB,KAAK;QACL,IAAI;QACJ,yBAAyB;QACzB,+BAA+B;QAC/B,4BAA4B;QAC5B,eAAe;QACf,KAAK;KACN,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEb,IAAM,WAAW,GAAgB,IAAI,WAAW,EAAE,CAAC;IACnD,IAAM,aAAa,GAAkB,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IACrE,IAAM,SAAS,GAAY,aAAa,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC5E,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IACtD,IAAM,SAAS,GAAiB,SAAyB,CAAC;IAC1D,IAAM,oBAAoB,GAAiB,iBAAiB,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC9F,MAAM,CAAC,WAAW,CAAC,kBAAkB,CAAC,oBAAoB,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;AACjF,CAAC,CAAC,CAAC","sourcesContent":["import { ParserContext, TSDocParser } from '..';\r\nimport { TestHelpers } from '../parser/__tests__/TestHelpers';\r\nimport { DocParagraph, DocNode, DocNodeKind } from '../nodes';\r\nimport { DocNodeTransforms } from '../transforms/DocNodeTransforms';\r\n\r\ntest('01 trimSpacesInParagraphNodes()', () => {\r\n  const buffer: string = [\r\n    '/**',\r\n    ' *',\r\n    ' *    This \\t is    the',\r\n    ' * first   {@mylink}sentence.',\r\n    ' *         This is another',\r\n    ' *sentence.  ',\r\n    ' */'\r\n  ].join('\\n');\r\n\r\n  const tsdocParser: TSDocParser = new TSDocParser();\r\n  const parserContext: ParserContext = tsdocParser.parseString(buffer);\r\n  const firstNode: DocNode = parserContext.docComment.summarySection.nodes[0];\r\n  expect(firstNode.kind).toEqual(DocNodeKind.Paragraph);\r\n  const paragraph: DocParagraph = firstNode as DocParagraph;\r\n  const transformedParagraph: DocParagraph = DocNodeTransforms.trimSpacesInParagraph(paragraph);\r\n  expect(TestHelpers.getDocNodeSnapshot(transformedParagraph)).toMatchSnapshot();\r\n});\r\n"]}

node_modules/@microsoft/tsdoc/lib/__tests__/ParagraphSplitter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ParagraphSplitter.test.d.ts.map

node_modules/@microsoft/tsdoc/lib/__tests__/ParagraphSplitter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParagraphSplitter.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ParagraphSplitter.test.ts"],"names":[],"mappings":""}

node_modules/@microsoft/tsdoc/lib/__tests__/ParagraphSplitter.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParagraphSplitter.test.js","sourceRoot":"","sources":["../../src/__tests__/ParagraphSplitter.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC7F,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAEzE,IAAI,CAAC,8BAA8B,EAAE;IACnC,WAAW,CAAC,+BAA+B,CACzC;QACE,KAAK;QACL,QAAQ;QACR,gBAAgB;QAChB,qBAAqB;QACrB,YAAY;QACZ,MAAM;QACN,YAAY;QACZ,kCAAkC;QAClC,IAAI;QACJ,iCAAiC;QACjC,IAAI;QACJ,OAAO;QACP,KAAK;KACN,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,wCAAwC,EAAE;IAC7C,WAAW,CAAC,+BAA+B,CACzC,CAAC,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAClG,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,+BAA+B,EAAE;IACpC,WAAW,CAAC,+BAA+B,CACzC,CAAC,YAAY,EAAE,WAAW,EAAE,EAAE,EAAE,uBAAuB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACpE,CAAC;AACJ,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,0CAA0C,EAAE;IAC/C,IAAM,aAAa,GAAuB,IAAI,kBAAkB,EAAE,CAAC;IAEnE,IAAM,UAAU,GAAe,IAAI,UAAU,CAAC,EAAE,aAAa,eAAA,EAAE,EAAE;QAC/D,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,EAAE;YAClC,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;YACtD,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,CAAC;YACnC,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;YAChD,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,CAAC;YACnC,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YAClD,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;YAChD,IAAI,WAAW,CAAC,EAAE,aAAa,eAAA,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;YACtD,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;YACtD,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,CAAC;YACnC,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,CAAC;YACnC,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;SACxD,CAAC;QACF,+CAA+C;QAC/C,IAAI,YAAY,CAAC,EAAE,aAAa,eAAA,EAAE,CAAC;KACpC,CAAC,CAAC;IAEH,iBAAiB,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;IACxD,MAAM,CAAC,WAAW,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC,eAAe,EAAE,CAAC;AACvE,CAAC,CAAC,CAAC","sourcesContent":["import { TestHelpers } from '../parser/__tests__/TestHelpers';\r\nimport { ParagraphSplitter } from '../parser/ParagraphSplitter';\r\nimport { DocSection, DocPlainText, DocSoftBreak, DocParagraph, DocBlockTag } from '../index';\r\nimport { TSDocConfiguration } from '../configuration/TSDocConfiguration';\r\n\r\ntest('01 Basic paragraph splitting', () => {\r\n  TestHelpers.parseAndMatchDocCommentSnapshot(\r\n    [\r\n      '/**',\r\n      ' *    ',\r\n      ' * This is the',\r\n      ' * first paragraph.',\r\n      ' *   \\t   ',\r\n      ' *  ',\r\n      ' *   \\t   ',\r\n      ' * This is the second paragraph.',\r\n      ' *',\r\n      ' * This is the third paragraph.',\r\n      ' *',\r\n      ' *   ',\r\n      ' */'\r\n    ].join('\\n')\r\n  );\r\n});\r\n\r\ntest('02 Basic paragraph splitting in blocks', () => {\r\n  TestHelpers.parseAndMatchDocCommentSnapshot(\r\n    ['/**', ' * P1', ' * @remarks P2', ' *', ' * P3 @deprecated P4', ' *', ' * P5', ' */'].join('\\n')\r\n  );\r\n});\r\n\r\ntest('03 Degenerate comment framing', () => {\r\n  TestHelpers.parseAndMatchDocCommentSnapshot(\r\n    ['/** line 1', ' * line 2', '', ' *   @public line 3*/'].join('\\n')\r\n  );\r\n});\r\n\r\ntest('04 Degenerate manually constructed nodes', () => {\r\n  const configuration: TSDocConfiguration = new TSDocConfiguration();\r\n\r\n  const docSection: DocSection = new DocSection({ configuration }, [\r\n    new DocParagraph({ configuration }, [\r\n      new DocPlainText({ configuration, text: '  para 1 ' }),\r\n      new DocSoftBreak({ configuration }),\r\n      new DocPlainText({ configuration, text: '   ' }),\r\n      new DocSoftBreak({ configuration }),\r\n      new DocPlainText({ configuration, text: ' \\t  ' }),\r\n      new DocPlainText({ configuration, text: '   ' }),\r\n      new DocBlockTag({ configuration, tagName: '@public' }),\r\n      new DocPlainText({ configuration, text: '  para 2 ' }),\r\n      new DocSoftBreak({ configuration }),\r\n      new DocSoftBreak({ configuration }),\r\n      new DocPlainText({ configuration, text: '  para 3  ' })\r\n    ]),\r\n    // Currently we do not discard empty paragraphs\r\n    new DocParagraph({ configuration })\r\n  ]);\r\n\r\n  ParagraphSplitter.splitParagraphsForSection(docSection);\r\n  expect(TestHelpers.getDocNodeSnapshot(docSection)).toMatchSnapshot();\r\n});\r\n"]}

node_modules/@microsoft/tsdoc/lib/__tests__/ParsingBasics.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ParsingBasics.test.d.ts.map

node_modules/@microsoft/tsdoc/lib/__tests__/ParsingBasics.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParsingBasics.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ParsingBasics.test.ts"],"names":[],"mappings":""}

node_modules/@microsoft/tsdoc/lib/beta/DeclarationReference.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Represents a reference to a declaration.
+ * @beta
+ */
+export declare class DeclarationReference {
+    private _source;
+    private _navigation;
+    private _symbol;
+    constructor(source?: ModuleSource | GlobalSource, navigation?: Navigation.Locals | Navigation.Exports, symbol?: SymbolReference);
+    get source(): ModuleSource | GlobalSource | undefined;
+    get navigation(): Navigation.Locals | Navigation.Exports | undefined;
+    get symbol(): SymbolReference | undefined;
+    get isEmpty(): boolean;
+    static parse(text: string): DeclarationReference;
+    static parseComponent(text: string): Component;
+    /**
+     * Determines whether the provided string is a well-formed symbol navigation component string.
+     */
+    static isWellFormedComponentString(text: string): boolean;
+    /**
+     * Escapes a string for use as a symbol navigation component. If the string contains any of `!.#~:,"{}()@` or starts
+     * with `[`, it is enclosed in quotes.
+     */
+    static escapeComponentString(text: string): string;
+    /**
+     * Unescapes a string used as a symbol navigation component.
+     */
+    static unescapeComponentString(text: string): string;
+    /**
+     * Determines whether the provided string is a well-formed module source string. The string may not
+     * have a trailing `!` character.
+     */
+    static isWellFormedModuleSourceString(text: string): boolean;
+    /**
+     * Escapes a string for use as a module source. If the string contains any of `!"` it is enclosed in quotes.
+     */
+    static escapeModuleSourceString(text: string): string;
+    /**
+     * Unescapes a string used as a module source. The string may not have a trailing `!` character.
+     */
+    static unescapeModuleSourceString(text: string): string;
+    static empty(): DeclarationReference;
+    static package(packageName: string, importPath?: string): DeclarationReference;
+    static module(path: string, userEscaped?: boolean): DeclarationReference;
+    static global(): DeclarationReference;
+    static from(base: DeclarationReference | undefined): DeclarationReference;
+    withSource(source: ModuleSource | GlobalSource | undefined): DeclarationReference;
+    withNavigation(navigation: Navigation.Locals | Navigation.Exports | undefined): DeclarationReference;
+    withSymbol(symbol: SymbolReference | undefined): DeclarationReference;
+    withComponentPath(componentPath: ComponentPath): DeclarationReference;
+    withMeaning(meaning: Meaning | undefined): DeclarationReference;
+    withOverloadIndex(overloadIndex: number | undefined): DeclarationReference;
+    addNavigationStep(navigation: Navigation, component: ComponentLike): DeclarationReference;
+    toString(): string;
+}
+/**
+ * Indicates the symbol table from which to resolve the next symbol component.
+ * @beta
+ */
+export declare const enum Navigation {
+    Exports = ".",
+    Members = "#",
+    Locals = "~"
+}
+/**
+ * Represents a module.
+ * @beta
+ */
+export declare class ModuleSource {
+    readonly escapedPath: string;
+    private _path;
+    private _pathComponents;
+    constructor(path: string, userEscaped?: boolean);
+    get path(): string;
+    get packageName(): string;
+    get scopeName(): string;
+    get unscopedPackageName(): string;
+    get importPath(): string;
+    static fromScopedPackage(scopeName: string | undefined, unscopedPackageName: string, importPath?: string): ModuleSource;
+    static fromPackage(packageName: string, importPath?: string): ModuleSource;
+    private static _fromPackageName;
+    toString(): string;
+    private _getOrParsePathComponents;
+}
+/**
+ * Represents the global scope.
+ * @beta
+ */
+export declare class GlobalSource {
+    static readonly instance: GlobalSource;
+    private constructor();
+    toString(): string;
+}
+/**
+ * @beta
+ */
+export declare type Component = ComponentString | ComponentReference;
+/**
+ * @beta
+ */
+export declare namespace Component {
+    function from(value: ComponentLike): Component;
+}
+/**
+ * @beta
+ */
+export declare type ComponentLike = Component | DeclarationReference | string;
+/**
+ * @beta
+ */
+export declare class ComponentString {
+    readonly text: string;
+    constructor(text: string, userEscaped?: boolean);
+    toString(): string;
+}
+/**
+ * @beta
+ */
+export declare class ComponentReference {
+    readonly reference: DeclarationReference;
+    constructor(reference: DeclarationReference);
+    static parse(text: string): ComponentReference;
+    withReference(reference: DeclarationReference): ComponentReference;
+    toString(): string;
+}
+/**
+ * @beta
+ */
+export declare type ComponentPath = ComponentRoot | ComponentNavigation;
+/**
+ * @beta
+ */
+export declare abstract class ComponentPathBase {
+    readonly component: Component;
+    constructor(component: Component);
+    addNavigationStep(this: ComponentPath, navigation: Navigation, component: ComponentLike): ComponentPath;
+    abstract toString(): string;
+}
+/**
+ * @beta
+ */
+export declare class ComponentRoot extends ComponentPathBase {
+    withComponent(component: ComponentLike): ComponentRoot;
+    toString(): string;
+}
+/**
+ * @beta
+ */
+export declare class ComponentNavigation extends ComponentPathBase {
+    readonly parent: ComponentPath;
+    readonly navigation: Navigation;
+    constructor(parent: ComponentPath, navigation: Navigation, component: Component);
+    withParent(parent: ComponentPath): ComponentNavigation;
+    withNavigation(navigation: Navigation): ComponentNavigation;
+    withComponent(component: ComponentLike): ComponentNavigation;
+    toString(): string;
+}
+/**
+ * @beta
+ */
+export declare const enum Meaning {
+    Class = "class",
+    Interface = "interface",
+    TypeAlias = "type",
+    Enum = "enum",
+    Namespace = "namespace",
+    Function = "function",
+    Variable = "var",
+    Constructor = "constructor",
+    Member = "member",
+    Event = "event",
+    CallSignature = "call",
+    ConstructSignature = "new",
+    IndexSignature = "index",
+    ComplexType = "complex"
+}
+/**
+ * @beta
+ */
+export interface ISymbolReferenceOptions {
+    meaning?: Meaning;
+    overloadIndex?: number;
+}
+/**
+ * Represents a reference to a TypeScript symbol.
+ * @beta
+ */
+export declare class SymbolReference {
+    readonly componentPath: ComponentPath | undefined;
+    readonly meaning: Meaning | undefined;
+    readonly overloadIndex: number | undefined;
+    constructor(component: ComponentPath | undefined, { meaning, overloadIndex }?: ISymbolReferenceOptions);
+    static empty(): SymbolReference;
+    withComponentPath(componentPath: ComponentPath | undefined): SymbolReference;
+    withMeaning(meaning: Meaning | undefined): SymbolReference;
+    withOverloadIndex(overloadIndex: number | undefined): SymbolReference;
+    addNavigationStep(navigation: Navigation, component: ComponentLike): SymbolReference;
+    toString(): string;
+}
+//# sourceMappingURL=DeclarationReference.d.ts.map

node_modules/@microsoft/tsdoc/lib/beta/DeclarationReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeclarationReference.d.ts","sourceRoot":"","sources":["../../src/beta/DeclarationReference.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,WAAW,CAAqD;IACxE,OAAO,CAAC,OAAO,CAA8B;gBAG3C,MAAM,CAAC,EAAE,YAAY,GAAG,YAAY,EACpC,UAAU,CAAC,EAAE,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,EACnD,MAAM,CAAC,EAAE,eAAe;IAO1B,IAAW,MAAM,IAAI,YAAY,GAAG,YAAY,GAAG,SAAS,CAE3D;IAED,IAAW,UAAU,IAAI,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,GAAG,SAAS,CAW1E;IAED,IAAW,MAAM,IAAI,eAAe,GAAG,SAAS,CAE/C;IAED,IAAW,OAAO,IAAI,OAAO,CAE5B;WAEa,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB;WAYzC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS;IAQrD;;OAEG;WACW,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAShE;;;OAGG;WACW,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAWzD;;OAEG;WACW,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAc3D;;;OAGG;WACW,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUnE;;OAEG;WACW,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAW5D;;OAEG;WACW,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;WAchD,KAAK,IAAI,oBAAoB;WAI7B,OAAO,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,oBAAoB;WAIvE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,oBAAoB;WAIjE,MAAM,IAAI,oBAAoB;WAI9B,IAAI,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG,oBAAoB;IAIzE,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,oBAAoB;IAIjF,cAAc,CACnB,UAAU,EAAE,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO,GAAG,SAAS,GAC7D,oBAAoB;IAMhB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,GAAG,oBAAoB;IAIrE,iBAAiB,CAAC,aAAa,EAAE,aAAa,GAAG,oBAAoB;IAMrE,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,oBAAoB;IAU/D,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,oBAAoB;IAU1E,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,GAAG,oBAAoB;IAWzF,QAAQ,IAAI,MAAM;CAO1B;AAED;;;GAGG;AACH,0BAAkB,UAAU;IAC1B,OAAO,MAAM;IACb,OAAO,MAAM;IACb,MAAM,MAAM;CACb;AAED;;;GAGG;AACH,qBAAa,YAAY;IACvB,SAAgB,WAAW,EAAE,MAAM,CAAC;IACpC,OAAO,CAAC,KAAK,CAAqB;IAElC,OAAO,CAAC,eAAe,CAA6B;gBAEjC,IAAI,EAAE,MAAM,EAAE,WAAW,GAAE,OAAc;IAK5D,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,SAAS,IAAI,MAAM,CAG7B;IAED,IAAW,mBAAmB,IAAI,MAAM,CAEvC;IAED,IAAW,UAAU,IAAI,MAAM,CAE9B;WAEa,iBAAiB,CAC7B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,mBAAmB,EAAE,MAAM,EAC3B,UAAU,CAAC,EAAE,MAAM,GAClB,YAAY;WAaD,WAAW,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,YAAY;IAIjF,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA4BxB,QAAQ,IAAI,MAAM;IAIzB,OAAO,CAAC,yBAAyB;CAiBlC;AA2CD;;;GAGG;AACH,qBAAa,YAAY;IACvB,gBAAuB,QAAQ,EAAE,YAAY,CAAsB;IAEnE,OAAO;IAEA,QAAQ,IAAI,MAAM;CAG1B;AAED;;GAEG;AACH,oBAAY,SAAS,GAAG,eAAe,GAAG,kBAAkB,CAAC;AAE7D;;GAEG;AAEH,yBAAiB,SAAS,CAAC;IACzB,SAAgB,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,CAQpD;CACF;AAED;;GAEG;AACH,oBAAY,aAAa,GAAG,SAAS,GAAG,oBAAoB,GAAG,MAAM,CAAC;AAEtE;;GAEG;AACH,qBAAa,eAAe;IAC1B,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO;IAI/C,QAAQ,IAAI,MAAM;CAG1B;AAID;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,SAAgB,SAAS,EAAE,oBAAoB,CAAC;gBAE7B,SAAS,EAAE,oBAAoB;WAIpC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB;IAO9C,aAAa,CAAC,SAAS,EAAE,oBAAoB,GAAG,kBAAkB;IAIlE,QAAQ,IAAI,MAAM;CAG1B;AAED;;GAEG;AACH,oBAAY,aAAa,GAAG,aAAa,GAAG,mBAAmB,CAAC;AAEhE;;GAEG;AACH,8BAAsB,iBAAiB;IACrC,SAAgB,SAAS,EAAE,SAAS,CAAC;gBAElB,SAAS,EAAE,SAAS;IAIhC,iBAAiB,CACtB,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,aAAa,GACvB,aAAa;aAKA,QAAQ,IAAI,MAAM;CACnC;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,iBAAiB;IAC3C,aAAa,CAAC,SAAS,EAAE,aAAa,GAAG,aAAa;IAItD,QAAQ,IAAI,MAAM;CAG1B;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;IACxD,SAAgB,MAAM,EAAE,aAAa,CAAC;IACtC,SAAgB,UAAU,EAAE,UAAU,CAAC;gBAEpB,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS;IAM/E,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,mBAAmB;IAItD,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,mBAAmB;IAM3D,aAAa,CAAC,SAAS,EAAE,aAAa,GAAG,mBAAmB;IAM5D,QAAQ,IAAI,MAAM;CAG1B;AAED;;GAEG;AACH,0BAAkB,OAAO;IACvB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,SAAS,SAAS;IAClB,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,QAAQ,aAAa;IACrB,QAAQ,QAAQ;IAChB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,aAAa,SAAS;IACtB,kBAAkB,QAAQ;IAC1B,cAAc,UAAU;IACxB,WAAW,YAAY;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B,SAAgB,aAAa,EAAE,aAAa,GAAG,SAAS,CAAC;IACzD,SAAgB,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,SAAgB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;gBAGhD,SAAS,EAAE,aAAa,GAAG,SAAS,EACpC,EAAE,OAAO,EAAE,aAAa,EAAE,GAAE,uBAA4B;WAO5C,KAAK,IAAI,eAAe;IAI/B,iBAAiB,CAAC,aAAa,EAAE,aAAa,GAAG,SAAS,GAAG,eAAe;IAS5E,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,eAAe;IAS1D,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe;IASrE,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa,GAAG,eAAe;IAOpF,QAAQ,IAAI,MAAM;CAW1B"}

node_modules/@microsoft/tsdoc/lib/beta/__tests__/DeclarationReference.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DeclarationReference.test.d.ts.map

node_modules/@microsoft/tsdoc/lib/beta/__tests__/DeclarationReference.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeclarationReference.test.d.ts","sourceRoot":"","sources":["../../../src/beta/__tests__/DeclarationReference.test.ts"],"names":[],"mappings":""}

node_modules/@microsoft/tsdoc/lib/configuration/DocNodeManager.d.ts

@@ -0,0 +1,44 @@
+import { DocNode } from '../nodes/DocNode';
+export declare type DocNodeConstructor = new (...args: any[]) => DocNode;
+export interface IDocNodeDefinition {
+    docNodeKind: string;
+    constructor: DocNodeConstructor;
+}
+/**
+ * Part of the {@link TSDocConfiguration} object.
+ *
+ * @remarks
+ * If you define your own custom subclasses of `DocNode`, they must be registered with the `DocNodeManager`.
+ * Use {@link DocNodeManager.registerAllowableChildren} to specify which {@link DocNodeContainer} subclasses
+ * are allowed to contain your nodes.
+ */
+export declare class DocNodeManager {
+    private static readonly _nodeKindRegExp;
+    private readonly _docNodeDefinitionsByKind;
+    private readonly _docNodeDefinitionsByConstructor;
+    /**
+     * Registers a list of {@link IDocNodeDefinition} objects to be used with the associated
+     * {@link TSDocConfiguration} object.
+     */
+    registerDocNodes(packageName: string, definitions: ReadonlyArray<IDocNodeDefinition>): void;
+    /**
+     * Reports an error if the specified DocNode kind has not been registered.
+     */
+    throwIfNotRegisteredKind(docNodeKind: string): void;
+    /**
+     * For the given parent DocNode kind, registers the specified DocNode kinds as being allowable children of
+     * the parent.
+     *
+     * @remarks
+     * To prevent mistakes, `DocNodeContainer` will report an error if you try to add node that was not registered
+     * as an allowable child of the container.
+     */
+    registerAllowableChildren(parentKind: string, childKinds: ReadonlyArray<string>): void;
+    /**
+     * Returns true if the specified DocNode kind has been registered as an allowable child of the specified
+     * parent DocNode kind.
+     */
+    isAllowedChild(parentKind: string, childKind: string): boolean;
+    private _getDefinition;
+}
+//# sourceMappingURL=DocNodeManager.d.ts.map

node_modules/@microsoft/tsdoc/lib/configuration/DocNodeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocNodeManager.d.ts","sourceRoot":"","sources":["../../src/configuration/DocNodeManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAI3C,oBAAY,kBAAkB,GAAG,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,kBAAkB,CAAC;CACjC;AASD;;;;;;;GAOG;AACH,qBAAa,cAAc;IAIzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAiC;IAExE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAGtC;IACJ,OAAO,CAAC,QAAQ,CAAC,gCAAgC,CAGe;IAEhE;;;OAGG;IACI,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,aAAa,CAAC,kBAAkB,CAAC,GAAG,IAAI;IA6ClG;;OAEG;IACI,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAM1D;;;;;;;OAOG;IACI,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,IAAI;IAS7F;;;OAGG;IACI,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAKrE,OAAO,CAAC,cAAc;CASvB"}

node_modules/@microsoft/tsdoc/lib/configuration/DocNodeManager.js

@@ -0,0 +1,96 @@
+import { StringChecks } from '../parser/StringChecks';
+/**
+ * Part of the {@link TSDocConfiguration} object.
+ *
+ * @remarks
+ * If you define your own custom subclasses of `DocNode`, they must be registered with the `DocNodeManager`.
+ * Use {@link DocNodeManager.registerAllowableChildren} to specify which {@link DocNodeContainer} subclasses
+ * are allowed to contain your nodes.
+ */
+var DocNodeManager = /** @class */ (function () {
+    function DocNodeManager() {
+        this._docNodeDefinitionsByKind = new Map();
+        this._docNodeDefinitionsByConstructor = new Map();
+    }
+    /**
+     * Registers a list of {@link IDocNodeDefinition} objects to be used with the associated
+     * {@link TSDocConfiguration} object.
+     */
+    DocNodeManager.prototype.registerDocNodes = function (packageName, definitions) {
+        var packageNameError = StringChecks.explainIfInvalidPackageName(packageName);
+        if (packageNameError) {
+            throw new Error('Invalid NPM package name: ' + packageNameError);
+        }
+        for (var _i = 0, definitions_1 = definitions; _i < definitions_1.length; _i++) {
+            var definition = definitions_1[_i];
+            if (!DocNodeManager._nodeKindRegExp.test(definition.docNodeKind)) {
+                throw new Error("The DocNode kind " + JSON.stringify(definition.docNodeKind) + " is not a valid identifier." +
+                    " It must start with an underscore or letter, and be comprised of letters, numbers, and underscores");
+            }
+            var existingDefinition = this._docNodeDefinitionsByKind.get(definition.docNodeKind);
+            if (existingDefinition !== undefined) {
+                throw new Error("The DocNode kind \"" + definition.docNodeKind + "\" was already registered" +
+                    (" by " + existingDefinition.packageName));
+            }
+            existingDefinition = this._docNodeDefinitionsByConstructor.get(definition.constructor);
+            if (existingDefinition !== undefined) {
+                throw new Error("This DocNode constructor was already registered by " + existingDefinition.packageName +
+                    (" as " + existingDefinition.docNodeKind));
+            }
+            var newDefinition = {
+                docNodeKind: definition.docNodeKind,
+                constructor: definition.constructor,
+                packageName: packageName,
+                allowedChildKinds: new Set()
+            };
+            this._docNodeDefinitionsByKind.set(definition.docNodeKind, newDefinition);
+            this._docNodeDefinitionsByConstructor.set(definition.constructor, newDefinition);
+        }
+    };
+    /**
+     * Reports an error if the specified DocNode kind has not been registered.
+     */
+    DocNodeManager.prototype.throwIfNotRegisteredKind = function (docNodeKind) {
+        if (!this._docNodeDefinitionsByKind.has(docNodeKind)) {
+            throw new Error("The DocNode kind \"" + docNodeKind + "\" was not registered with this TSDocConfiguration");
+        }
+    };
+    /**
+     * For the given parent DocNode kind, registers the specified DocNode kinds as being allowable children of
+     * the parent.
+     *
+     * @remarks
+     * To prevent mistakes, `DocNodeContainer` will report an error if you try to add node that was not registered
+     * as an allowable child of the container.
+     */
+    DocNodeManager.prototype.registerAllowableChildren = function (parentKind, childKinds) {
+        var parentDefinition = this._getDefinition(parentKind);
+        for (var _i = 0, childKinds_1 = childKinds; _i < childKinds_1.length; _i++) {
+            var childKind = childKinds_1[_i];
+            this._getDefinition(childKind);
+            parentDefinition.allowedChildKinds.add(childKind);
+        }
+    };
+    /**
+     * Returns true if the specified DocNode kind has been registered as an allowable child of the specified
+     * parent DocNode kind.
+     */
+    DocNodeManager.prototype.isAllowedChild = function (parentKind, childKind) {
+        var parentDefinition = this._getDefinition(parentKind);
+        return parentDefinition.allowedChildKinds.has(childKind);
+    };
+    DocNodeManager.prototype._getDefinition = function (docNodeKind) {
+        var definition = this._docNodeDefinitionsByKind.get(docNodeKind);
+        if (definition === undefined) {
+            throw new Error("The DocNode kind \"" + docNodeKind + "\" was not registered with this TSDocConfiguration");
+        }
+        return definition;
+    };
+    // Matches an ASCII TypeScript-style identifier.
+    //
+    // Example: "_myIdentifier99"
+    DocNodeManager._nodeKindRegExp = /^[_a-z][_a-z0-9]*$/i;
+    return DocNodeManager;
+}());
+export { DocNodeManager };
+//# sourceMappingURL=DocNodeManager.js.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocConfiguration.d.ts

@@ -0,0 +1,133 @@
+import { TSDocTagDefinition } from './TSDocTagDefinition';
+import { TSDocValidationConfiguration } from './TSDocValidationConfiguration';
+import { DocNodeManager } from './DocNodeManager';
+import { TSDocMessageId } from '../parser/TSDocMessageId';
+/**
+ * Configuration for the TSDocParser.
+ */
+export declare class TSDocConfiguration {
+    private readonly _tagDefinitions;
+    private readonly _tagDefinitionsByName;
+    private readonly _supportedTagDefinitions;
+    private readonly _validation;
+    private readonly _docNodeManager;
+    private readonly _supportedHtmlElements;
+    constructor();
+    /**
+     * Resets the `TSDocConfiguration` object to its initial empty state.
+     * @param noStandardTags - The `TSDocConfiguration` constructor normally adds definitions for the
+     * standard TSDoc tags.  Set `noStandardTags` to true for a completely empty `tagDefinitions` collection.
+     */
+    clear(noStandardTags?: boolean): void;
+    /**
+     * The TSDoc tags that are defined in this configuration.
+     *
+     * @remarks
+     * The subset of "supported" tags is tracked by {@link TSDocConfiguration.supportedTagDefinitions}.
+     */
+    get tagDefinitions(): ReadonlyArray<TSDocTagDefinition>;
+    /**
+     * Returns the subset of {@link TSDocConfiguration.tagDefinitions}
+     * that are supported in this configuration.
+     *
+     * @remarks
+     * This property is only used when
+     * {@link TSDocValidationConfiguration.reportUnsupportedTags} is enabled.
+     */
+    get supportedTagDefinitions(): ReadonlyArray<TSDocTagDefinition>;
+    /**
+     * Enable/disable validation checks performed by the parser.
+     */
+    get validation(): TSDocValidationConfiguration;
+    /**
+     * The HTML element names that are supported in this configuration. Used in conjunction with the `reportUnsupportedHtmlElements` setting.
+     */
+    get supportedHtmlElements(): string[];
+    /**
+     * Register custom DocNode subclasses.
+     */
+    get docNodeManager(): DocNodeManager;
+    /**
+     * Return the tag that was defined with the specified name, or undefined
+     * if not found.
+     */
+    tryGetTagDefinition(tagName: string): TSDocTagDefinition | undefined;
+    /**
+     * Return the tag that was defined with the specified name, or undefined
+     * if not found.
+     */
+    tryGetTagDefinitionWithUpperCase(alreadyUpperCaseTagName: string): TSDocTagDefinition | undefined;
+    /**
+     * Define a new TSDoc tag to be recognized by the TSDocParser, and mark it as unsupported.
+     * Use {@link TSDocConfiguration.setSupportForTag} to mark it as supported.
+     *
+     * @remarks
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     */
+    addTagDefinition(tagDefinition: TSDocTagDefinition): void;
+    /**
+     * Calls {@link TSDocConfiguration.addTagDefinition} for a list of definitions,
+     * and optionally marks them as supported.
+     * @param tagDefinitions - the definitions to be added
+     * @param supported - if specified, calls the {@link TSDocConfiguration.setSupportForTag}
+     *    method to mark the definitions as supported or unsupported
+     */
+    addTagDefinitions(tagDefinitions: ReadonlyArray<TSDocTagDefinition>, supported?: boolean | undefined): void;
+    /**
+     * Returns true if the tag is supported in this configuration.
+     */
+    isTagSupported(tagDefinition: TSDocTagDefinition): boolean;
+    /**
+     * Specifies whether the tag definition is supported in this configuration.
+     * The parser may issue warnings for unsupported tags.
+     *
+     * @remarks
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     *
+     * This function automatically sets {@link TSDocValidationConfiguration.reportUnsupportedTags}
+     * to true.
+     */
+    setSupportForTag(tagDefinition: TSDocTagDefinition, supported: boolean): void;
+    /**
+     * Specifies whether the tag definition is supported in this configuration.
+     * This operation sets {@link TSDocValidationConfiguration.reportUnsupportedTags} to `true`.
+     *
+     * @remarks
+     * The parser may issue warnings for unsupported tags.
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     */
+    setSupportForTags(tagDefinitions: ReadonlyArray<TSDocTagDefinition>, supported: boolean): void;
+    /**
+     * Assigns the `supportedHtmlElements` property, replacing any previous elements.
+     * This operation sets {@link TSDocValidationConfiguration.reportUnsupportedHtmlElements} to `true`.
+     */
+    setSupportedHtmlElements(htmlTags: string[]): void;
+    /**
+     * Returns true if the html element is supported in this configuration.
+     */
+    isHtmlElementSupported(htmlTag: string): boolean;
+    /**
+     * Returns true if the specified {@link TSDocMessageId} string is implemented by this release of the TSDoc parser.
+     * This can be used to detect misspelled identifiers.
+     *
+     * @privateRemarks
+     *
+     * Why this API is associated with TSDocConfiguration:  In the future, if we enable support for custom extensions
+     * of the TSDoc parser, we may provide a way to register custom message identifiers.
+     */
+    isKnownMessageId(messageId: TSDocMessageId | string): boolean;
+    /**
+     * Returns the list of {@link TSDocMessageId} strings that are implemented by this release of the TSDoc parser.
+     *
+     * @privateRemarks
+     *
+     * Why this API is associated with TSDocConfiguration:  In the future, if we enable support for custom extensions
+     * of the TSDoc parser, we may provide a way to register custom message identifiers.
+     */
+    get allTsdocMessageIds(): ReadonlyArray<TSDocMessageId>;
+    private _requireTagToBeDefined;
+}
+//# sourceMappingURL=TSDocConfiguration.d.ts.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocConfiguration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocConfiguration.d.ts","sourceRoot":"","sources":["../../src/configuration/TSDocConfiguration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,cAAc,EAA6C,MAAM,0BAA0B,CAAC;AAErG;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAuB;IACvD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAkC;IACxE,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAA0B;IACnE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+B;IAC3D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAc;;IAgBrD;;;;OAIG;IACI,KAAK,CAAC,cAAc,GAAE,OAAe,GAAG,IAAI;IAenD;;;;;OAKG;IACH,IAAW,cAAc,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAE7D;IAED;;;;;;;OAOG;IACH,IAAW,uBAAuB,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAEtE;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,4BAA4B,CAEpD;IAED;;OAEG;IACH,IAAW,qBAAqB,IAAI,MAAM,EAAE,CAE3C;IAED;;OAEG;IACH,IAAW,cAAc,IAAI,cAAc,CAE1C;IAED;;;OAGG;IACI,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAI3E;;;OAGG;IACI,gCAAgC,CAAC,uBAAuB,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIxG;;;;;;;OAOG;IACI,gBAAgB,CAAC,aAAa,EAAE,kBAAkB,GAAG,IAAI;IAiBhE;;;;;;OAMG;IACI,iBAAiB,CACtB,cAAc,EAAE,aAAa,CAAC,kBAAkB,CAAC,EACjD,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,GAC9B,IAAI;IAUP;;OAEG;IACI,cAAc,CAAC,aAAa,EAAE,kBAAkB,GAAG,OAAO;IAKjE;;;;;;;;;;OAUG;IACI,gBAAgB,CAAC,aAAa,EAAE,kBAAkB,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAWpF;;;;;;;;OAQG;IACI,iBAAiB,CAAC,cAAc,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI;IAMrG;;;OAGG;IACI,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAQzD;;OAEG;IACI,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIvD;;;;;;;;OAQG;IACI,gBAAgB,CAAC,SAAS,EAAE,cAAc,GAAG,MAAM,GAAG,OAAO;IAIpE;;;;;;;OAOG;IACH,IAAW,kBAAkB,IAAI,aAAa,CAAC,cAAc,CAAC,CAE7D;IAED,OAAO,CAAC,sBAAsB;CAW/B"}

node_modules/@microsoft/tsdoc/lib/configuration/TSDocConfiguration.js

@@ -0,0 +1,248 @@
+import { StandardTags } from '../details/StandardTags';
+import { TSDocValidationConfiguration } from './TSDocValidationConfiguration';
+import { DocNodeManager } from './DocNodeManager';
+import { BuiltInDocNodes } from '../nodes/BuiltInDocNodes';
+import { allTsdocMessageIds, allTsdocMessageIdsSet } from '../parser/TSDocMessageId';
+/**
+ * Configuration for the TSDocParser.
+ */
+var TSDocConfiguration = /** @class */ (function () {
+    function TSDocConfiguration() {
+        this._tagDefinitions = [];
+        this._tagDefinitionsByName = new Map();
+        this._supportedTagDefinitions = new Set();
+        this._validation = new TSDocValidationConfiguration();
+        this._docNodeManager = new DocNodeManager();
+        this._supportedHtmlElements = new Set();
+        this.clear(false);
+        // Register the built-in node kinds
+        BuiltInDocNodes.register(this);
+    }
+    /**
+     * Resets the `TSDocConfiguration` object to its initial empty state.
+     * @param noStandardTags - The `TSDocConfiguration` constructor normally adds definitions for the
+     * standard TSDoc tags.  Set `noStandardTags` to true for a completely empty `tagDefinitions` collection.
+     */
+    TSDocConfiguration.prototype.clear = function (noStandardTags) {
+        if (noStandardTags === void 0) { noStandardTags = false; }
+        this._tagDefinitions.length = 0;
+        this._tagDefinitionsByName.clear();
+        this._supportedTagDefinitions.clear();
+        this._validation.ignoreUndefinedTags = false;
+        this._validation.reportUnsupportedTags = false;
+        this._validation.reportUnsupportedHtmlElements = false;
+        this._supportedHtmlElements.clear();
+        if (!noStandardTags) {
+            // Define all the standard tags
+            this.addTagDefinitions(StandardTags.allDefinitions);
+        }
+    };
+    Object.defineProperty(TSDocConfiguration.prototype, "tagDefinitions", {
+        /**
+         * The TSDoc tags that are defined in this configuration.
+         *
+         * @remarks
+         * The subset of "supported" tags is tracked by {@link TSDocConfiguration.supportedTagDefinitions}.
+         */
+        get: function () {
+            return this._tagDefinitions;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TSDocConfiguration.prototype, "supportedTagDefinitions", {
+        /**
+         * Returns the subset of {@link TSDocConfiguration.tagDefinitions}
+         * that are supported in this configuration.
+         *
+         * @remarks
+         * This property is only used when
+         * {@link TSDocValidationConfiguration.reportUnsupportedTags} is enabled.
+         */
+        get: function () {
+            var _this = this;
+            return this.tagDefinitions.filter(function (x) { return _this.isTagSupported(x); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TSDocConfiguration.prototype, "validation", {
+        /**
+         * Enable/disable validation checks performed by the parser.
+         */
+        get: function () {
+            return this._validation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TSDocConfiguration.prototype, "supportedHtmlElements", {
+        /**
+         * The HTML element names that are supported in this configuration. Used in conjunction with the `reportUnsupportedHtmlElements` setting.
+         */
+        get: function () {
+            return Array.from(this._supportedHtmlElements.values());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(TSDocConfiguration.prototype, "docNodeManager", {
+        /**
+         * Register custom DocNode subclasses.
+         */
+        get: function () {
+            return this._docNodeManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Return the tag that was defined with the specified name, or undefined
+     * if not found.
+     */
+    TSDocConfiguration.prototype.tryGetTagDefinition = function (tagName) {
+        return this._tagDefinitionsByName.get(tagName.toUpperCase());
+    };
+    /**
+     * Return the tag that was defined with the specified name, or undefined
+     * if not found.
+     */
+    TSDocConfiguration.prototype.tryGetTagDefinitionWithUpperCase = function (alreadyUpperCaseTagName) {
+        return this._tagDefinitionsByName.get(alreadyUpperCaseTagName);
+    };
+    /**
+     * Define a new TSDoc tag to be recognized by the TSDocParser, and mark it as unsupported.
+     * Use {@link TSDocConfiguration.setSupportForTag} to mark it as supported.
+     *
+     * @remarks
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     */
+    TSDocConfiguration.prototype.addTagDefinition = function (tagDefinition) {
+        var existingDefinition = this._tagDefinitionsByName.get(tagDefinition.tagNameWithUpperCase);
+        if (existingDefinition === tagDefinition) {
+            return;
+        }
+        if (existingDefinition) {
+            throw new Error("A tag is already defined using the name " + existingDefinition.tagName);
+        }
+        this._tagDefinitions.push(tagDefinition);
+        this._tagDefinitionsByName.set(tagDefinition.tagNameWithUpperCase, tagDefinition);
+    };
+    /**
+     * Calls {@link TSDocConfiguration.addTagDefinition} for a list of definitions,
+     * and optionally marks them as supported.
+     * @param tagDefinitions - the definitions to be added
+     * @param supported - if specified, calls the {@link TSDocConfiguration.setSupportForTag}
+     *    method to mark the definitions as supported or unsupported
+     */
+    TSDocConfiguration.prototype.addTagDefinitions = function (tagDefinitions, supported) {
+        for (var _i = 0, tagDefinitions_1 = tagDefinitions; _i < tagDefinitions_1.length; _i++) {
+            var tagDefinition = tagDefinitions_1[_i];
+            this.addTagDefinition(tagDefinition);
+            if (supported !== undefined) {
+                this.setSupportForTag(tagDefinition, supported);
+            }
+        }
+    };
+    /**
+     * Returns true if the tag is supported in this configuration.
+     */
+    TSDocConfiguration.prototype.isTagSupported = function (tagDefinition) {
+        this._requireTagToBeDefined(tagDefinition);
+        return this._supportedTagDefinitions.has(tagDefinition);
+    };
+    /**
+     * Specifies whether the tag definition is supported in this configuration.
+     * The parser may issue warnings for unsupported tags.
+     *
+     * @remarks
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     *
+     * This function automatically sets {@link TSDocValidationConfiguration.reportUnsupportedTags}
+     * to true.
+     */
+    TSDocConfiguration.prototype.setSupportForTag = function (tagDefinition, supported) {
+        this._requireTagToBeDefined(tagDefinition);
+        if (supported) {
+            this._supportedTagDefinitions.add(tagDefinition);
+        }
+        else {
+            this._supportedTagDefinitions.delete(tagDefinition);
+        }
+        this.validation.reportUnsupportedTags = true;
+    };
+    /**
+     * Specifies whether the tag definition is supported in this configuration.
+     * This operation sets {@link TSDocValidationConfiguration.reportUnsupportedTags} to `true`.
+     *
+     * @remarks
+     * The parser may issue warnings for unsupported tags.
+     * If a tag is "defined" this means that the parser recognizes it and understands its syntax.
+     * Whereas if a tag is "supported", this means it is defined AND the application implements the tag.
+     */
+    TSDocConfiguration.prototype.setSupportForTags = function (tagDefinitions, supported) {
+        for (var _i = 0, tagDefinitions_2 = tagDefinitions; _i < tagDefinitions_2.length; _i++) {
+            var tagDefinition = tagDefinitions_2[_i];
+            this.setSupportForTag(tagDefinition, supported);
+        }
+    };
+    /**
+     * Assigns the `supportedHtmlElements` property, replacing any previous elements.
+     * This operation sets {@link TSDocValidationConfiguration.reportUnsupportedHtmlElements} to `true`.
+     */
+    TSDocConfiguration.prototype.setSupportedHtmlElements = function (htmlTags) {
+        this._supportedHtmlElements.clear();
+        this._validation.reportUnsupportedHtmlElements = true;
+        for (var _i = 0, htmlTags_1 = htmlTags; _i < htmlTags_1.length; _i++) {
+            var htmlTag = htmlTags_1[_i];
+            this._supportedHtmlElements.add(htmlTag);
+        }
+    };
+    /**
+     * Returns true if the html element is supported in this configuration.
+     */
+    TSDocConfiguration.prototype.isHtmlElementSupported = function (htmlTag) {
+        return this._supportedHtmlElements.has(htmlTag);
+    };
+    /**
+     * Returns true if the specified {@link TSDocMessageId} string is implemented by this release of the TSDoc parser.
+     * This can be used to detect misspelled identifiers.
+     *
+     * @privateRemarks
+     *
+     * Why this API is associated with TSDocConfiguration:  In the future, if we enable support for custom extensions
+     * of the TSDoc parser, we may provide a way to register custom message identifiers.
+     */
+    TSDocConfiguration.prototype.isKnownMessageId = function (messageId) {
+        return allTsdocMessageIdsSet.has(messageId);
+    };
+    Object.defineProperty(TSDocConfiguration.prototype, "allTsdocMessageIds", {
+        /**
+         * Returns the list of {@link TSDocMessageId} strings that are implemented by this release of the TSDoc parser.
+         *
+         * @privateRemarks
+         *
+         * Why this API is associated with TSDocConfiguration:  In the future, if we enable support for custom extensions
+         * of the TSDoc parser, we may provide a way to register custom message identifiers.
+         */
+        get: function () {
+            return allTsdocMessageIds;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TSDocConfiguration.prototype._requireTagToBeDefined = function (tagDefinition) {
+        var matching = this._tagDefinitionsByName.get(tagDefinition.tagNameWithUpperCase);
+        if (matching) {
+            if (matching === tagDefinition) {
+                return;
+            }
+        }
+        throw new Error('The specified TSDocTagDefinition is not defined for this TSDocConfiguration');
+    };
+    return TSDocConfiguration;
+}());
+export { TSDocConfiguration };
+//# sourceMappingURL=TSDocConfiguration.js.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocTagDefinition.d.ts

@@ -0,0 +1,69 @@
+import { Standardization } from '../details/Standardization';
+/**
+ * Determines the type of syntax for a TSDocTagDefinition
+ */
+export declare enum TSDocTagSyntaxKind {
+    /**
+     * The tag is intended to be an inline tag.  For example: `{@link}`.
+     */
+    InlineTag = 0,
+    /**
+     * The tag is intended to be a block tag that starts a new documentation
+     * section.  For example: `@remarks`
+     */
+    BlockTag = 1,
+    /**
+     * The tag is intended to be a modifier tag whose presence indicates
+     * an aspect of the associated API item.  For example: `@internal`
+     */
+    ModifierTag = 2
+}
+/**
+ * Constructor parameters for {@link TSDocTagDefinition}
+ */
+export interface ITSDocTagDefinitionParameters {
+    tagName: string;
+    syntaxKind: TSDocTagSyntaxKind;
+    allowMultiple?: boolean;
+}
+/**
+ * @internal
+ */
+export interface ITSDocTagDefinitionInternalParameters extends ITSDocTagDefinitionParameters {
+    standardization: Standardization;
+}
+/**
+ * Defines a TSDoc tag that will be understood by the TSDocParser.
+ */
+export declare class TSDocTagDefinition {
+    /**
+     * The TSDoc tag name.  TSDoc tag names start with an at-sign (`@`) followed
+     * by ASCII letters using "camelCase" capitalization.
+     */
+    readonly tagName: string;
+    /**
+     * The TSDoc tag name in all capitals, which is used for performing
+     * case-insensitive comparisons or lookups.
+     */
+    readonly tagNameWithUpperCase: string;
+    /**
+     * Specifies the expected syntax for this tag.
+     */
+    readonly syntaxKind: TSDocTagSyntaxKind;
+    /**
+     * Indicates the level of support expected from documentation tools that implement
+     * the standard.
+     */
+    readonly standardization: Standardization;
+    /**
+     * If true, then this TSDoc tag may appear multiple times in a doc comment.
+     * By default, a tag may only appear once.
+     */
+    readonly allowMultiple: boolean;
+    constructor(parameters: ITSDocTagDefinitionParameters);
+    /**
+     * Throws an exception if `tagName` is not a valid TSDoc tag name.
+     */
+    static validateTSDocTagName(tagName: string): void;
+}
+//# sourceMappingURL=TSDocTagDefinition.d.ts.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocTagDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocTagDefinition.d.ts","sourceRoot":"","sources":["../../src/configuration/TSDocTagDefinition.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;GAEG;AACH,oBAAY,kBAAkB;IAC5B;;OAEG;IACH,SAAS,IAAA;IAET;;;OAGG;IACH,QAAQ,IAAA;IAER;;;OAGG;IACH,WAAW,IAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,kBAAkB,CAAC;IAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,qCAAsC,SAAQ,6BAA6B;IAC1F,eAAe,EAAE,eAAe,CAAC;CAClC;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B;;;OAGG;IACH,SAAgB,OAAO,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACH,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAE7C;;OAEG;IACH,SAAgB,UAAU,EAAE,kBAAkB,CAAC;IAE/C;;;OAGG;IACH,SAAgB,eAAe,EAAE,eAAe,CAAC;IAEjD;;;OAGG;IACH,SAAgB,aAAa,EAAE,OAAO,CAAC;gBAEpB,UAAU,EAAE,6BAA6B;IAU5D;;OAEG;WACW,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAG1D"}

node_modules/@microsoft/tsdoc/lib/configuration/TSDocTagDefinition.js

@@ -0,0 +1,45 @@
+import { StringChecks } from '../parser/StringChecks';
+import { Standardization } from '../details/Standardization';
+/**
+ * Determines the type of syntax for a TSDocTagDefinition
+ */
+export var TSDocTagSyntaxKind;
+(function (TSDocTagSyntaxKind) {
+    /**
+     * The tag is intended to be an inline tag.  For example: `{@link}`.
+     */
+    TSDocTagSyntaxKind[TSDocTagSyntaxKind["InlineTag"] = 0] = "InlineTag";
+    /**
+     * The tag is intended to be a block tag that starts a new documentation
+     * section.  For example: `@remarks`
+     */
+    TSDocTagSyntaxKind[TSDocTagSyntaxKind["BlockTag"] = 1] = "BlockTag";
+    /**
+     * The tag is intended to be a modifier tag whose presence indicates
+     * an aspect of the associated API item.  For example: `@internal`
+     */
+    TSDocTagSyntaxKind[TSDocTagSyntaxKind["ModifierTag"] = 2] = "ModifierTag";
+})(TSDocTagSyntaxKind || (TSDocTagSyntaxKind = {}));
+/**
+ * Defines a TSDoc tag that will be understood by the TSDocParser.
+ */
+var TSDocTagDefinition = /** @class */ (function () {
+    function TSDocTagDefinition(parameters) {
+        StringChecks.validateTSDocTagName(parameters.tagName);
+        this.tagName = parameters.tagName;
+        this.tagNameWithUpperCase = parameters.tagName.toUpperCase();
+        this.syntaxKind = parameters.syntaxKind;
+        this.standardization =
+            parameters.standardization || Standardization.None;
+        this.allowMultiple = !!parameters.allowMultiple;
+    }
+    /**
+     * Throws an exception if `tagName` is not a valid TSDoc tag name.
+     */
+    TSDocTagDefinition.validateTSDocTagName = function (tagName) {
+        StringChecks.validateTSDocTagName(tagName);
+    };
+    return TSDocTagDefinition;
+}());
+export { TSDocTagDefinition };
+//# sourceMappingURL=TSDocTagDefinition.js.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocTagDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocTagDefinition.js","sourceRoot":"","sources":["../../src/configuration/TSDocTagDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;GAEG;AACH,MAAM,CAAN,IAAY,kBAiBX;AAjBD,WAAY,kBAAkB;IAC5B;;OAEG;IACH,qEAAS,CAAA;IAET;;;OAGG;IACH,mEAAQ,CAAA;IAER;;;OAGG;IACH,yEAAW,CAAA;AACb,CAAC,EAjBW,kBAAkB,KAAlB,kBAAkB,QAiB7B;AAkBD;;GAEG;AACH;IA8BE,4BAAmB,UAAyC;QAC1D,YAAY,CAAC,oBAAoB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;QAClC,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QAC7D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,eAAe;YACjB,UAAoD,CAAC,eAAe,IAAI,eAAe,CAAC,IAAI,CAAC;QAChG,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,UAAU,CAAC,aAAa,CAAC;IAClD,CAAC;IAED;;OAEG;IACW,uCAAoB,GAAlC,UAAmC,OAAe;QAChD,YAAY,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;IACH,yBAAC;AAAD,CAAC,AA9CD,IA8CC","sourcesContent":["import { StringChecks } from '../parser/StringChecks';\r\nimport { Standardization } from '../details/Standardization';\r\n\r\n/**\r\n * Determines the type of syntax for a TSDocTagDefinition\r\n */\r\nexport enum TSDocTagSyntaxKind {\r\n  /**\r\n   * The tag is intended to be an inline tag.  For example: `{@link}`.\r\n   */\r\n  InlineTag,\r\n\r\n  /**\r\n   * The tag is intended to be a block tag that starts a new documentation\r\n   * section.  For example: `@remarks`\r\n   */\r\n  BlockTag,\r\n\r\n  /**\r\n   * The tag is intended to be a modifier tag whose presence indicates\r\n   * an aspect of the associated API item.  For example: `@internal`\r\n   */\r\n  ModifierTag\r\n}\r\n\r\n/**\r\n * Constructor parameters for {@link TSDocTagDefinition}\r\n */\r\nexport interface ITSDocTagDefinitionParameters {\r\n  tagName: string;\r\n  syntaxKind: TSDocTagSyntaxKind;\r\n  allowMultiple?: boolean;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface ITSDocTagDefinitionInternalParameters extends ITSDocTagDefinitionParameters {\r\n  standardization: Standardization;\r\n}\r\n\r\n/**\r\n * Defines a TSDoc tag that will be understood by the TSDocParser.\r\n */\r\nexport class TSDocTagDefinition {\r\n  /**\r\n   * The TSDoc tag name.  TSDoc tag names start with an at-sign (`@`) followed\r\n   * by ASCII letters using \"camelCase\" capitalization.\r\n   */\r\n  public readonly tagName: string;\r\n\r\n  /**\r\n   * The TSDoc tag name in all capitals, which is used for performing\r\n   * case-insensitive comparisons or lookups.\r\n   */\r\n  public readonly tagNameWithUpperCase: string;\r\n\r\n  /**\r\n   * Specifies the expected syntax for this tag.\r\n   */\r\n  public readonly syntaxKind: TSDocTagSyntaxKind;\r\n\r\n  /**\r\n   * Indicates the level of support expected from documentation tools that implement\r\n   * the standard.\r\n   */\r\n  public readonly standardization: Standardization;\r\n\r\n  /**\r\n   * If true, then this TSDoc tag may appear multiple times in a doc comment.\r\n   * By default, a tag may only appear once.\r\n   */\r\n  public readonly allowMultiple: boolean;\r\n\r\n  public constructor(parameters: ITSDocTagDefinitionParameters) {\r\n    StringChecks.validateTSDocTagName(parameters.tagName);\r\n    this.tagName = parameters.tagName;\r\n    this.tagNameWithUpperCase = parameters.tagName.toUpperCase();\r\n    this.syntaxKind = parameters.syntaxKind;\r\n    this.standardization =\r\n      (parameters as ITSDocTagDefinitionInternalParameters).standardization || Standardization.None;\r\n    this.allowMultiple = !!parameters.allowMultiple;\r\n  }\r\n\r\n  /**\r\n   * Throws an exception if `tagName` is not a valid TSDoc tag name.\r\n   */\r\n  public static validateTSDocTagName(tagName: string): void {\r\n    StringChecks.validateTSDocTagName(tagName);\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/configuration/TSDocValidationConfiguration.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Part of the {@link TSDocConfiguration} object.
+ */
+export declare class TSDocValidationConfiguration {
+    /**
+     * Set `ignoreUndefinedTags` to true to silently ignore unrecognized tags,
+     * instead of reporting a warning.
+     *
+     * @remarks
+     * Normally the parser will issue errors when it encounters tag names that do not
+     * have a corresponding definition in {@link TSDocConfiguration.tagDefinitions}.
+     * This helps to catch common mistakes such as a misspelled tag.
+     *
+     * @defaultValue `false`
+     */
+    ignoreUndefinedTags: boolean;
+    /**
+     * Set `reportUnsupportedTags` to true to issue a warning for tags that are not
+     * supported by your tool.
+     *
+     * @remarks
+     * The TSDoc standard defines may tags.  By default it assumes that if your tool does
+     * not implement one of these tags, then it will simply ignore it.  But sometimes this
+     * may be misleading for developers. (For example, they might write an `@example` block
+     * and then be surprised if it doesn't appear in the documentation output.).
+     *
+     * For a better experience, you can tell the parser which tags you support, and then it
+     * will issue warnings wherever unsupported tags are used.  This is done using
+     * {@link TSDocConfiguration.setSupportForTag}.  Note that calling that function
+     * automatically sets `reportUnsupportedTags` to true.
+     *
+     * @defaultValue `false`
+     */
+    reportUnsupportedTags: boolean;
+    /**
+     * Set `reportUnsupportedHtmlElements` to true to issue a warning for HTML elements which
+     * are not defined in your TSDoc configuration's `supportedHtmlElements` field.
+     *
+     * @defaultValue `false`
+     */
+    reportUnsupportedHtmlElements: boolean;
+}
+//# sourceMappingURL=TSDocValidationConfiguration.d.ts.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocValidationConfiguration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocValidationConfiguration.d.ts","sourceRoot":"","sources":["../../src/configuration/TSDocValidationConfiguration.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,4BAA4B;IACvC;;;;;;;;;;OAUG;IACI,mBAAmB,EAAE,OAAO,CAAS;IAE5C;;;;;;;;;;;;;;;;OAgBG;IACI,qBAAqB,EAAE,OAAO,CAAS;IAE9C;;;;;OAKG;IACI,6BAA6B,EAAE,OAAO,CAAS;CACvD"}

node_modules/@microsoft/tsdoc/lib/configuration/TSDocValidationConfiguration.js

@@ -0,0 +1,47 @@
+/**
+ * Part of the {@link TSDocConfiguration} object.
+ */
+var TSDocValidationConfiguration = /** @class */ (function () {
+    function TSDocValidationConfiguration() {
+        /**
+         * Set `ignoreUndefinedTags` to true to silently ignore unrecognized tags,
+         * instead of reporting a warning.
+         *
+         * @remarks
+         * Normally the parser will issue errors when it encounters tag names that do not
+         * have a corresponding definition in {@link TSDocConfiguration.tagDefinitions}.
+         * This helps to catch common mistakes such as a misspelled tag.
+         *
+         * @defaultValue `false`
+         */
+        this.ignoreUndefinedTags = false;
+        /**
+         * Set `reportUnsupportedTags` to true to issue a warning for tags that are not
+         * supported by your tool.
+         *
+         * @remarks
+         * The TSDoc standard defines may tags.  By default it assumes that if your tool does
+         * not implement one of these tags, then it will simply ignore it.  But sometimes this
+         * may be misleading for developers. (For example, they might write an `@example` block
+         * and then be surprised if it doesn't appear in the documentation output.).
+         *
+         * For a better experience, you can tell the parser which tags you support, and then it
+         * will issue warnings wherever unsupported tags are used.  This is done using
+         * {@link TSDocConfiguration.setSupportForTag}.  Note that calling that function
+         * automatically sets `reportUnsupportedTags` to true.
+         *
+         * @defaultValue `false`
+         */
+        this.reportUnsupportedTags = false;
+        /**
+         * Set `reportUnsupportedHtmlElements` to true to issue a warning for HTML elements which
+         * are not defined in your TSDoc configuration's `supportedHtmlElements` field.
+         *
+         * @defaultValue `false`
+         */
+        this.reportUnsupportedHtmlElements = false;
+    }
+    return TSDocValidationConfiguration;
+}());
+export { TSDocValidationConfiguration };
+//# sourceMappingURL=TSDocValidationConfiguration.js.map

node_modules/@microsoft/tsdoc/lib/configuration/TSDocValidationConfiguration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocValidationConfiguration.js","sourceRoot":"","sources":["../../src/configuration/TSDocValidationConfiguration.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAAA;QACE;;;;;;;;;;WAUG;QACI,wBAAmB,GAAY,KAAK,CAAC;QAE5C;;;;;;;;;;;;;;;;WAgBG;QACI,0BAAqB,GAAY,KAAK,CAAC;QAE9C;;;;;WAKG;QACI,kCAA6B,GAAY,KAAK,CAAC;IACxD,CAAC;IAAD,mCAAC;AAAD,CAAC,AAxCD,IAwCC","sourcesContent":["/**\r\n * Part of the {@link TSDocConfiguration} object.\r\n */\r\nexport class TSDocValidationConfiguration {\r\n  /**\r\n   * Set `ignoreUndefinedTags` to true to silently ignore unrecognized tags,\r\n   * instead of reporting a warning.\r\n   *\r\n   * @remarks\r\n   * Normally the parser will issue errors when it encounters tag names that do not\r\n   * have a corresponding definition in {@link TSDocConfiguration.tagDefinitions}.\r\n   * This helps to catch common mistakes such as a misspelled tag.\r\n   *\r\n   * @defaultValue `false`\r\n   */\r\n  public ignoreUndefinedTags: boolean = false;\r\n\r\n  /**\r\n   * Set `reportUnsupportedTags` to true to issue a warning for tags that are not\r\n   * supported by your tool.\r\n   *\r\n   * @remarks\r\n   * The TSDoc standard defines may tags.  By default it assumes that if your tool does\r\n   * not implement one of these tags, then it will simply ignore it.  But sometimes this\r\n   * may be misleading for developers. (For example, they might write an `@example` block\r\n   * and then be surprised if it doesn't appear in the documentation output.).\r\n   *\r\n   * For a better experience, you can tell the parser which tags you support, and then it\r\n   * will issue warnings wherever unsupported tags are used.  This is done using\r\n   * {@link TSDocConfiguration.setSupportForTag}.  Note that calling that function\r\n   * automatically sets `reportUnsupportedTags` to true.\r\n   *\r\n   * @defaultValue `false`\r\n   */\r\n  public reportUnsupportedTags: boolean = false;\r\n\r\n  /**\r\n   * Set `reportUnsupportedHtmlElements` to true to issue a warning for HTML elements which\r\n   * are not defined in your TSDoc configuration's `supportedHtmlElements` field.\r\n   *\r\n   * @defaultValue `false`\r\n   */\r\n  public reportUnsupportedHtmlElements: boolean = false;\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/details/ModifierTagSet.d.ts

@@ -0,0 +1,44 @@
+import { DocBlockTag } from '../nodes/DocBlockTag';
+import { TSDocTagDefinition } from '../configuration/TSDocTagDefinition';
+/**
+ * Represents a set of modifier tags that were extracted from a doc comment.
+ *
+ * @remarks
+ * TSDoc modifier tags are block tags that do not have any associated rich text content.
+ * Instead, their presence or absence acts as an on/off switch, indicating some aspect
+ * of the underlying API item.  For example, the `@internal` modifier indicates that a
+ * signature is internal (i.e. not part of the public API contract).
+ */
+export declare class ModifierTagSet {
+    private readonly _nodes;
+    private readonly _nodesByName;
+    /**
+     * The original block tag nodes that defined the modifiers in this set, excluding duplicates.
+     */
+    get nodes(): ReadonlyArray<DocBlockTag>;
+    /**
+     * Returns true if the set contains a DocBlockTag with the specified tag name.
+     * Note that synonyms are not considered.  The comparison is case-insensitive.
+     * @param modifierTagName - The name of the tag, including the `@` prefix  For example, `@internal`
+     */
+    hasTagName(modifierTagName: string): boolean;
+    /**
+     * Returns true if the set contains a DocBlockTag matching the specified tag definition.
+     * Note that synonyms are not considered.  The comparison is case-insensitive.
+     * The TSDocTagDefinition must be a modifier tag.
+     * @param tagName - The name of the tag, including the `@` prefix  For example, `@internal`
+     */
+    hasTag(modifierTagDefinition: TSDocTagDefinition): boolean;
+    /**
+     * Returns a DocBlockTag matching the specified tag definition, or undefined if no such
+     * tag was added to the set.  If there were multiple instances, returned object will be
+     * the first one to be added.
+     */
+    tryGetTag(modifierTagDefinition: TSDocTagDefinition): DocBlockTag | undefined;
+    /**
+     * Adds a new modifier tag to the set.  If a tag already exists with the same name,
+     * then no change is made, and the return value is false.
+     */
+    addTag(blockTag: DocBlockTag): boolean;
+}
+//# sourceMappingURL=ModifierTagSet.d.ts.map

node_modules/@microsoft/tsdoc/lib/details/ModifierTagSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModifierTagSet.d.ts","sourceRoot":"","sources":["../../src/details/ModifierTagSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAsB,MAAM,qCAAqC,CAAC;AAE7F;;;;;;;;GAQG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAK5C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4D;IAEzF;;OAEG;IACH,IAAW,KAAK,IAAI,aAAa,CAAC,WAAW,CAAC,CAE7C;IAED;;;;OAIG;IACI,UAAU,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO;IAInD;;;;;OAKG;IACI,MAAM,CAAC,qBAAqB,EAAE,kBAAkB,GAAG,OAAO;IAIjE;;;;OAIG;IACI,SAAS,CAAC,qBAAqB,EAAE,kBAAkB,GAAG,WAAW,GAAG,SAAS;IAOpF;;;OAGG;IACI,MAAM,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO;CAU9C"}

node_modules/@microsoft/tsdoc/lib/details/ModifierTagSet.js

@@ -0,0 +1,72 @@
+import { TSDocTagSyntaxKind } from '../configuration/TSDocTagDefinition';
+/**
+ * Represents a set of modifier tags that were extracted from a doc comment.
+ *
+ * @remarks
+ * TSDoc modifier tags are block tags that do not have any associated rich text content.
+ * Instead, their presence or absence acts as an on/off switch, indicating some aspect
+ * of the underlying API item.  For example, the `@internal` modifier indicates that a
+ * signature is internal (i.e. not part of the public API contract).
+ */
+var ModifierTagSet = /** @class */ (function () {
+    function ModifierTagSet() {
+        this._nodes = [];
+        // NOTE: To implement case insensitivity, the keys in this set are always upper-case.
+        // This convention makes the normalization more obvious (and as a general practice handles
+        // the Turkish "i" character correctly).
+        this._nodesByName = new Map();
+    }
+    Object.defineProperty(ModifierTagSet.prototype, "nodes", {
+        /**
+         * The original block tag nodes that defined the modifiers in this set, excluding duplicates.
+         */
+        get: function () {
+            return this._nodes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Returns true if the set contains a DocBlockTag with the specified tag name.
+     * Note that synonyms are not considered.  The comparison is case-insensitive.
+     * @param modifierTagName - The name of the tag, including the `@` prefix  For example, `@internal`
+     */
+    ModifierTagSet.prototype.hasTagName = function (modifierTagName) {
+        return this._nodesByName.has(modifierTagName.toUpperCase());
+    };
+    /**
+     * Returns true if the set contains a DocBlockTag matching the specified tag definition.
+     * Note that synonyms are not considered.  The comparison is case-insensitive.
+     * The TSDocTagDefinition must be a modifier tag.
+     * @param tagName - The name of the tag, including the `@` prefix  For example, `@internal`
+     */
+    ModifierTagSet.prototype.hasTag = function (modifierTagDefinition) {
+        return !!this.tryGetTag(modifierTagDefinition);
+    };
+    /**
+     * Returns a DocBlockTag matching the specified tag definition, or undefined if no such
+     * tag was added to the set.  If there were multiple instances, returned object will be
+     * the first one to be added.
+     */
+    ModifierTagSet.prototype.tryGetTag = function (modifierTagDefinition) {
+        if (modifierTagDefinition.syntaxKind !== TSDocTagSyntaxKind.ModifierTag) {
+            throw new Error('The tag definition is not a modifier tag');
+        }
+        return this._nodesByName.get(modifierTagDefinition.tagNameWithUpperCase);
+    };
+    /**
+     * Adds a new modifier tag to the set.  If a tag already exists with the same name,
+     * then no change is made, and the return value is false.
+     */
+    ModifierTagSet.prototype.addTag = function (blockTag) {
+        if (this._nodesByName.has(blockTag.tagNameWithUpperCase)) {
+            return false;
+        }
+        this._nodesByName.set(blockTag.tagNameWithUpperCase, blockTag);
+        this._nodes.push(blockTag);
+        return true;
+    };
+    return ModifierTagSet;
+}());
+export { ModifierTagSet };
+//# sourceMappingURL=ModifierTagSet.js.map

node_modules/@microsoft/tsdoc/lib/details/ModifierTagSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModifierTagSet.js","sourceRoot":"","sources":["../../src/details/ModifierTagSet.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAE7F;;;;;;;;GAQG;AACH;IAAA;QACmB,WAAM,GAAkB,EAAE,CAAC;QAE5C,qFAAqF;QACrF,0FAA0F;QAC1F,wCAAwC;QACvB,iBAAY,GAA6B,IAAI,GAAG,EAAuB,CAAC;IAsD3F,CAAC;IAjDC,sBAAW,iCAAK;QAHhB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;;;OAAA;IAED;;;;OAIG;IACI,mCAAU,GAAjB,UAAkB,eAAuB;QACvC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,CAAC,WAAW,EAAE,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;OAKG;IACI,+BAAM,GAAb,UAAc,qBAAyC;QACrD,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACI,kCAAS,GAAhB,UAAiB,qBAAyC;QACxD,IAAI,qBAAqB,CAAC,UAAU,KAAK,kBAAkB,CAAC,WAAW,EAAE;YACvE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;SAC7D;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,qBAAqB,CAAC,oBAAoB,CAAC,CAAC;IAC3E,CAAC;IAED;;;OAGG;IACI,+BAAM,GAAb,UAAc,QAAqB;QACjC,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,EAAE;YACxD,OAAO,KAAK,CAAC;SACd;QAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;QAC/D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE3B,OAAO,IAAI,CAAC;IACd,CAAC;IACH,qBAAC;AAAD,CAAC,AA5DD,IA4DC","sourcesContent":["import { DocBlockTag } from '../nodes/DocBlockTag';\r\nimport { TSDocTagDefinition, TSDocTagSyntaxKind } from '../configuration/TSDocTagDefinition';\r\n\r\n/**\r\n * Represents a set of modifier tags that were extracted from a doc comment.\r\n *\r\n * @remarks\r\n * TSDoc modifier tags are block tags that do not have any associated rich text content.\r\n * Instead, their presence or absence acts as an on/off switch, indicating some aspect\r\n * of the underlying API item.  For example, the `@internal` modifier indicates that a\r\n * signature is internal (i.e. not part of the public API contract).\r\n */\r\nexport class ModifierTagSet {\r\n  private readonly _nodes: DocBlockTag[] = [];\r\n\r\n  // NOTE: To implement case insensitivity, the keys in this set are always upper-case.\r\n  // This convention makes the normalization more obvious (and as a general practice handles\r\n  // the Turkish \"i\" character correctly).\r\n  private readonly _nodesByName: Map<string, DocBlockTag> = new Map<string, DocBlockTag>();\r\n\r\n  /**\r\n   * The original block tag nodes that defined the modifiers in this set, excluding duplicates.\r\n   */\r\n  public get nodes(): ReadonlyArray<DocBlockTag> {\r\n    return this._nodes;\r\n  }\r\n\r\n  /**\r\n   * Returns true if the set contains a DocBlockTag with the specified tag name.\r\n   * Note that synonyms are not considered.  The comparison is case-insensitive.\r\n   * @param modifierTagName - The name of the tag, including the `@` prefix  For example, `@internal`\r\n   */\r\n  public hasTagName(modifierTagName: string): boolean {\r\n    return this._nodesByName.has(modifierTagName.toUpperCase());\r\n  }\r\n\r\n  /**\r\n   * Returns true if the set contains a DocBlockTag matching the specified tag definition.\r\n   * Note that synonyms are not considered.  The comparison is case-insensitive.\r\n   * The TSDocTagDefinition must be a modifier tag.\r\n   * @param tagName - The name of the tag, including the `@` prefix  For example, `@internal`\r\n   */\r\n  public hasTag(modifierTagDefinition: TSDocTagDefinition): boolean {\r\n    return !!this.tryGetTag(modifierTagDefinition);\r\n  }\r\n\r\n  /**\r\n   * Returns a DocBlockTag matching the specified tag definition, or undefined if no such\r\n   * tag was added to the set.  If there were multiple instances, returned object will be\r\n   * the first one to be added.\r\n   */\r\n  public tryGetTag(modifierTagDefinition: TSDocTagDefinition): DocBlockTag | undefined {\r\n    if (modifierTagDefinition.syntaxKind !== TSDocTagSyntaxKind.ModifierTag) {\r\n      throw new Error('The tag definition is not a modifier tag');\r\n    }\r\n    return this._nodesByName.get(modifierTagDefinition.tagNameWithUpperCase);\r\n  }\r\n\r\n  /**\r\n   * Adds a new modifier tag to the set.  If a tag already exists with the same name,\r\n   * then no change is made, and the return value is false.\r\n   */\r\n  public addTag(blockTag: DocBlockTag): boolean {\r\n    if (this._nodesByName.has(blockTag.tagNameWithUpperCase)) {\r\n      return false;\r\n    }\r\n\r\n    this._nodesByName.set(blockTag.tagNameWithUpperCase, blockTag);\r\n    this._nodes.push(blockTag);\r\n\r\n    return true;\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/details/StandardModifierTagSet.d.ts

@@ -0,0 +1,52 @@
+import { ModifierTagSet } from './ModifierTagSet';
+/**
+ * Extends the ModifierTagSet base class with getters for modifiers that
+ * are part of the standardized core tags for TSDoc.
+ */
+export declare class StandardModifierTagSet extends ModifierTagSet {
+    /**
+     * Returns true if the `@alpha` modifier tag was specified.
+     */
+    isAlpha(): boolean;
+    /**
+     * Returns true if the `@beta` modifier tag was specified.
+     */
+    isBeta(): boolean;
+    /**
+     * Returns true if the `@eventProperty` modifier tag was specified.
+     */
+    isEventProperty(): boolean;
+    /**
+     * Returns true if the `@experimental` modifier tag was specified.
+     */
+    isExperimental(): boolean;
+    /**
+     * Returns true if the `@internal` modifier tag was specified.
+     */
+    isInternal(): boolean;
+    /**
+     * Returns true if the `@override` modifier tag was specified.
+     */
+    isOverride(): boolean;
+    /**
+     * Returns true if the `@packageDocumentation` modifier tag was specified.
+     */
+    isPackageDocumentation(): boolean;
+    /**
+     * Returns true if the `@public` modifier tag was specified.
+     */
+    isPublic(): boolean;
+    /**
+     * Returns true if the `@readonly` modifier tag was specified.
+     */
+    isReadonly(): boolean;
+    /**
+     * Returns true if the `@sealed` modifier tag was specified.
+     */
+    isSealed(): boolean;
+    /**
+     * Returns true if the `@virtual` modifier tag was specified.
+     */
+    isVirtual(): boolean;
+}
+//# sourceMappingURL=StandardModifierTagSet.d.ts.map

node_modules/@microsoft/tsdoc/lib/details/StandardModifierTagSet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardModifierTagSet.d.ts","sourceRoot":"","sources":["../../src/details/StandardModifierTagSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,cAAc;IACxD;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACI,MAAM,IAAI,OAAO;IAIxB;;OAEG;IACI,eAAe,IAAI,OAAO;IAIjC;;OAEG;IACI,cAAc,IAAI,OAAO;IAIhC;;OAEG;IACI,UAAU,IAAI,OAAO;IAI5B;;OAEG;IACI,UAAU,IAAI,OAAO;IAI5B;;OAEG;IACI,sBAAsB,IAAI,OAAO;IAIxC;;OAEG;IACI,QAAQ,IAAI,OAAO;IAI1B;;OAEG;IACI,UAAU,IAAI,OAAO;IAI5B;;OAEG;IACI,QAAQ,IAAI,OAAO;IAI1B;;OAEG;IACI,SAAS,IAAI,OAAO;CAG5B"}

node_modules/@microsoft/tsdoc/lib/details/StandardModifierTagSet.js

@@ -0,0 +1,94 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { ModifierTagSet } from './ModifierTagSet';
+import { StandardTags } from './StandardTags';
+/**
+ * Extends the ModifierTagSet base class with getters for modifiers that
+ * are part of the standardized core tags for TSDoc.
+ */
+var StandardModifierTagSet = /** @class */ (function (_super) {
+    __extends(StandardModifierTagSet, _super);
+    function StandardModifierTagSet() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Returns true if the `@alpha` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isAlpha = function () {
+        return this.hasTag(StandardTags.alpha);
+    };
+    /**
+     * Returns true if the `@beta` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isBeta = function () {
+        return this.hasTag(StandardTags.beta);
+    };
+    /**
+     * Returns true if the `@eventProperty` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isEventProperty = function () {
+        return this.hasTag(StandardTags.eventProperty);
+    };
+    /**
+     * Returns true if the `@experimental` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isExperimental = function () {
+        return this.hasTag(StandardTags.experimental);
+    };
+    /**
+     * Returns true if the `@internal` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isInternal = function () {
+        return this.hasTag(StandardTags.internal);
+    };
+    /**
+     * Returns true if the `@override` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isOverride = function () {
+        return this.hasTag(StandardTags.override);
+    };
+    /**
+     * Returns true if the `@packageDocumentation` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isPackageDocumentation = function () {
+        return this.hasTag(StandardTags.packageDocumentation);
+    };
+    /**
+     * Returns true if the `@public` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isPublic = function () {
+        return this.hasTag(StandardTags.public);
+    };
+    /**
+     * Returns true if the `@readonly` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isReadonly = function () {
+        return this.hasTag(StandardTags.readonly);
+    };
+    /**
+     * Returns true if the `@sealed` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isSealed = function () {
+        return this.hasTag(StandardTags.sealed);
+    };
+    /**
+     * Returns true if the `@virtual` modifier tag was specified.
+     */
+    StandardModifierTagSet.prototype.isVirtual = function () {
+        return this.hasTag(StandardTags.virtual);
+    };
+    return StandardModifierTagSet;
+}(ModifierTagSet));
+export { StandardModifierTagSet };
+//# sourceMappingURL=StandardModifierTagSet.js.map

node_modules/@microsoft/tsdoc/lib/details/StandardModifierTagSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardModifierTagSet.js","sourceRoot":"","sources":["../../src/details/StandardModifierTagSet.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;GAGG;AACH;IAA4C,0CAAc;IAA1D;;IA6EA,CAAC;IA5EC;;OAEG;IACI,wCAAO,GAAd;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,uCAAM,GAAb;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,gDAAe,GAAtB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACI,+CAAc,GAArB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,2CAAU,GAAjB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,2CAAU,GAAjB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,uDAAsB,GAA7B;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACI,yCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACI,2CAAU,GAAjB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACI,yCAAQ,GAAf;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACI,0CAAS,GAAhB;QACE,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IACH,6BAAC;AAAD,CAAC,AA7ED,CAA4C,cAAc,GA6EzD","sourcesContent":["import { ModifierTagSet } from './ModifierTagSet';\r\nimport { StandardTags } from './StandardTags';\r\n\r\n/**\r\n * Extends the ModifierTagSet base class with getters for modifiers that\r\n * are part of the standardized core tags for TSDoc.\r\n */\r\nexport class StandardModifierTagSet extends ModifierTagSet {\r\n  /**\r\n   * Returns true if the `@alpha` modifier tag was specified.\r\n   */\r\n  public isAlpha(): boolean {\r\n    return this.hasTag(StandardTags.alpha);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@beta` modifier tag was specified.\r\n   */\r\n  public isBeta(): boolean {\r\n    return this.hasTag(StandardTags.beta);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@eventProperty` modifier tag was specified.\r\n   */\r\n  public isEventProperty(): boolean {\r\n    return this.hasTag(StandardTags.eventProperty);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@experimental` modifier tag was specified.\r\n   */\r\n  public isExperimental(): boolean {\r\n    return this.hasTag(StandardTags.experimental);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@internal` modifier tag was specified.\r\n   */\r\n  public isInternal(): boolean {\r\n    return this.hasTag(StandardTags.internal);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@override` modifier tag was specified.\r\n   */\r\n  public isOverride(): boolean {\r\n    return this.hasTag(StandardTags.override);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@packageDocumentation` modifier tag was specified.\r\n   */\r\n  public isPackageDocumentation(): boolean {\r\n    return this.hasTag(StandardTags.packageDocumentation);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@public` modifier tag was specified.\r\n   */\r\n  public isPublic(): boolean {\r\n    return this.hasTag(StandardTags.public);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@readonly` modifier tag was specified.\r\n   */\r\n  public isReadonly(): boolean {\r\n    return this.hasTag(StandardTags.readonly);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@sealed` modifier tag was specified.\r\n   */\r\n  public isSealed(): boolean {\r\n    return this.hasTag(StandardTags.sealed);\r\n  }\r\n\r\n  /**\r\n   * Returns true if the `@virtual` modifier tag was specified.\r\n   */\r\n  public isVirtual(): boolean {\r\n    return this.hasTag(StandardTags.virtual);\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/details/StandardTags.d.ts

@@ -0,0 +1,356 @@
+import { TSDocTagDefinition } from '../configuration/TSDocTagDefinition';
+/**
+ * Tags whose meaning is defined by the TSDoc standard.
+ */
+export declare class StandardTags {
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "alpha".
+     * It is intended to be used by third-party developers eventually, but has not
+     * yet been released.  The tooling may trim the declaration from a public release.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    static readonly alpha: TSDocTagDefinition;
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "beta".
+     * It has been released to third-party developers experimentally for the purpose of
+     * collecting feedback.  The API should not be used in production, because its contract may
+     * change without notice.  The tooling may trim the declaration from a public release,
+     * but may include it in a developer preview release.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     *
+     * Synonyms: `@experimental`
+     */
+    static readonly beta: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * ECMAScript decorators are sometimes an important part of an API contract.
+     * However, today the TypeScript compiler does not represent decorators in the
+     * .d.ts output files used by API consumers.  The `@decorator` tag provides a workaround,
+     * enabling a decorator expressions to be quoted in a doc comment.
+     *
+     * @example
+     * ```ts
+     * class Book {
+     *   /**
+     *    * The title of the book.
+     *    * @decorator `@jsonSerialized`
+     *    * @decorator `@jsonFormat(JsonFormats.Url)`
+     *    *
+     *+/
+     *   @jsonSerialized
+     *   @jsonFormat(JsonFormats.Url)
+     *   public website: string;
+     * }
+     * ```
+     */
+    static readonly decorator: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This block tag is used to document the default value for a field or property,
+     * if a value is not assigned explicitly.
+     *
+     * @remarks
+     * This tag should only be used with fields or properties that are members of a class or interface.
+     */
+    static readonly defaultValue: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * This block tag communicates that an API item is no longer supported and may be removed
+     * in a future release.  The `@deprecated` tag is followed by a sentence describing
+     * the recommended alternative.  It recursively applies to members of the container.
+     * For example, if a class is deprecated, then so are all of its members.
+     */
+    static readonly deprecated: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * When applied to a class or interface property, this indicates that the property
+     * returns an event object that event handlers can be attached to.  The event-handling
+     * API is implementation-defined, but typically the property return type would be a class
+     * with members such as `addHandler()` and `removeHandler()`.  A documentation tool can
+     * display such properties under an "Events" heading instead of the usual "Properties" heading.
+     */
+    static readonly eventProperty: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * Indicates a documentation section that should be presented as an example
+     * illustrating how to use the API.  It may include a code sample.
+     */
+    static readonly example: TSDocTagDefinition;
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning:  Same semantics as `@beta`, but used by tools that don't support
+     * an `@alpha` release stage.
+     *
+     * @remarks
+     * Example implementations: Angular API documenter
+     *
+     * Synonyms: `@beta`
+     */
+    static readonly experimental: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This inline tag is used to automatically generate an API item's documentation by
+     * copying it from another API item.  The inline tag parameter contains a reference
+     * to the other item, which may be an unrelated class, or even an import from a
+     * separate NPM package.
+     *
+     * @remarks
+     * What gets copied
+     *
+     * The `@inheritDoc` tag does not copy the entire comment body. Only the following
+     * components are copied:
+     * - summary section
+     * - `@remarks` block
+     * - `@params` blocks
+     * - `@typeParam` blocks
+     * - `@returns` block
+     * Other tags such as `@defaultValue` or `@example` are not copied, and need to be
+     * explicitly included after the `@inheritDoc` tag.
+     *
+     * TODO: The notation for API item references is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    static readonly inheritDoc: TSDocTagDefinition;
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning:  Designates that an API item is not planned to be used by
+     * third-party developers.  The tooling may trim the declaration from a public release.
+     * In some implementations, certain designated packages may be allowed to consume
+     * internal API items, e.g. because the packages are components of the same product.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    static readonly internal: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * The `{@label}` inline tag is used to label a declaration, so that it can be referenced
+     * using a selector in the TSDoc declaration reference notation.
+     *
+     * @remarks
+     * TODO: The `{@label}` notation is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    static readonly label: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * The `{@link}` inline tag is used to create hyperlinks to other pages in a
+     * documentation system or general internet URLs.  In particular, it supports
+     * expressions for referencing API items.
+     *
+     * @remarks
+     * TODO: The `{@link}` notation is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    static readonly link: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `override` keyword in C# or Java.
+     * For a member function or property, explicitly indicates that this definition
+     * is overriding (i.e. redefining) the definition inherited from the base class.
+     * The base class definition would normally be marked as `virtual`.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    static readonly override: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * Used to indicate a doc comment that describes an entire NPM package (as opposed
+     * to an individual API item belonging to that package).  The `@packageDocumentation` comment
+     * is found in the *.d.ts file that acts as the entry point for the package, and it
+     * should be the first `/**` comment encountered in that file.  A comment containing a
+     * `@packageDocumentation` tag should never be used to describe an individual API item.
+     */
+    static readonly packageDocumentation: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * Used to document a function parameter.  The `@param` tag is followed by a parameter
+     * name, followed by a hyphen, followed by a description.  The TSDoc parser recognizes
+     * this syntax and will extract it into a DocParamBlock node.
+     */
+    static readonly param: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * Starts a section of additional documentation content that is not intended for a
+     * public audience.  A tool must omit this entire section from the API reference web site,
+     * generated *.d.ts file, and any other outputs incorporating the content.
+     */
+    static readonly privateRemarks: TSDocTagDefinition;
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "public".
+     * It has been officially released to third-party developers, and its signature is
+     * guaranteed to be stable (e.g. following Semantic Versioning rules).
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    static readonly public: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This modifier tag indicates that an API item should be documented as being read-only,
+     * even if the TypeScript type system may indicate otherwise.  For example, suppose a
+     * class property has a setter function that always throws an exception explaining that
+     * the property cannot be assigned; in this situation, the `@readonly` modifier can be
+     * added so that the property is shown as read-only in the documentation.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    static readonly readonly: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * The main documentation for an API item is separated into a brief "summary" section,
+     * optionally followed by a more detailed "remarks" section.  On a documentation web site,
+     * index pages (e.g. showing members of a class) will show only the brief summaries,
+     * whereas a detail pages (e.g. describing a single member) will show the summary followed
+     * by the remarks.  The `@remarks` block tag ends the summary section, and begins the
+     * remarks section for a doc comment.
+     */
+    static readonly remarks: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * Used to document the return value for a function.
+     */
+    static readonly returns: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `sealed` keyword in C# or Java.
+     * For a class, indicates that subclasses must not inherit from the class.
+     * For a member function or property, indicates that subclasses must not override
+     * (i.e. redefine) the member.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    static readonly sealed: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * Used to build a list of references to an API item or other resource that may be related to the
+     * current item.
+     *
+     * @remarks
+     *
+     * For example:
+     *
+     * ```ts
+     * /**
+     *  * Parses a string containing a Uniform Resource Locator (URL).
+     *  * @see {@link ParsedUrl} for the returned data structure
+     *  * @see {@link https://tools.ietf.org/html/rfc1738|RFC 1738}
+     *  * for syntax
+     *  * @see your developer SDK for code samples
+     *  * @param url - the string to be parsed
+     *  * @returns the parsed result
+     *  */
+     * function parseURL(url: string): ParsedUrl;
+     * ```
+     *
+     * `@see` is a block tag.  Each block becomes an item in the list of references.  For example, a documentation
+     * system might render the above blocks as follows:
+     *
+     * ```markdown
+     * `function parseURL(url: string): ParsedUrl;`
+     *
+     * Parses a string containing a Uniform Resource Locator (URL).
+     *
+     * ## See Also
+     * - ParsedUrl for the returned data structure
+     * - RFC 1738 for syntax
+     * - your developer SDK for code samples
+     * ```
+     *
+     * NOTE: JSDoc attempts to automatically hyperlink the text immediately after `@see`.  Because this is ambiguous
+     * with plain text, TSDoc instead requires an explicit `{@link}` tag to make hyperlinks.
+     */
+    static readonly see: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * Used to document an exception type that may be thrown by a function or property.
+     *
+     * @remarks
+     *
+     * A separate `@throws` block should be used to document each exception type.  This tag is for informational
+     * purposes only, and does not restrict other types from being thrown.  It is suggested, but not required,
+     * for the `@throws` block to start with a line containing only the name of the exception.
+     *
+     * For example:
+     *
+     * ```ts
+     * /**
+     *  * Retrieves metadata about a book from the catalog.
+     *  *
+     *  * @param isbnCode - the ISBN number for the book
+     *  * @returns the retrieved book object
+     *  *
+     *  * @throws {@link IsbnSyntaxError}
+     *  * This exception is thrown if the input is not a valid ISBN number.
+     *  *
+     *  * @throws {@link book-lib#BookNotFoundError}
+     *  * Thrown if the ISBN number is valid, but no such book exists in the catalog.
+     *  *
+     *  * @public
+     *  */
+     * function fetchBookByIsbn(isbnCode: string): Book;
+     * ```
+     */
+    static readonly throws: TSDocTagDefinition;
+    /**
+     * (Core)
+     *
+     * Used to document a generic parameter.  The `@typeParam` tag is followed by a parameter
+     * name, followed by a hyphen, followed by a description.  The TSDoc parser recognizes
+     * this syntax and will extract it into a DocParamBlock node.
+     */
+    static readonly typeParam: TSDocTagDefinition;
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `virtual` keyword in C# or Java.
+     * For a member function or property, explicitly indicates that subclasses may override
+     * (i.e. redefine) the member.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    static readonly virtual: TSDocTagDefinition;
+    /**
+     * Returns the full list of all core tags.
+     */
+    static allDefinitions: ReadonlyArray<TSDocTagDefinition>;
+    private static _defineTag;
+}
+//# sourceMappingURL=StandardTags.d.ts.map

node_modules/@microsoft/tsdoc/lib/details/StandardTags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StandardTags.d.ts","sourceRoot":"","sources":["../../src/details/StandardTags.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAGnB,MAAM,qCAAqC,CAAC;AAG7C;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;OASG;IACH,gBAAuB,KAAK,EAAE,kBAAkB,CAI7C;IAEH;;;;;;;;;;;;;OAaG;IACH,gBAAuB,IAAI,EAAE,kBAAkB,CAI5C;IAEH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAAuB,SAAS,EAAE,kBAAkB,CAKjD;IAEH;;;;;;;;OAQG;IACH,gBAAuB,YAAY,EAAE,kBAAkB,CAIpD;IAEH;;;;;;;OAOG;IACH,gBAAuB,UAAU,EAAE,kBAAkB,CAIlD;IAEH;;;;;;;;OAQG;IACH,gBAAuB,aAAa,EAAE,kBAAkB,CAIrD;IAEH;;;;;OAKG;IACH,gBAAuB,OAAO,EAAE,kBAAkB,CAK/C;IAEH;;;;;;;;;;OAUG;IACH,gBAAuB,YAAY,EAAE,kBAAkB,CAIpD;IAEH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,gBAAuB,UAAU,EAAE,kBAAkB,CAIlD;IAEH;;;;;;;;;;OAUG;IACH,gBAAuB,QAAQ,EAAE,kBAAkB,CAIhD;IAEH;;;;;;;;;OASG;IACH,gBAAuB,KAAK,EAAE,kBAAkB,CAI7C;IAEH;;;;;;;;;;OAUG;IACH,gBAAuB,IAAI,EAAE,kBAAkB,CAK5C;IAEH;;;;;;;;;;;OAWG;IACH,gBAAuB,QAAQ,EAAE,kBAAkB,CAIhD;IAEH;;;;;;;;OAQG;IACH,gBAAuB,oBAAoB,EAAE,kBAAkB,CAI5D;IAEH;;;;;;OAMG;IACH,gBAAuB,KAAK,EAAE,kBAAkB,CAK7C;IAEH;;;;;;OAMG;IACH,gBAAuB,cAAc,EAAE,kBAAkB,CAItD;IAEH;;;;;;;;;OASG;IACH,gBAAuB,MAAM,EAAE,kBAAkB,CAI9C;IAEH;;;;;;;;;;;OAWG;IACH,gBAAuB,QAAQ,EAAE,kBAAkB,CAIhD;IAEH;;;;;;;;;OASG;IACH,gBAAuB,OAAO,EAAE,kBAAkB,CAI/C;IAEH;;;;OAIG;IACH,gBAAuB,OAAO,EAAE,kBAAkB,CAI/C;IAEH;;;;;;;;;;;OAWG;IACH,gBAAuB,MAAM,EAAE,kBAAkB,CAI9C;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,gBAAuB,GAAG,EAAE,kBAAkB,CAI3C;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,gBAAuB,MAAM,EAAE,kBAAkB,CAK9C;IAEH;;;;;;OAMG;IACH,gBAAuB,SAAS,EAAE,kBAAkB,CAKjD;IAEH;;;;;;;;;;OAUG;IACH,gBAAuB,OAAO,EAAE,kBAAkB,CAI/C;IAEH;;OAEG;IACH,OAAc,cAAc,EAAE,aAAa,CAAC,kBAAkB,CAAC,CA0B7D;IAEF,OAAO,CAAC,MAAM,CAAC,UAAU;CAG1B"}

node_modules/@microsoft/tsdoc/lib/details/StandardTags.js

@@ -0,0 +1,495 @@
+import { TSDocTagDefinition, TSDocTagSyntaxKind } from '../configuration/TSDocTagDefinition';
+import { Standardization } from './Standardization';
+/**
+ * Tags whose meaning is defined by the TSDoc standard.
+ */
+var StandardTags = /** @class */ (function () {
+    function StandardTags() {
+    }
+    StandardTags._defineTag = function (parameters) {
+        return new TSDocTagDefinition(parameters);
+    };
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "alpha".
+     * It is intended to be used by third-party developers eventually, but has not
+     * yet been released.  The tooling may trim the declaration from a public release.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    StandardTags.alpha = StandardTags._defineTag({
+        tagName: '@alpha',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Discretionary
+    });
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "beta".
+     * It has been released to third-party developers experimentally for the purpose of
+     * collecting feedback.  The API should not be used in production, because its contract may
+     * change without notice.  The tooling may trim the declaration from a public release,
+     * but may include it in a developer preview release.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     *
+     * Synonyms: `@experimental`
+     */
+    StandardTags.beta = StandardTags._defineTag({
+        tagName: '@beta',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Discretionary
+    });
+    /**
+     * (Extended)
+     *
+     * ECMAScript decorators are sometimes an important part of an API contract.
+     * However, today the TypeScript compiler does not represent decorators in the
+     * .d.ts output files used by API consumers.  The `@decorator` tag provides a workaround,
+     * enabling a decorator expressions to be quoted in a doc comment.
+     *
+     * @example
+     * ```ts
+     * class Book {
+     *   /**
+     *    * The title of the book.
+     *    * @decorator `@jsonSerialized`
+     *    * @decorator `@jsonFormat(JsonFormats.Url)`
+     *    *
+     *+/
+     *   @jsonSerialized
+     *   @jsonFormat(JsonFormats.Url)
+     *   public website: string;
+     * }
+     * ```
+     */
+    StandardTags.decorator = StandardTags._defineTag({
+        tagName: '@decorator',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Extended)
+     *
+     * This block tag is used to document the default value for a field or property,
+     * if a value is not assigned explicitly.
+     *
+     * @remarks
+     * This tag should only be used with fields or properties that are members of a class or interface.
+     */
+    StandardTags.defaultValue = StandardTags._defineTag({
+        tagName: '@defaultValue',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Core)
+     *
+     * This block tag communicates that an API item is no longer supported and may be removed
+     * in a future release.  The `@deprecated` tag is followed by a sentence describing
+     * the recommended alternative.  It recursively applies to members of the container.
+     * For example, if a class is deprecated, then so are all of its members.
+     */
+    StandardTags.deprecated = StandardTags._defineTag({
+        tagName: '@deprecated',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Extended)
+     *
+     * When applied to a class or interface property, this indicates that the property
+     * returns an event object that event handlers can be attached to.  The event-handling
+     * API is implementation-defined, but typically the property return type would be a class
+     * with members such as `addHandler()` and `removeHandler()`.  A documentation tool can
+     * display such properties under an "Events" heading instead of the usual "Properties" heading.
+     */
+    StandardTags.eventProperty = StandardTags._defineTag({
+        tagName: '@eventProperty',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Extended)
+     *
+     * Indicates a documentation section that should be presented as an example
+     * illustrating how to use the API.  It may include a code sample.
+     */
+    StandardTags.example = StandardTags._defineTag({
+        tagName: '@example',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning:  Same semantics as `@beta`, but used by tools that don't support
+     * an `@alpha` release stage.
+     *
+     * @remarks
+     * Example implementations: Angular API documenter
+     *
+     * Synonyms: `@beta`
+     */
+    StandardTags.experimental = StandardTags._defineTag({
+        tagName: '@experimental',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Discretionary
+    });
+    /**
+     * (Extended)
+     *
+     * This inline tag is used to automatically generate an API item's documentation by
+     * copying it from another API item.  The inline tag parameter contains a reference
+     * to the other item, which may be an unrelated class, or even an import from a
+     * separate NPM package.
+     *
+     * @remarks
+     * What gets copied
+     *
+     * The `@inheritDoc` tag does not copy the entire comment body. Only the following
+     * components are copied:
+     * - summary section
+     * - `@remarks` block
+     * - `@params` blocks
+     * - `@typeParam` blocks
+     * - `@returns` block
+     * Other tags such as `@defaultValue` or `@example` are not copied, and need to be
+     * explicitly included after the `@inheritDoc` tag.
+     *
+     * TODO: The notation for API item references is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    StandardTags.inheritDoc = StandardTags._defineTag({
+        tagName: '@inheritDoc',
+        syntaxKind: TSDocTagSyntaxKind.InlineTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning:  Designates that an API item is not planned to be used by
+     * third-party developers.  The tooling may trim the declaration from a public release.
+     * In some implementations, certain designated packages may be allowed to consume
+     * internal API items, e.g. because the packages are components of the same product.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    StandardTags.internal = StandardTags._defineTag({
+        tagName: '@internal',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Discretionary
+    });
+    /**
+     * (Core)
+     *
+     * The `{@label}` inline tag is used to label a declaration, so that it can be referenced
+     * using a selector in the TSDoc declaration reference notation.
+     *
+     * @remarks
+     * TODO: The `{@label}` notation is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    StandardTags.label = StandardTags._defineTag({
+        tagName: '@label',
+        syntaxKind: TSDocTagSyntaxKind.InlineTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Core)
+     *
+     * The `{@link}` inline tag is used to create hyperlinks to other pages in a
+     * documentation system or general internet URLs.  In particular, it supports
+     * expressions for referencing API items.
+     *
+     * @remarks
+     * TODO: The `{@link}` notation is still being standardized.  See this issue:
+     * https://github.com/microsoft/tsdoc/issues/9
+     */
+    StandardTags.link = StandardTags._defineTag({
+        tagName: '@link',
+        syntaxKind: TSDocTagSyntaxKind.InlineTag,
+        allowMultiple: true,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `override` keyword in C# or Java.
+     * For a member function or property, explicitly indicates that this definition
+     * is overriding (i.e. redefining) the definition inherited from the base class.
+     * The base class definition would normally be marked as `virtual`.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    StandardTags.override = StandardTags._defineTag({
+        tagName: '@override',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Core)
+     *
+     * Used to indicate a doc comment that describes an entire NPM package (as opposed
+     * to an individual API item belonging to that package).  The `@packageDocumentation` comment
+     * is found in the *.d.ts file that acts as the entry point for the package, and it
+     * should be the first `/**` comment encountered in that file.  A comment containing a
+     * `@packageDocumentation` tag should never be used to describe an individual API item.
+     */
+    StandardTags.packageDocumentation = StandardTags._defineTag({
+        tagName: '@packageDocumentation',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Core)
+     *
+     * Used to document a function parameter.  The `@param` tag is followed by a parameter
+     * name, followed by a hyphen, followed by a description.  The TSDoc parser recognizes
+     * this syntax and will extract it into a DocParamBlock node.
+     */
+    StandardTags.param = StandardTags._defineTag({
+        tagName: '@param',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Core)
+     *
+     * Starts a section of additional documentation content that is not intended for a
+     * public audience.  A tool must omit this entire section from the API reference web site,
+     * generated *.d.ts file, and any other outputs incorporating the content.
+     */
+    StandardTags.privateRemarks = StandardTags._defineTag({
+        tagName: '@privateRemarks',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Discretionary)
+     *
+     * Suggested meaning: Designates that an API item's release stage is "public".
+     * It has been officially released to third-party developers, and its signature is
+     * guaranteed to be stable (e.g. following Semantic Versioning rules).
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    StandardTags.public = StandardTags._defineTag({
+        tagName: '@public',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Discretionary
+    });
+    /**
+     * (Extended)
+     *
+     * This modifier tag indicates that an API item should be documented as being read-only,
+     * even if the TypeScript type system may indicate otherwise.  For example, suppose a
+     * class property has a setter function that always throws an exception explaining that
+     * the property cannot be assigned; in this situation, the `@readonly` modifier can be
+     * added so that the property is shown as read-only in the documentation.
+     *
+     * @remarks
+     * Example implementations: API Extractor
+     */
+    StandardTags.readonly = StandardTags._defineTag({
+        tagName: '@readonly',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Core)
+     *
+     * The main documentation for an API item is separated into a brief "summary" section,
+     * optionally followed by a more detailed "remarks" section.  On a documentation web site,
+     * index pages (e.g. showing members of a class) will show only the brief summaries,
+     * whereas a detail pages (e.g. describing a single member) will show the summary followed
+     * by the remarks.  The `@remarks` block tag ends the summary section, and begins the
+     * remarks section for a doc comment.
+     */
+    StandardTags.remarks = StandardTags._defineTag({
+        tagName: '@remarks',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Core)
+     *
+     * Used to document the return value for a function.
+     */
+    StandardTags.returns = StandardTags._defineTag({
+        tagName: '@returns',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `sealed` keyword in C# or Java.
+     * For a class, indicates that subclasses must not inherit from the class.
+     * For a member function or property, indicates that subclasses must not override
+     * (i.e. redefine) the member.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    StandardTags.sealed = StandardTags._defineTag({
+        tagName: '@sealed',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Extended)
+     *
+     * Used to build a list of references to an API item or other resource that may be related to the
+     * current item.
+     *
+     * @remarks
+     *
+     * For example:
+     *
+     * ```ts
+     * /**
+     *  * Parses a string containing a Uniform Resource Locator (URL).
+     *  * @see {@link ParsedUrl} for the returned data structure
+     *  * @see {@link https://tools.ietf.org/html/rfc1738|RFC 1738}
+     *  * for syntax
+     *  * @see your developer SDK for code samples
+     *  * @param url - the string to be parsed
+     *  * @returns the parsed result
+     *  */
+     * function parseURL(url: string): ParsedUrl;
+     * ```
+     *
+     * `@see` is a block tag.  Each block becomes an item in the list of references.  For example, a documentation
+     * system might render the above blocks as follows:
+     *
+     * ```markdown
+     * `function parseURL(url: string): ParsedUrl;`
+     *
+     * Parses a string containing a Uniform Resource Locator (URL).
+     *
+     * ## See Also
+     * - ParsedUrl for the returned data structure
+     * - RFC 1738 for syntax
+     * - your developer SDK for code samples
+     * ```
+     *
+     * NOTE: JSDoc attempts to automatically hyperlink the text immediately after `@see`.  Because this is ambiguous
+     * with plain text, TSDoc instead requires an explicit `{@link}` tag to make hyperlinks.
+     */
+    StandardTags.see = StandardTags._defineTag({
+        tagName: '@see',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Extended)
+     *
+     * Used to document an exception type that may be thrown by a function or property.
+     *
+     * @remarks
+     *
+     * A separate `@throws` block should be used to document each exception type.  This tag is for informational
+     * purposes only, and does not restrict other types from being thrown.  It is suggested, but not required,
+     * for the `@throws` block to start with a line containing only the name of the exception.
+     *
+     * For example:
+     *
+     * ```ts
+     * /**
+     *  * Retrieves metadata about a book from the catalog.
+     *  *
+     *  * @param isbnCode - the ISBN number for the book
+     *  * @returns the retrieved book object
+     *  *
+     *  * @throws {@link IsbnSyntaxError}
+     *  * This exception is thrown if the input is not a valid ISBN number.
+     *  *
+     *  * @throws {@link book-lib#BookNotFoundError}
+     *  * Thrown if the ISBN number is valid, but no such book exists in the catalog.
+     *  *
+     *  * @public
+     *  */
+     * function fetchBookByIsbn(isbnCode: string): Book;
+     * ```
+     */
+    StandardTags.throws = StandardTags._defineTag({
+        tagName: '@throws',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true,
+        standardization: Standardization.Extended
+    });
+    /**
+     * (Core)
+     *
+     * Used to document a generic parameter.  The `@typeParam` tag is followed by a parameter
+     * name, followed by a hyphen, followed by a description.  The TSDoc parser recognizes
+     * this syntax and will extract it into a DocParamBlock node.
+     */
+    StandardTags.typeParam = StandardTags._defineTag({
+        tagName: '@typeParam',
+        syntaxKind: TSDocTagSyntaxKind.BlockTag,
+        allowMultiple: true,
+        standardization: Standardization.Core
+    });
+    /**
+     * (Extended)
+     *
+     * This modifier has similar semantics to the `virtual` keyword in C# or Java.
+     * For a member function or property, explicitly indicates that subclasses may override
+     * (i.e. redefine) the member.
+     *
+     * @remarks
+     * A documentation tool may enforce that the `@virtual`, `@override`, and/or `@sealed`
+     * modifiers are consistently applied, but this is not required by the TSDoc standard.
+     */
+    StandardTags.virtual = StandardTags._defineTag({
+        tagName: '@virtual',
+        syntaxKind: TSDocTagSyntaxKind.ModifierTag,
+        standardization: Standardization.Extended
+    });
+    /**
+     * Returns the full list of all core tags.
+     */
+    StandardTags.allDefinitions = [
+        StandardTags.alpha,
+        StandardTags.beta,
+        StandardTags.defaultValue,
+        StandardTags.decorator,
+        StandardTags.deprecated,
+        StandardTags.eventProperty,
+        StandardTags.example,
+        StandardTags.experimental,
+        StandardTags.inheritDoc,
+        StandardTags.internal,
+        StandardTags.label,
+        StandardTags.link,
+        StandardTags.override,
+        StandardTags.packageDocumentation,
+        StandardTags.param,
+        StandardTags.privateRemarks,
+        StandardTags.public,
+        StandardTags.readonly,
+        StandardTags.remarks,
+        StandardTags.returns,
+        StandardTags.sealed,
+        StandardTags.see,
+        StandardTags.throws,
+        StandardTags.typeParam,
+        StandardTags.virtual
+    ];
+    return StandardTags;
+}());
+export { StandardTags };
+//# sourceMappingURL=StandardTags.js.map

node_modules/@microsoft/tsdoc/lib/details/Standardization.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Used to group the {@link StandardTags} definitions according to the level of support
+ * expected from documentation tools that implement the standard.
+ */
+export declare enum Standardization {
+    /**
+     * TSDoc tags in the "Core" standardization group are considered essential.
+     * Their meaning is standardized, and every documentation tool is expected
+     * to recognize them.  The TSDoc parser library typically provides dedicated APIs
+     * for accessing these tags.
+     */
+    Core = "Core",
+    /**
+     * TSDoc tags in the "Extended" standardization group are optional.  Documentation tools
+     * may or may not support them.  If they do, the syntax and semantics should conform to
+     * the TSDoc standard definitions.
+     */
+    Extended = "Extended",
+    /**
+     * TSDoc tags in the "Discretionary" standardization group are optional.  Although the
+     * syntax is specified, the semantics for these tags are implementation-specific
+     * (and sometimes difficult to describe completely without referring to a specific
+     * implementation).  Discretionary tags are included in the TSDoc standard to ensure that
+     * if two different popular tools use the same tag name, developers can expect the syntax
+     * to be the same, and the semantics to be somewhat similar.
+     */
+    Discretionary = "Discretionary",
+    /**
+     * The tag is not part of the TSDoc standard.  All used-defined tags are assigned to this group.
+     */
+    None = "None"
+}
+//# sourceMappingURL=Standardization.d.ts.map

node_modules/@microsoft/tsdoc/lib/details/Standardization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Standardization.d.ts","sourceRoot":"","sources":["../../src/details/Standardization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IACzB;;;;;OAKG;IACH,IAAI,SAAS;IAEb;;;;OAIG;IACH,QAAQ,aAAa;IAErB;;;;;;;OAOG;IACH,aAAa,kBAAkB;IAE/B;;OAEG;IACH,IAAI,SAAS;CACd"}

node_modules/@microsoft/tsdoc/lib/details/Standardization.js

@@ -0,0 +1,34 @@
+/**
+ * Used to group the {@link StandardTags} definitions according to the level of support
+ * expected from documentation tools that implement the standard.
+ */
+export var Standardization;
+(function (Standardization) {
+    /**
+     * TSDoc tags in the "Core" standardization group are considered essential.
+     * Their meaning is standardized, and every documentation tool is expected
+     * to recognize them.  The TSDoc parser library typically provides dedicated APIs
+     * for accessing these tags.
+     */
+    Standardization["Core"] = "Core";
+    /**
+     * TSDoc tags in the "Extended" standardization group are optional.  Documentation tools
+     * may or may not support them.  If they do, the syntax and semantics should conform to
+     * the TSDoc standard definitions.
+     */
+    Standardization["Extended"] = "Extended";
+    /**
+     * TSDoc tags in the "Discretionary" standardization group are optional.  Although the
+     * syntax is specified, the semantics for these tags are implementation-specific
+     * (and sometimes difficult to describe completely without referring to a specific
+     * implementation).  Discretionary tags are included in the TSDoc standard to ensure that
+     * if two different popular tools use the same tag name, developers can expect the syntax
+     * to be the same, and the semantics to be somewhat similar.
+     */
+    Standardization["Discretionary"] = "Discretionary";
+    /**
+     * The tag is not part of the TSDoc standard.  All used-defined tags are assigned to this group.
+     */
+    Standardization["None"] = "None";
+})(Standardization || (Standardization = {}));
+//# sourceMappingURL=Standardization.js.map

node_modules/@microsoft/tsdoc/lib/details/Standardization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Standardization.js","sourceRoot":"","sources":["../../src/details/Standardization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAN,IAAY,eA8BX;AA9BD,WAAY,eAAe;IACzB;;;;;OAKG;IACH,gCAAa,CAAA;IAEb;;;;OAIG;IACH,wCAAqB,CAAA;IAErB;;;;;;;OAOG;IACH,kDAA+B,CAAA;IAE/B;;OAEG;IACH,gCAAa,CAAA;AACf,CAAC,EA9BW,eAAe,KAAf,eAAe,QA8B1B","sourcesContent":["/**\r\n * Used to group the {@link StandardTags} definitions according to the level of support\r\n * expected from documentation tools that implement the standard.\r\n */\r\nexport enum Standardization {\r\n  /**\r\n   * TSDoc tags in the \"Core\" standardization group are considered essential.\r\n   * Their meaning is standardized, and every documentation tool is expected\r\n   * to recognize them.  The TSDoc parser library typically provides dedicated APIs\r\n   * for accessing these tags.\r\n   */\r\n  Core = 'Core',\r\n\r\n  /**\r\n   * TSDoc tags in the \"Extended\" standardization group are optional.  Documentation tools\r\n   * may or may not support them.  If they do, the syntax and semantics should conform to\r\n   * the TSDoc standard definitions.\r\n   */\r\n  Extended = 'Extended',\r\n\r\n  /**\r\n   * TSDoc tags in the \"Discretionary\" standardization group are optional.  Although the\r\n   * syntax is specified, the semantics for these tags are implementation-specific\r\n   * (and sometimes difficult to describe completely without referring to a specific\r\n   * implementation).  Discretionary tags are included in the TSDoc standard to ensure that\r\n   * if two different popular tools use the same tag name, developers can expect the syntax\r\n   * to be the same, and the semantics to be somewhat similar.\r\n   */\r\n  Discretionary = 'Discretionary',\r\n\r\n  /**\r\n   * The tag is not part of the TSDoc standard.  All used-defined tags are assigned to this group.\r\n   */\r\n  None = 'None'\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/emitters/PlainTextEmitter.d.ts

@@ -0,0 +1,33 @@
+import { DocNode } from '../nodes';
+/**
+ * Renders a DocNode tree as plain text, without any rich text formatting or markup.
+ */
+export declare class PlainTextEmitter {
+    /**
+     * Returns true if the specified node contains any text content.
+     *
+     * @remarks
+     * A documentation tool can use this test to report warnings when a developer neglected to write a code comment
+     * for a declaration.
+     *
+     * @param node - this node and all its children will be considered
+     * @param requiredCharacters - The test returns true if at least this many non-spacing characters are found.
+     * The default value is 1.
+     */
+    static hasAnyTextContent(node: DocNode, requiredCharacters?: number): boolean;
+    /**
+     * Returns true if the specified collection of nodes contains any text content.
+     *
+     * @remarks
+     * A documentation tool can use this test to report warnings when a developer neglected to write a code comment
+     * for a declaration.
+     *
+     * @param nodes - the collection of nodes to be tested
+     * @param requiredCharacters - The test returns true if at least this many non-spacing characters are found.
+     * The default value is 1.
+     */
+    static hasAnyTextContent(nodes: ReadonlyArray<DocNode>, requiredCharacters?: number): boolean;
+    private static _scanTextContent;
+    private static _countNonSpaceCharacters;
+}
+//# sourceMappingURL=PlainTextEmitter.d.ts.map

node_modules/@microsoft/tsdoc/lib/emitters/PlainTextEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlainTextEmitter.d.ts","sourceRoot":"","sources":["../../src/emitters/PlainTextEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAOR,MAAM,UAAU,CAAC;AAElB;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;OAUG;WACW,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO;IAEpF;;;;;;;;;;OAUG;WACW,iBAAiB,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO;IAqBpG,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAkD/B,OAAO,CAAC,MAAM,CAAC,wBAAwB;CAkBxC"}

node_modules/@microsoft/tsdoc/lib/emitters/PlainTextEmitter.js

@@ -0,0 +1,78 @@
+import { DocNode, DocNodeKind } from '../nodes';
+/**
+ * Renders a DocNode tree as plain text, without any rich text formatting or markup.
+ */
+var PlainTextEmitter = /** @class */ (function () {
+    function PlainTextEmitter() {
+    }
+    PlainTextEmitter.hasAnyTextContent = function (nodeOrNodes, requiredCharacters) {
+        if (requiredCharacters === undefined || requiredCharacters < 1) {
+            requiredCharacters = 1; // default
+        }
+        var nodes;
+        if (nodeOrNodes instanceof DocNode) {
+            nodes = [nodeOrNodes];
+        }
+        else {
+            nodes = nodeOrNodes;
+        }
+        var foundCharacters = PlainTextEmitter._scanTextContent(nodes, requiredCharacters, 0);
+        return foundCharacters >= requiredCharacters;
+    };
+    PlainTextEmitter._scanTextContent = function (nodes, requiredCharacters, foundCharacters) {
+        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+            var node = nodes_1[_i];
+            switch (node.kind) {
+                case DocNodeKind.FencedCode:
+                    var docFencedCode = node;
+                    foundCharacters += PlainTextEmitter._countNonSpaceCharacters(docFencedCode.code);
+                    break;
+                case DocNodeKind.CodeSpan:
+                    var docCodeSpan = node;
+                    foundCharacters += PlainTextEmitter._countNonSpaceCharacters(docCodeSpan.code);
+                    break;
+                case DocNodeKind.EscapedText:
+                    var docEscapedText = node;
+                    foundCharacters += PlainTextEmitter._countNonSpaceCharacters(docEscapedText.decodedText);
+                    break;
+                case DocNodeKind.LinkTag:
+                    var docLinkTag = node;
+                    foundCharacters += PlainTextEmitter._countNonSpaceCharacters(docLinkTag.linkText || '');
+                    break;
+                case DocNodeKind.PlainText:
+                    var docPlainText = node;
+                    foundCharacters += PlainTextEmitter._countNonSpaceCharacters(docPlainText.text);
+                    break;
+            }
+            if (foundCharacters >= requiredCharacters) {
+                break;
+            }
+            foundCharacters += PlainTextEmitter._scanTextContent(node.getChildNodes(), requiredCharacters, foundCharacters);
+            if (foundCharacters >= requiredCharacters) {
+                break;
+            }
+        }
+        return foundCharacters;
+    };
+    PlainTextEmitter._countNonSpaceCharacters = function (s) {
+        var count = 0;
+        var length = s.length;
+        var i = 0;
+        while (i < length) {
+            switch (s.charCodeAt(i)) {
+                case 32: // space
+                case 9: // tab
+                case 13: // CR
+                case 10: // LF
+                    break;
+                default:
+                    ++count;
+            }
+            ++i;
+        }
+        return count;
+    };
+    return PlainTextEmitter;
+}());
+export { PlainTextEmitter };
+//# sourceMappingURL=PlainTextEmitter.js.map

node_modules/@microsoft/tsdoc/lib/emitters/StringBuilder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * An interface for a builder object that allows a large text string to be constructed incrementally by appending
+ * small chunks.
+ *
+ * @remarks
+ *
+ * {@link StringBuilder} is the default implementation of this contract.
+ */
+export interface IStringBuilder {
+    /**
+     * Append the specified text to the buffer.
+     */
+    append(text: string): void;
+    /**
+     * Returns a single string containing all the text that was appended to the buffer so far.
+     *
+     * @remarks
+     *
+     * This is a potentially expensive operation.
+     */
+    toString(): string;
+}
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ */
+export declare class StringBuilder implements IStringBuilder {
+    private _chunks;
+    constructor();
+    /** {@inheritdoc IStringBuilder.append} */
+    append(text: string): void;
+    /** {@inheritdoc IStringBuilder.toString} */
+    toString(): string;
+}
+//# sourceMappingURL=StringBuilder.d.ts.map

node_modules/@microsoft/tsdoc/lib/emitters/StringBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringBuilder.d.ts","sourceRoot":"","sources":["../../src/emitters/StringBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,OAAO,CAAC,OAAO,CAAW;;IAM1B,0CAA0C;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIjC,4CAA4C;IACrC,QAAQ,IAAI,MAAM;CAa1B"}

node_modules/@microsoft/tsdoc/lib/emitters/StringBuilder.js

@@ -0,0 +1,35 @@
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ */
+var StringBuilder = /** @class */ (function () {
+    function StringBuilder() {
+        this._chunks = [];
+    }
+    /** {@inheritdoc IStringBuilder.append} */
+    StringBuilder.prototype.append = function (text) {
+        this._chunks.push(text);
+    };
+    /** {@inheritdoc IStringBuilder.toString} */
+    StringBuilder.prototype.toString = function () {
+        if (this._chunks.length === 0) {
+            return '';
+        }
+        if (this._chunks.length > 1) {
+            var joined = this._chunks.join('');
+            this._chunks.length = 1;
+            this._chunks[0] = joined;
+        }
+        return this._chunks[0];
+    };
+    return StringBuilder;
+}());
+export { StringBuilder };
+//# sourceMappingURL=StringBuilder.js.map

node_modules/@microsoft/tsdoc/lib/emitters/StringBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringBuilder.js","sourceRoot":"","sources":["../../src/emitters/StringBuilder.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;GAUG;AACH;IAGE;QACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,0CAA0C;IACnC,8BAAM,GAAb,UAAc,IAAY;QACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,4CAA4C;IACrC,gCAAQ,GAAf;QACE,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7B,OAAO,EAAE,CAAC;SACX;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,IAAM,MAAM,GAAW,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;SAC1B;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC;IACH,oBAAC;AAAD,CAAC,AA1BD,IA0BC","sourcesContent":["/**\r\n * An interface for a builder object that allows a large text string to be constructed incrementally by appending\r\n * small chunks.\r\n *\r\n * @remarks\r\n *\r\n * {@link StringBuilder} is the default implementation of this contract.\r\n */\r\nexport interface IStringBuilder {\r\n  /**\r\n   * Append the specified text to the buffer.\r\n   */\r\n  append(text: string): void;\r\n\r\n  /**\r\n   * Returns a single string containing all the text that was appended to the buffer so far.\r\n   *\r\n   * @remarks\r\n   *\r\n   * This is a potentially expensive operation.\r\n   */\r\n  toString(): string;\r\n}\r\n\r\n/**\r\n * This class allows a large text string to be constructed incrementally by appending small chunks.  The final\r\n * string can be obtained by calling StringBuilder.toString().\r\n *\r\n * @remarks\r\n * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying\r\n * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated\r\n * (and later freed by the garbage  collector), and many of the allocations could be very large objects.\r\n * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them\r\n * when `getText()` is finally called.\r\n */\r\nexport class StringBuilder implements IStringBuilder {\r\n  private _chunks: string[];\r\n\r\n  public constructor() {\r\n    this._chunks = [];\r\n  }\r\n\r\n  /** {@inheritdoc IStringBuilder.append} */\r\n  public append(text: string): void {\r\n    this._chunks.push(text);\r\n  }\r\n\r\n  /** {@inheritdoc IStringBuilder.toString} */\r\n  public toString(): string {\r\n    if (this._chunks.length === 0) {\r\n      return '';\r\n    }\r\n\r\n    if (this._chunks.length > 1) {\r\n      const joined: string = this._chunks.join('');\r\n      this._chunks.length = 1;\r\n      this._chunks[0] = joined;\r\n    }\r\n\r\n    return this._chunks[0];\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/emitters/TSDocEmitter.d.ts

@@ -0,0 +1,26 @@
+import type { DocComment, DocDeclarationReference, DocHtmlEndTag, DocHtmlStartTag } from '../nodes';
+import { IStringBuilder } from './StringBuilder';
+/**
+ * Renders a DocNode tree as a code comment.
+ */
+export declare class TSDocEmitter {
+    readonly eol: string;
+    private _emitCommentFraming;
+    private _output;
+    private _lineState;
+    private _previousLineHadContent;
+    private _hangingParagraph;
+    renderComment(output: IStringBuilder, docComment: DocComment): void;
+    renderHtmlTag(output: IStringBuilder, htmlTag: DocHtmlStartTag | DocHtmlEndTag): void;
+    renderDeclarationReference(output: IStringBuilder, declarationReference: DocDeclarationReference): void;
+    private _renderCompleteObject;
+    private _renderNode;
+    private _renderInlineTag;
+    private _renderNodes;
+    private _ensureAtStartOfLine;
+    private _ensureLineSkipped;
+    private _writeContent;
+    private _writeNewline;
+    private _writeEnd;
+}
+//# sourceMappingURL=TSDocEmitter.d.ts.map

node_modules/@microsoft/tsdoc/lib/emitters/TSDocEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocEmitter.d.ts","sourceRoot":"","sources":["../../src/emitters/TSDocEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EAQV,uBAAuB,EAGvB,aAAa,EACb,eAAe,EAWhB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAWjD;;GAEG;AACH,qBAAa,YAAY;IACvB,SAAgB,GAAG,EAAE,MAAM,CAAQ;IAGnC,OAAO,CAAC,mBAAmB,CAAiB;IAE5C,OAAO,CAAC,OAAO,CAA6B;IAG5C,OAAO,CAAC,UAAU,CAA+B;IAGjD,OAAO,CAAC,uBAAuB,CAAkB;IAKjD,OAAO,CAAC,iBAAiB,CAAkB;IAEpC,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;IAKnE,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,eAAe,GAAG,aAAa,GAAG,IAAI;IAKrF,0BAA0B,CAC/B,MAAM,EAAE,cAAc,EACtB,oBAAoB,EAAE,uBAAuB,GAC5C,IAAI;IAKP,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,WAAW;IAoQnB,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,aAAa;IAsCrB,OAAO,CAAC,aAAa;IAqBrB,OAAO,CAAC,SAAS;CAclB"}

node_modules/@microsoft/tsdoc/lib/emitters/TSDocEmitter.js

@@ -0,0 +1,376 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import { DocNodeKind } from '../nodes/DocNode';
+import { DocNodeTransforms } from '../transforms/DocNodeTransforms';
+import { StandardTags } from '../details/StandardTags';
+var LineState;
+(function (LineState) {
+    LineState[LineState["Closed"] = 0] = "Closed";
+    LineState[LineState["StartOfLine"] = 1] = "StartOfLine";
+    LineState[LineState["MiddleOfLine"] = 2] = "MiddleOfLine";
+})(LineState || (LineState = {}));
+/**
+ * Renders a DocNode tree as a code comment.
+ */
+var TSDocEmitter = /** @class */ (function () {
+    function TSDocEmitter() {
+        this.eol = '\n';
+        // Whether to emit the /** */ framing
+        this._emitCommentFraming = true;
+        // This state machine is used by the writer functions to generate the /** */ framing around the emitted lines
+        this._lineState = LineState.Closed;
+        // State for _ensureLineSkipped()
+        this._previousLineHadContent = false;
+        // Normally a paragraph is precede by a blank line (unless it's the first thing written).
+        // But sometimes we want the paragraph to be attached to the previous element, e.g. when it's part of
+        // an "@param" block.  Setting _hangingParagraph=true accomplishes that.
+        this._hangingParagraph = false;
+    }
+    TSDocEmitter.prototype.renderComment = function (output, docComment) {
+        this._emitCommentFraming = true;
+        this._renderCompleteObject(output, docComment);
+    };
+    TSDocEmitter.prototype.renderHtmlTag = function (output, htmlTag) {
+        this._emitCommentFraming = false;
+        this._renderCompleteObject(output, htmlTag);
+    };
+    TSDocEmitter.prototype.renderDeclarationReference = function (output, declarationReference) {
+        this._emitCommentFraming = false;
+        this._renderCompleteObject(output, declarationReference);
+    };
+    TSDocEmitter.prototype._renderCompleteObject = function (output, docNode) {
+        this._output = output;
+        this._lineState = LineState.Closed;
+        this._previousLineHadContent = false;
+        this._hangingParagraph = false;
+        this._renderNode(docNode);
+        this._writeEnd();
+    };
+    TSDocEmitter.prototype._renderNode = function (docNode) {
+        var _this = this;
+        if (docNode === undefined) {
+            return;
+        }
+        switch (docNode.kind) {
+            case DocNodeKind.Block:
+                var docBlock = docNode;
+                this._ensureLineSkipped();
+                this._renderNode(docBlock.blockTag);
+                if (docBlock.blockTag.tagNameWithUpperCase === StandardTags.returns.tagNameWithUpperCase) {
+                    this._writeContent(' ');
+                    this._hangingParagraph = true;
+                }
+                this._renderNode(docBlock.content);
+                break;
+            case DocNodeKind.BlockTag:
+                var docBlockTag = docNode;
+                if (this._lineState === LineState.MiddleOfLine) {
+                    this._writeContent(' ');
+                }
+                this._writeContent(docBlockTag.tagName);
+                break;
+            case DocNodeKind.CodeSpan:
+                var docCodeSpan = docNode;
+                this._writeContent('`');
+                this._writeContent(docCodeSpan.code);
+                this._writeContent('`');
+                break;
+            case DocNodeKind.Comment:
+                var docComment = docNode;
+                this._renderNodes(__spreadArrays([
+                    docComment.summarySection,
+                    docComment.remarksBlock,
+                    docComment.privateRemarks,
+                    docComment.deprecatedBlock,
+                    docComment.params,
+                    docComment.typeParams,
+                    docComment.returnsBlock
+                ], docComment.customBlocks, docComment.seeBlocks, [
+                    docComment.inheritDocTag
+                ]));
+                if (docComment.modifierTagSet.nodes.length > 0) {
+                    this._ensureLineSkipped();
+                    this._renderNodes(docComment.modifierTagSet.nodes);
+                }
+                break;
+            case DocNodeKind.DeclarationReference:
+                var docDeclarationReference = docNode;
+                this._writeContent(docDeclarationReference.packageName);
+                this._writeContent(docDeclarationReference.importPath);
+                if (docDeclarationReference.packageName !== undefined ||
+                    docDeclarationReference.importPath !== undefined) {
+                    this._writeContent('#');
+                }
+                this._renderNodes(docDeclarationReference.memberReferences);
+                break;
+            case DocNodeKind.ErrorText:
+                var docErrorText = docNode;
+                this._writeContent(docErrorText.text);
+                break;
+            case DocNodeKind.EscapedText:
+                var docEscapedText = docNode;
+                this._writeContent(docEscapedText.encodedText);
+                break;
+            case DocNodeKind.FencedCode:
+                var docFencedCode = docNode;
+                this._ensureAtStartOfLine();
+                this._writeContent('```');
+                this._writeContent(docFencedCode.language);
+                this._writeNewline();
+                this._writeContent(docFencedCode.code);
+                this._writeContent('```');
+                this._writeNewline();
+                this._writeNewline();
+                break;
+            case DocNodeKind.HtmlAttribute:
+                var docHtmlAttribute = docNode;
+                this._writeContent(docHtmlAttribute.name);
+                this._writeContent(docHtmlAttribute.spacingAfterName);
+                this._writeContent('=');
+                this._writeContent(docHtmlAttribute.spacingAfterEquals);
+                this._writeContent(docHtmlAttribute.value);
+                this._writeContent(docHtmlAttribute.spacingAfterValue);
+                break;
+            case DocNodeKind.HtmlEndTag:
+                var docHtmlEndTag = docNode;
+                this._writeContent('</');
+                this._writeContent(docHtmlEndTag.name);
+                this._writeContent('>');
+                break;
+            case DocNodeKind.HtmlStartTag:
+                var docHtmlStartTag = docNode;
+                this._writeContent('<');
+                this._writeContent(docHtmlStartTag.name);
+                this._writeContent(docHtmlStartTag.spacingAfterName);
+                var needsSpace = docHtmlStartTag.spacingAfterName === undefined || docHtmlStartTag.spacingAfterName.length === 0;
+                for (var _i = 0, _a = docHtmlStartTag.htmlAttributes; _i < _a.length; _i++) {
+                    var attribute = _a[_i];
+                    if (needsSpace) {
+                        this._writeContent(' ');
+                    }
+                    this._renderNode(attribute);
+                    needsSpace = attribute.spacingAfterValue === undefined || attribute.spacingAfterValue.length === 0;
+                }
+                this._writeContent(docHtmlStartTag.selfClosingTag ? '/>' : '>');
+                break;
+            case DocNodeKind.InheritDocTag:
+                var docInheritDocTag_1 = docNode;
+                this._renderInlineTag(docInheritDocTag_1, function () {
+                    if (docInheritDocTag_1.declarationReference) {
+                        _this._writeContent(' ');
+                        _this._renderNode(docInheritDocTag_1.declarationReference);
+                    }
+                });
+                break;
+            case DocNodeKind.InlineTag:
+                var docInlineTag_1 = docNode;
+                this._renderInlineTag(docInlineTag_1, function () {
+                    if (docInlineTag_1.tagContent.length > 0) {
+                        _this._writeContent(' ');
+                        _this._writeContent(docInlineTag_1.tagContent);
+                    }
+                });
+                break;
+            case DocNodeKind.LinkTag:
+                var docLinkTag_1 = docNode;
+                this._renderInlineTag(docLinkTag_1, function () {
+                    if (docLinkTag_1.urlDestination !== undefined || docLinkTag_1.codeDestination !== undefined) {
+                        if (docLinkTag_1.urlDestination !== undefined) {
+                            _this._writeContent(' ');
+                            _this._writeContent(docLinkTag_1.urlDestination);
+                        }
+                        else if (docLinkTag_1.codeDestination !== undefined) {
+                            _this._writeContent(' ');
+                            _this._renderNode(docLinkTag_1.codeDestination);
+                        }
+                    }
+                    if (docLinkTag_1.linkText !== undefined) {
+                        _this._writeContent(' ');
+                        _this._writeContent('|');
+                        _this._writeContent(' ');
+                        _this._writeContent(docLinkTag_1.linkText);
+                    }
+                });
+                break;
+            case DocNodeKind.MemberIdentifier:
+                var docMemberIdentifier = docNode;
+                if (docMemberIdentifier.hasQuotes) {
+                    this._writeContent('"');
+                    this._writeContent(docMemberIdentifier.identifier); // todo: encoding
+                    this._writeContent('"');
+                }
+                else {
+                    this._writeContent(docMemberIdentifier.identifier);
+                }
+                break;
+            case DocNodeKind.MemberReference:
+                var docMemberReference = docNode;
+                if (docMemberReference.hasDot) {
+                    this._writeContent('.');
+                }
+                if (docMemberReference.selector) {
+                    this._writeContent('(');
+                }
+                if (docMemberReference.memberSymbol) {
+                    this._renderNode(docMemberReference.memberSymbol);
+                }
+                else {
+                    this._renderNode(docMemberReference.memberIdentifier);
+                }
+                if (docMemberReference.selector) {
+                    this._writeContent(':');
+                    this._renderNode(docMemberReference.selector);
+                    this._writeContent(')');
+                }
+                break;
+            case DocNodeKind.MemberSelector:
+                var docMemberSelector = docNode;
+                this._writeContent(docMemberSelector.selector);
+                break;
+            case DocNodeKind.MemberSymbol:
+                var docMemberSymbol = docNode;
+                this._writeContent('[');
+                this._renderNode(docMemberSymbol.symbolReference);
+                this._writeContent(']');
+                break;
+            case DocNodeKind.Section:
+                var docSection = docNode;
+                this._renderNodes(docSection.nodes);
+                break;
+            case DocNodeKind.Paragraph:
+                var trimmedParagraph = DocNodeTransforms.trimSpacesInParagraph(docNode);
+                if (trimmedParagraph.nodes.length > 0) {
+                    if (this._hangingParagraph) {
+                        // If it's a hanging paragraph, then don't skip a line
+                        this._hangingParagraph = false;
+                    }
+                    else {
+                        this._ensureLineSkipped();
+                    }
+                    this._renderNodes(trimmedParagraph.nodes);
+                    this._writeNewline();
+                }
+                break;
+            case DocNodeKind.ParamBlock:
+                var docParamBlock = docNode;
+                this._ensureLineSkipped();
+                this._renderNode(docParamBlock.blockTag);
+                this._writeContent(' ');
+                this._writeContent(docParamBlock.parameterName);
+                this._writeContent(' - ');
+                this._hangingParagraph = true;
+                this._renderNode(docParamBlock.content);
+                this._hangingParagraph = false;
+                break;
+            case DocNodeKind.ParamCollection:
+                var docParamCollection = docNode;
+                this._renderNodes(docParamCollection.blocks);
+                break;
+            case DocNodeKind.PlainText:
+                var docPlainText = docNode;
+                this._writeContent(docPlainText.text);
+                break;
+        }
+    };
+    TSDocEmitter.prototype._renderInlineTag = function (docInlineTagBase, writeInlineTagContent) {
+        this._writeContent('{');
+        this._writeContent(docInlineTagBase.tagName);
+        writeInlineTagContent();
+        this._writeContent('}');
+    };
+    TSDocEmitter.prototype._renderNodes = function (docNodes) {
+        for (var _i = 0, docNodes_1 = docNodes; _i < docNodes_1.length; _i++) {
+            var docNode = docNodes_1[_i];
+            this._renderNode(docNode);
+        }
+    };
+    // Calls _writeNewline() only if we're not already at the start of a new line
+    TSDocEmitter.prototype._ensureAtStartOfLine = function () {
+        if (this._lineState === LineState.MiddleOfLine) {
+            this._writeNewline();
+        }
+    };
+    // Calls _writeNewline() if needed to ensure that we have skipped at least one line
+    TSDocEmitter.prototype._ensureLineSkipped = function () {
+        this._ensureAtStartOfLine();
+        if (this._previousLineHadContent) {
+            this._writeNewline();
+        }
+    };
+    // Writes literal text content.  If it contains newlines, they will automatically be converted to
+    // _writeNewline() calls, to ensure that "*" is written at the start of each line.
+    TSDocEmitter.prototype._writeContent = function (content) {
+        if (content === undefined || content.length === 0) {
+            return;
+        }
+        var splitLines = content.split(/\r?\n/g);
+        if (splitLines.length > 1) {
+            var firstLine = true;
+            for (var _i = 0, splitLines_1 = splitLines; _i < splitLines_1.length; _i++) {
+                var line = splitLines_1[_i];
+                if (firstLine) {
+                    firstLine = false;
+                }
+                else {
+                    this._writeNewline();
+                }
+                this._writeContent(line);
+            }
+            return;
+        }
+        if (this._lineState === LineState.Closed) {
+            if (this._emitCommentFraming) {
+                this._output.append('/**' + this.eol + ' *');
+            }
+            this._lineState = LineState.StartOfLine;
+        }
+        if (this._lineState === LineState.StartOfLine) {
+            if (this._emitCommentFraming) {
+                this._output.append(' ');
+            }
+        }
+        this._output.append(content);
+        this._lineState = LineState.MiddleOfLine;
+        this._previousLineHadContent = true;
+    };
+    // Starts a new line, and inserts "/**" or "*" as appropriate.
+    TSDocEmitter.prototype._writeNewline = function () {
+        if (this._lineState === LineState.Closed) {
+            if (this._emitCommentFraming) {
+                this._output.append('/**' + this.eol + ' *');
+            }
+            this._lineState = LineState.StartOfLine;
+        }
+        this._previousLineHadContent = this._lineState === LineState.MiddleOfLine;
+        if (this._emitCommentFraming) {
+            this._output.append(this.eol + ' *');
+        }
+        else {
+            this._output.append(this.eol);
+        }
+        this._lineState = LineState.StartOfLine;
+        this._hangingParagraph = false;
+    };
+    // Closes the comment, adding the final "*/" delimiter
+    TSDocEmitter.prototype._writeEnd = function () {
+        if (this._lineState === LineState.MiddleOfLine) {
+            if (this._emitCommentFraming) {
+                this._writeNewline();
+            }
+        }
+        if (this._lineState !== LineState.Closed) {
+            if (this._emitCommentFraming) {
+                this._output.append('/' + this.eol);
+            }
+            this._lineState = LineState.Closed;
+        }
+    };
+    return TSDocEmitter;
+}());
+export { TSDocEmitter };
+//# sourceMappingURL=TSDocEmitter.js.map

node_modules/@microsoft/tsdoc/lib/emitters/__tests__/TSDocEmitter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TSDocEmitter.test.d.ts.map

node_modules/@microsoft/tsdoc/lib/emitters/__tests__/TSDocEmitter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSDocEmitter.test.d.ts","sourceRoot":"","sources":["../../../src/emitters/__tests__/TSDocEmitter.test.ts"],"names":[],"mappings":""}

node_modules/@microsoft/tsdoc/lib/index.d.ts

@@ -0,0 +1,22 @@
+export { DocNodeManager, IDocNodeDefinition, DocNodeConstructor } from './configuration/DocNodeManager';
+export { TSDocConfiguration } from './configuration/TSDocConfiguration';
+export { ITSDocTagDefinitionParameters, TSDocTagSyntaxKind, TSDocTagDefinition } from './configuration/TSDocTagDefinition';
+export { TSDocValidationConfiguration } from './configuration/TSDocValidationConfiguration';
+export { StandardTags } from './details/StandardTags';
+export { Standardization } from './details/Standardization';
+export { StandardModifierTagSet } from './details/StandardModifierTagSet';
+export { ModifierTagSet } from './details/ModifierTagSet';
+export { PlainTextEmitter } from './emitters/PlainTextEmitter';
+export { StringBuilder, IStringBuilder } from './emitters/StringBuilder';
+export { TSDocEmitter } from './emitters/TSDocEmitter';
+export * from './nodes';
+export { ParserContext } from './parser/ParserContext';
+export { ParserMessage, IParserMessageParameters } from './parser/ParserMessage';
+export { ParserMessageLog } from './parser/ParserMessageLog';
+export { TextRange, ITextLocation } from './parser/TextRange';
+export { Token, TokenKind } from './parser/Token';
+export { TokenSequence, ITokenSequenceParameters } from './parser/TokenSequence';
+export { TSDocMessageId } from './parser/TSDocMessageId';
+export { TSDocParser } from './parser/TSDocParser';
+export { DocNodeTransforms } from './transforms/DocNodeTransforms';
+//# sourceMappingURL=index.d.ts.map

node_modules/@microsoft/tsdoc/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACxG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EACL,6BAA6B,EAC7B,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAE5F,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC"}

node_modules/@microsoft/tsdoc/lib/index.js

@@ -0,0 +1,22 @@
+export { DocNodeManager } from './configuration/DocNodeManager';
+export { TSDocConfiguration } from './configuration/TSDocConfiguration';
+export { TSDocTagSyntaxKind, TSDocTagDefinition } from './configuration/TSDocTagDefinition';
+export { TSDocValidationConfiguration } from './configuration/TSDocValidationConfiguration';
+export { StandardTags } from './details/StandardTags';
+export { Standardization } from './details/Standardization';
+export { StandardModifierTagSet } from './details/StandardModifierTagSet';
+export { ModifierTagSet } from './details/ModifierTagSet';
+export { PlainTextEmitter } from './emitters/PlainTextEmitter';
+export { StringBuilder } from './emitters/StringBuilder';
+export { TSDocEmitter } from './emitters/TSDocEmitter';
+export * from './nodes';
+export { ParserContext } from './parser/ParserContext';
+export { ParserMessage } from './parser/ParserMessage';
+export { ParserMessageLog } from './parser/ParserMessageLog';
+export { TextRange } from './parser/TextRange';
+export { Token, TokenKind } from './parser/Token';
+export { TokenSequence } from './parser/TokenSequence';
+export { TSDocMessageId } from './parser/TSDocMessageId';
+export { TSDocParser } from './parser/TSDocParser';
+export { DocNodeTransforms } from './transforms/DocNodeTransforms';
+//# sourceMappingURL=index.js.map

node_modules/@microsoft/tsdoc/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAA0C,MAAM,gCAAgC,CAAC;AACxG,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,8CAA8C,CAAC;AAE5F,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAkB,MAAM,0BAA0B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAA4B,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAiB,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,aAAa,EAA4B,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC","sourcesContent":["export { DocNodeManager, IDocNodeDefinition, DocNodeConstructor } from './configuration/DocNodeManager';\r\nexport { TSDocConfiguration } from './configuration/TSDocConfiguration';\r\nexport {\r\n  ITSDocTagDefinitionParameters,\r\n  TSDocTagSyntaxKind,\r\n  TSDocTagDefinition\r\n} from './configuration/TSDocTagDefinition';\r\nexport { TSDocValidationConfiguration } from './configuration/TSDocValidationConfiguration';\r\n\r\nexport { StandardTags } from './details/StandardTags';\r\nexport { Standardization } from './details/Standardization';\r\nexport { StandardModifierTagSet } from './details/StandardModifierTagSet';\r\nexport { ModifierTagSet } from './details/ModifierTagSet';\r\n\r\nexport { PlainTextEmitter } from './emitters/PlainTextEmitter';\r\nexport { StringBuilder, IStringBuilder } from './emitters/StringBuilder';\r\nexport { TSDocEmitter } from './emitters/TSDocEmitter';\r\n\r\nexport * from './nodes';\r\n\r\nexport { ParserContext } from './parser/ParserContext';\r\nexport { ParserMessage, IParserMessageParameters } from './parser/ParserMessage';\r\nexport { ParserMessageLog } from './parser/ParserMessageLog';\r\nexport { TextRange, ITextLocation } from './parser/TextRange';\r\nexport { Token, TokenKind } from './parser/Token';\r\nexport { TokenSequence, ITokenSequenceParameters } from './parser/TokenSequence';\r\nexport { TSDocMessageId } from './parser/TSDocMessageId';\r\nexport { TSDocParser } from './parser/TSDocParser';\r\n\r\nexport { DocNodeTransforms } from './transforms/DocNodeTransforms';\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/BuiltInDocNodes.d.ts

@@ -0,0 +1,5 @@
+import { TSDocConfiguration } from '../configuration/TSDocConfiguration';
+export declare class BuiltInDocNodes {
+    static register(configuration: TSDocConfiguration): void;
+}
+//# sourceMappingURL=BuiltInDocNodes.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/BuiltInDocNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuiltInDocNodes.d.ts","sourceRoot":"","sources":["../../src/nodes/BuiltInDocNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAKzE,qBAAa,eAAe;WACZ,QAAQ,CAAC,aAAa,EAAE,kBAAkB,GAAG,IAAI;CAmDhE"}

node_modules/@microsoft/tsdoc/lib/nodes/BuiltInDocNodes.js

@@ -0,0 +1,57 @@
+import { DocNodeKind } from './DocNode';
+import * as nodes from '..';
+var BuiltInDocNodes = /** @class */ (function () {
+    function BuiltInDocNodes() {
+    }
+    BuiltInDocNodes.register = function (configuration) {
+        var docNodeManager = configuration.docNodeManager;
+        docNodeManager.registerDocNodes('@microsoft/tsdoc', [
+            { docNodeKind: DocNodeKind.Block, constructor: nodes.DocBlock },
+            { docNodeKind: DocNodeKind.BlockTag, constructor: nodes.DocBlockTag },
+            { docNodeKind: DocNodeKind.CodeSpan, constructor: nodes.DocCodeSpan },
+            { docNodeKind: DocNodeKind.Comment, constructor: nodes.DocComment },
+            { docNodeKind: DocNodeKind.DeclarationReference, constructor: nodes.DocDeclarationReference },
+            { docNodeKind: DocNodeKind.ErrorText, constructor: nodes.DocErrorText },
+            { docNodeKind: DocNodeKind.EscapedText, constructor: nodes.DocEscapedText },
+            { docNodeKind: DocNodeKind.Excerpt, constructor: nodes.DocExcerpt },
+            { docNodeKind: DocNodeKind.FencedCode, constructor: nodes.DocFencedCode },
+            { docNodeKind: DocNodeKind.HtmlAttribute, constructor: nodes.DocHtmlAttribute },
+            { docNodeKind: DocNodeKind.HtmlEndTag, constructor: nodes.DocHtmlEndTag },
+            { docNodeKind: DocNodeKind.HtmlStartTag, constructor: nodes.DocHtmlStartTag },
+            { docNodeKind: DocNodeKind.InheritDocTag, constructor: nodes.DocInheritDocTag },
+            { docNodeKind: DocNodeKind.InlineTag, constructor: nodes.DocInlineTag },
+            { docNodeKind: DocNodeKind.LinkTag, constructor: nodes.DocLinkTag },
+            { docNodeKind: DocNodeKind.MemberIdentifier, constructor: nodes.DocMemberIdentifier },
+            { docNodeKind: DocNodeKind.MemberReference, constructor: nodes.DocMemberReference },
+            { docNodeKind: DocNodeKind.MemberSelector, constructor: nodes.DocMemberSelector },
+            { docNodeKind: DocNodeKind.MemberSymbol, constructor: nodes.DocMemberSymbol },
+            { docNodeKind: DocNodeKind.Paragraph, constructor: nodes.DocParagraph },
+            { docNodeKind: DocNodeKind.ParamBlock, constructor: nodes.DocParamBlock },
+            { docNodeKind: DocNodeKind.ParamCollection, constructor: nodes.DocParamCollection },
+            { docNodeKind: DocNodeKind.PlainText, constructor: nodes.DocPlainText },
+            { docNodeKind: DocNodeKind.Section, constructor: nodes.DocSection },
+            { docNodeKind: DocNodeKind.SoftBreak, constructor: nodes.DocSoftBreak }
+        ]);
+        docNodeManager.registerAllowableChildren(DocNodeKind.Section, [
+            DocNodeKind.FencedCode,
+            DocNodeKind.Paragraph,
+            DocNodeKind.HtmlStartTag,
+            DocNodeKind.HtmlEndTag
+        ]);
+        docNodeManager.registerAllowableChildren(DocNodeKind.Paragraph, [
+            DocNodeKind.BlockTag,
+            DocNodeKind.CodeSpan,
+            DocNodeKind.ErrorText,
+            DocNodeKind.EscapedText,
+            DocNodeKind.HtmlStartTag,
+            DocNodeKind.HtmlEndTag,
+            DocNodeKind.InlineTag,
+            DocNodeKind.LinkTag,
+            DocNodeKind.PlainText,
+            DocNodeKind.SoftBreak
+        ]);
+    };
+    return BuiltInDocNodes;
+}());
+export { BuiltInDocNodes };
+//# sourceMappingURL=BuiltInDocNodes.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocBlock.d.ts

@@ -0,0 +1,41 @@
+import { DocNodeKind, DocNode, IDocNodeParameters, IDocNodeParsedParameters } from './DocNode';
+import { DocSection } from './DocSection';
+import { DocBlockTag } from './DocBlockTag';
+/**
+ * Constructor parameters for {@link DocBlock}.
+ */
+export interface IDocBlockParameters extends IDocNodeParameters {
+    blockTag: DocBlockTag;
+}
+/**
+ * Constructor parameters for {@link DocBlock}.
+ */
+export interface IDocBlockParsedParameters extends IDocNodeParsedParameters {
+    blockTag: DocBlockTag;
+}
+/**
+ * Represents a section that is introduced by a TSDoc block tag.
+ * For example, an `@example` block.
+ */
+export declare class DocBlock extends DocNode {
+    private readonly _blockTag;
+    private readonly _content;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocBlockParameters | IDocBlockParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The TSDoc tag that introduces this section.
+     */
+    get blockTag(): DocBlockTag;
+    /**
+     * The TSDoc tag that introduces this section.
+     */
+    get content(): DocSection;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+}
+//# sourceMappingURL=DocBlock.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocBlock.d.ts","sourceRoot":"","sources":["../../src/nodes/DocBlock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,WAAW,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,wBAAwB;IACzE,QAAQ,EAAE,WAAW,CAAC;CACvB;AAED;;;GAGG;AACH,qBAAa,QAAS,SAAQ,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAa;IAEtC;;;OAGG;gBACgB,UAAU,EAAE,mBAAmB,GAAG,yBAAyB;IAM9E,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;OAEG;IACH,IAAW,QAAQ,IAAI,WAAW,CAEjC;IAED;;OAEG;IACH,IAAW,OAAO,IAAI,UAAU,CAE/B;IAED,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;CAGhE"}

node_modules/@microsoft/tsdoc/lib/nodes/DocBlock.js

@@ -0,0 +1,67 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { DocNodeKind, DocNode } from './DocNode';
+import { DocSection } from './DocSection';
+/**
+ * Represents a section that is introduced by a TSDoc block tag.
+ * For example, an `@example` block.
+ */
+var DocBlock = /** @class */ (function (_super) {
+    __extends(DocBlock, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocBlock(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        _this._blockTag = parameters.blockTag;
+        _this._content = new DocSection({ configuration: _this.configuration });
+        return _this;
+    }
+    Object.defineProperty(DocBlock.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.Block;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocBlock.prototype, "blockTag", {
+        /**
+         * The TSDoc tag that introduces this section.
+         */
+        get: function () {
+            return this._blockTag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocBlock.prototype, "content", {
+        /**
+         * The TSDoc tag that introduces this section.
+         */
+        get: function () {
+            return this._content;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @override */
+    DocBlock.prototype.onGetChildNodes = function () {
+        return [this.blockTag, this._content];
+    };
+    return DocBlock;
+}(DocNode));
+export { DocBlock };
+//# sourceMappingURL=DocBlock.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocBlock.js","sourceRoot":"","sources":["../../src/nodes/DocBlock.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAgD,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAiB1C;;;GAGG;AACH;IAA8B,4BAAO;IAInC;;;OAGG;IACH,kBAAmB,UAA2D;QAA9E,YACE,kBAAM,UAAU,CAAC,SAGlB;QAFC,KAAI,CAAC,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC;QACrC,KAAI,CAAC,QAAQ,GAAG,IAAI,UAAU,CAAC,EAAE,aAAa,EAAE,KAAI,CAAC,aAAa,EAAE,CAAC,CAAC;;IACxE,CAAC;IAGD,sBAAW,0BAAI;QADf,gBAAgB;aAChB;YACE,OAAO,WAAW,CAAC,KAAK,CAAC;QAC3B,CAAC;;;OAAA;IAKD,sBAAW,8BAAQ;QAHnB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;;;OAAA;IAKD,sBAAW,6BAAO;QAHlB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;;;OAAA;IAED,gBAAgB;IACN,kCAAe,GAAzB;QACE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxC,CAAC;IACH,eAAC;AAAD,CAAC,AArCD,CAA8B,OAAO,GAqCpC","sourcesContent":["import { DocNodeKind, DocNode, IDocNodeParameters, IDocNodeParsedParameters } from './DocNode';\r\nimport { DocSection } from './DocSection';\r\nimport { DocBlockTag } from './DocBlockTag';\r\n\r\n/**\r\n * Constructor parameters for {@link DocBlock}.\r\n */\r\nexport interface IDocBlockParameters extends IDocNodeParameters {\r\n  blockTag: DocBlockTag;\r\n}\r\n\r\n/**\r\n * Constructor parameters for {@link DocBlock}.\r\n */\r\nexport interface IDocBlockParsedParameters extends IDocNodeParsedParameters {\r\n  blockTag: DocBlockTag;\r\n}\r\n\r\n/**\r\n * Represents a section that is introduced by a TSDoc block tag.\r\n * For example, an `@example` block.\r\n */\r\nexport class DocBlock extends DocNode {\r\n  private readonly _blockTag: DocBlockTag;\r\n  private readonly _content: DocSection;\r\n\r\n  /**\r\n   * Don't call this directly.  Instead use {@link TSDocParser}\r\n   * @internal\r\n   */\r\n  public constructor(parameters: IDocBlockParameters | IDocBlockParsedParameters) {\r\n    super(parameters);\r\n    this._blockTag = parameters.blockTag;\r\n    this._content = new DocSection({ configuration: this.configuration });\r\n  }\r\n\r\n  /** @override */\r\n  public get kind(): DocNodeKind | string {\r\n    return DocNodeKind.Block;\r\n  }\r\n\r\n  /**\r\n   * The TSDoc tag that introduces this section.\r\n   */\r\n  public get blockTag(): DocBlockTag {\r\n    return this._blockTag;\r\n  }\r\n\r\n  /**\r\n   * The TSDoc tag that introduces this section.\r\n   */\r\n  public get content(): DocSection {\r\n    return this._content;\r\n  }\r\n\r\n  /** @override */\r\n  protected onGetChildNodes(): ReadonlyArray<DocNode | undefined> {\r\n    return [this.blockTag, this._content];\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/DocBlockTag.d.ts

@@ -0,0 +1,44 @@
+import { DocNodeKind, DocNode, IDocNodeParameters, IDocNodeParsedParameters } from './DocNode';
+import { TokenSequence } from '../parser/TokenSequence';
+/**
+ * Constructor parameters for {@link DocBlockTag}.
+ */
+export interface IDocBlockTagParameters extends IDocNodeParameters {
+    tagName: string;
+}
+/**
+ * Constructor parameters for {@link DocBlockTag}.
+ */
+export interface IDocBlockTagParsedParameters extends IDocNodeParsedParameters {
+    tagName: string;
+    tagNameExcerpt: TokenSequence;
+}
+/**
+ * Represents a TSDoc block tag such as `@param` or `@public`.
+ */
+export declare class DocBlockTag extends DocNode {
+    private readonly _tagName;
+    private readonly _tagNameWithUpperCase;
+    private readonly _tagNameExcerpt;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocBlockTagParameters | IDocBlockTagParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The TSDoc tag name.  TSDoc tag names start with an at-sign (`@`) followed
+     * by ASCII letters using "camelCase" capitalization.
+     */
+    get tagName(): string;
+    /**
+     * The TSDoc tag name in all capitals, which is used for performing
+     * case-insensitive comparisons or lookups.
+     */
+    get tagNameWithUpperCase(): string;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+    getTokenSequence(): TokenSequence;
+}
+//# sourceMappingURL=DocBlockTag.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocBlockTag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocBlockTag.d.ts","sourceRoot":"","sources":["../../src/nodes/DocBlockTag.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAE/F,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,wBAAwB;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,aAAa,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,OAAO;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAyB;IAEzD;;;OAGG;gBACgB,UAAU,EAAE,sBAAsB,GAAG,4BAA4B;IAgBpF,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;;OAGG;IACH,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED;;;OAGG;IACH,IAAW,oBAAoB,IAAI,MAAM,CAExC;IAED,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;IAIxD,gBAAgB,IAAI,aAAa;CAQzC"}

node_modules/@microsoft/tsdoc/lib/nodes/DocBlockTag.js

@@ -0,0 +1,83 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { DocNodeKind, DocNode } from './DocNode';
+import { StringChecks } from '../parser/StringChecks';
+import { DocExcerpt, ExcerptKind } from './DocExcerpt';
+/**
+ * Represents a TSDoc block tag such as `@param` or `@public`.
+ */
+var DocBlockTag = /** @class */ (function (_super) {
+    __extends(DocBlockTag, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocBlockTag(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        StringChecks.validateTSDocTagName(parameters.tagName);
+        _this._tagName = parameters.tagName;
+        _this._tagNameWithUpperCase = parameters.tagName.toUpperCase();
+        if (DocNode.isParsedParameters(parameters)) {
+            _this._tagNameExcerpt = new DocExcerpt({
+                configuration: _this.configuration,
+                excerptKind: ExcerptKind.BlockTag,
+                content: parameters.tagNameExcerpt
+            });
+        }
+        return _this;
+    }
+    Object.defineProperty(DocBlockTag.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.BlockTag;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocBlockTag.prototype, "tagName", {
+        /**
+         * The TSDoc tag name.  TSDoc tag names start with an at-sign (`@`) followed
+         * by ASCII letters using "camelCase" capitalization.
+         */
+        get: function () {
+            return this._tagName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocBlockTag.prototype, "tagNameWithUpperCase", {
+        /**
+         * The TSDoc tag name in all capitals, which is used for performing
+         * case-insensitive comparisons or lookups.
+         */
+        get: function () {
+            return this._tagNameWithUpperCase;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @override */
+    DocBlockTag.prototype.onGetChildNodes = function () {
+        return [this._tagNameExcerpt];
+    };
+    DocBlockTag.prototype.getTokenSequence = function () {
+        if (!this._tagNameExcerpt) {
+            throw new Error('DocBlockTag.getTokenSequence() failed because this object did not originate from a parsed input');
+        }
+        return this._tagNameExcerpt.content;
+    };
+    return DocBlockTag;
+}(DocNode));
+export { DocBlockTag };
+//# sourceMappingURL=DocBlockTag.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocBlockTag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocBlockTag.js","sourceRoot":"","sources":["../../src/nodes/DocBlockTag.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAgD,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAiBvD;;GAEG;AACH;IAAiC,+BAAO;IAKtC;;;OAGG;IACH,qBAAmB,UAAiE;QAApF,YACE,kBAAM,UAAU,CAAC,SAalB;QAXC,YAAY,CAAC,oBAAoB,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACtD,KAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC;QACnC,KAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QAE9D,IAAI,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE;YAC1C,KAAI,CAAC,eAAe,GAAG,IAAI,UAAU,CAAC;gBACpC,aAAa,EAAE,KAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,WAAW,CAAC,QAAQ;gBACjC,OAAO,EAAE,UAAU,CAAC,cAAc;aACnC,CAAC,CAAC;SACJ;;IACH,CAAC;IAGD,sBAAW,6BAAI;QADf,gBAAgB;aAChB;YACE,OAAO,WAAW,CAAC,QAAQ,CAAC;QAC9B,CAAC;;;OAAA;IAMD,sBAAW,gCAAO;QAJlB;;;WAGG;aACH;YACE,OAAO,IAAI,CAAC,QAAQ,CAAC;QACvB,CAAC;;;OAAA;IAMD,sBAAW,6CAAoB;QAJ/B;;;WAGG;aACH;YACE,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACpC,CAAC;;;OAAA;IAED,gBAAgB;IACN,qCAAe,GAAzB;QACE,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAChC,CAAC;IAEM,sCAAgB,GAAvB;QACE,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE;YACzB,MAAM,IAAI,KAAK,CACb,iGAAiG,CAClG,CAAC;SACH;QACD,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;IACtC,CAAC;IACH,kBAAC;AAAD,CAAC,AA3DD,CAAiC,OAAO,GA2DvC","sourcesContent":["import { DocNodeKind, DocNode, IDocNodeParameters, IDocNodeParsedParameters } from './DocNode';\r\nimport { StringChecks } from '../parser/StringChecks';\r\nimport { TokenSequence } from '../parser/TokenSequence';\r\nimport { DocExcerpt, ExcerptKind } from './DocExcerpt';\r\n\r\n/**\r\n * Constructor parameters for {@link DocBlockTag}.\r\n */\r\nexport interface IDocBlockTagParameters extends IDocNodeParameters {\r\n  tagName: string;\r\n}\r\n\r\n/**\r\n * Constructor parameters for {@link DocBlockTag}.\r\n */\r\nexport interface IDocBlockTagParsedParameters extends IDocNodeParsedParameters {\r\n  tagName: string;\r\n  tagNameExcerpt: TokenSequence;\r\n}\r\n\r\n/**\r\n * Represents a TSDoc block tag such as `@param` or `@public`.\r\n */\r\nexport class DocBlockTag extends DocNode {\r\n  private readonly _tagName: string;\r\n  private readonly _tagNameWithUpperCase: string;\r\n  private readonly _tagNameExcerpt: DocExcerpt | undefined;\r\n\r\n  /**\r\n   * Don't call this directly.  Instead use {@link TSDocParser}\r\n   * @internal\r\n   */\r\n  public constructor(parameters: IDocBlockTagParameters | IDocBlockTagParsedParameters) {\r\n    super(parameters);\r\n\r\n    StringChecks.validateTSDocTagName(parameters.tagName);\r\n    this._tagName = parameters.tagName;\r\n    this._tagNameWithUpperCase = parameters.tagName.toUpperCase();\r\n\r\n    if (DocNode.isParsedParameters(parameters)) {\r\n      this._tagNameExcerpt = new DocExcerpt({\r\n        configuration: this.configuration,\r\n        excerptKind: ExcerptKind.BlockTag,\r\n        content: parameters.tagNameExcerpt\r\n      });\r\n    }\r\n  }\r\n\r\n  /** @override */\r\n  public get kind(): DocNodeKind | string {\r\n    return DocNodeKind.BlockTag;\r\n  }\r\n\r\n  /**\r\n   * The TSDoc tag name.  TSDoc tag names start with an at-sign (`@`) followed\r\n   * by ASCII letters using \"camelCase\" capitalization.\r\n   */\r\n  public get tagName(): string {\r\n    return this._tagName;\r\n  }\r\n\r\n  /**\r\n   * The TSDoc tag name in all capitals, which is used for performing\r\n   * case-insensitive comparisons or lookups.\r\n   */\r\n  public get tagNameWithUpperCase(): string {\r\n    return this._tagNameWithUpperCase;\r\n  }\r\n\r\n  /** @override */\r\n  protected onGetChildNodes(): ReadonlyArray<DocNode | undefined> {\r\n    return [this._tagNameExcerpt];\r\n  }\r\n\r\n  public getTokenSequence(): TokenSequence {\r\n    if (!this._tagNameExcerpt) {\r\n      throw new Error(\r\n        'DocBlockTag.getTokenSequence() failed because this object did not originate from a parsed input'\r\n      );\r\n    }\r\n    return this._tagNameExcerpt.content;\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/DocCodeSpan.d.ts

@@ -0,0 +1,40 @@
+import { DocNodeKind, IDocNodeParameters, DocNode, IDocNodeParsedParameters } from './DocNode';
+import { TokenSequence } from '../parser/TokenSequence';
+/**
+ * Constructor parameters for {@link DocCodeSpan}.
+ */
+export interface IDocCodeSpanParameters extends IDocNodeParameters {
+    code: string;
+}
+/**
+ * Constructor parameters for {@link DocCodeSpan}.
+ */
+export interface IDocCodeSpanParsedParameters extends IDocNodeParsedParameters {
+    openingDelimiterExcerpt: TokenSequence;
+    codeExcerpt: TokenSequence;
+    closingDelimiterExcerpt: TokenSequence;
+}
+/**
+ * Represents CommonMark-style code span, i.e. code surrounded by
+ * backtick characters.
+ */
+export declare class DocCodeSpan extends DocNode {
+    private readonly _openingDelimiterExcerpt;
+    private _code;
+    private readonly _codeExcerpt;
+    private readonly _closingDelimiterExcerpt;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocCodeSpanParameters | IDocCodeSpanParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The text that should be rendered as code, excluding the backtick delimiters.
+     */
+    get code(): string;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+}
+//# sourceMappingURL=DocCodeSpan.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocCodeSpan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocCodeSpan.d.ts","sourceRoot":"","sources":["../../src/nodes/DocCodeSpan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAGxD;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAChE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,4BAA6B,SAAQ,wBAAwB;IAC5E,uBAAuB,EAAE,aAAa,CAAC;IAEvC,WAAW,EAAE,aAAa,CAAC;IAE3B,uBAAuB,EAAE,aAAa,CAAC;CACxC;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,OAAO;IAEtC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAyB;IAGlE,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAyB;IAGtD,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAyB;IAElE;;;OAGG;gBACgB,UAAU,EAAE,sBAAsB,GAAG,4BAA4B;IAwBpF,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAKxB;IAED,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;CAGhE"}

node_modules/@microsoft/tsdoc/lib/nodes/DocCodeSpan.js

@@ -0,0 +1,78 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { DocNodeKind, DocNode } from './DocNode';
+import { DocExcerpt, ExcerptKind } from './DocExcerpt';
+/**
+ * Represents CommonMark-style code span, i.e. code surrounded by
+ * backtick characters.
+ */
+var DocCodeSpan = /** @class */ (function (_super) {
+    __extends(DocCodeSpan, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocCodeSpan(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        if (DocNode.isParsedParameters(parameters)) {
+            _this._openingDelimiterExcerpt = new DocExcerpt({
+                configuration: _this.configuration,
+                excerptKind: ExcerptKind.CodeSpan_OpeningDelimiter,
+                content: parameters.openingDelimiterExcerpt
+            });
+            _this._codeExcerpt = new DocExcerpt({
+                configuration: _this.configuration,
+                excerptKind: ExcerptKind.CodeSpan_Code,
+                content: parameters.codeExcerpt
+            });
+            _this._closingDelimiterExcerpt = new DocExcerpt({
+                configuration: _this.configuration,
+                excerptKind: ExcerptKind.CodeSpan_ClosingDelimiter,
+                content: parameters.closingDelimiterExcerpt
+            });
+        }
+        else {
+            _this._code = parameters.code;
+        }
+        return _this;
+    }
+    Object.defineProperty(DocCodeSpan.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.CodeSpan;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocCodeSpan.prototype, "code", {
+        /**
+         * The text that should be rendered as code, excluding the backtick delimiters.
+         */
+        get: function () {
+            if (this._code === undefined) {
+                this._code = this._codeExcerpt.content.toString();
+            }
+            return this._code;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @override */
+    DocCodeSpan.prototype.onGetChildNodes = function () {
+        return [this._openingDelimiterExcerpt, this._codeExcerpt, this._closingDelimiterExcerpt];
+    };
+    return DocCodeSpan;
+}(DocNode));
+export { DocCodeSpan };
+//# sourceMappingURL=DocCodeSpan.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocCodeSpan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocCodeSpan.js","sourceRoot":"","sources":["../../src/nodes/DocCodeSpan.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAsB,OAAO,EAA4B,MAAM,WAAW,CAAC;AAE/F,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAoBvD;;;GAGG;AACH;IAAiC,+BAAO;IAWtC;;;OAGG;IACH,qBAAmB,UAAiE;QAApF,YACE,kBAAM,UAAU,CAAC,SAqBlB;QAnBC,IAAI,OAAO,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE;YAC1C,KAAI,CAAC,wBAAwB,GAAG,IAAI,UAAU,CAAC;gBAC7C,aAAa,EAAE,KAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,WAAW,CAAC,yBAAyB;gBAClD,OAAO,EAAE,UAAU,CAAC,uBAAuB;aAC5C,CAAC,CAAC;YACH,KAAI,CAAC,YAAY,GAAG,IAAI,UAAU,CAAC;gBACjC,aAAa,EAAE,KAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,WAAW,CAAC,aAAa;gBACtC,OAAO,EAAE,UAAU,CAAC,WAAW;aAChC,CAAC,CAAC;YACH,KAAI,CAAC,wBAAwB,GAAG,IAAI,UAAU,CAAC;gBAC7C,aAAa,EAAE,KAAI,CAAC,aAAa;gBACjC,WAAW,EAAE,WAAW,CAAC,yBAAyB;gBAClD,OAAO,EAAE,UAAU,CAAC,uBAAuB;aAC5C,CAAC,CAAC;SACJ;aAAM;YACL,KAAI,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC;SAC9B;;IACH,CAAC;IAGD,sBAAW,6BAAI;QADf,gBAAgB;aAChB;YACE,OAAO,WAAW,CAAC,QAAQ,CAAC;QAC9B,CAAC;;;OAAA;IAKD,sBAAW,6BAAI;QAHf;;WAEG;aACH;YACE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;gBAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAa,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;aACpD;YACD,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;;;OAAA;IAED,gBAAgB;IACN,qCAAe,GAAzB;QACE,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAC3F,CAAC;IACH,kBAAC;AAAD,CAAC,AA1DD,CAAiC,OAAO,GA0DvC","sourcesContent":["import { DocNodeKind, IDocNodeParameters, DocNode, IDocNodeParsedParameters } from './DocNode';\r\nimport { TokenSequence } from '../parser/TokenSequence';\r\nimport { DocExcerpt, ExcerptKind } from './DocExcerpt';\r\n\r\n/**\r\n * Constructor parameters for {@link DocCodeSpan}.\r\n */\r\nexport interface IDocCodeSpanParameters extends IDocNodeParameters {\r\n  code: string;\r\n}\r\n\r\n/**\r\n * Constructor parameters for {@link DocCodeSpan}.\r\n */\r\nexport interface IDocCodeSpanParsedParameters extends IDocNodeParsedParameters {\r\n  openingDelimiterExcerpt: TokenSequence;\r\n\r\n  codeExcerpt: TokenSequence;\r\n\r\n  closingDelimiterExcerpt: TokenSequence;\r\n}\r\n\r\n/**\r\n * Represents CommonMark-style code span, i.e. code surrounded by\r\n * backtick characters.\r\n */\r\nexport class DocCodeSpan extends DocNode {\r\n  // The opening ` delimiter\r\n  private readonly _openingDelimiterExcerpt: DocExcerpt | undefined;\r\n\r\n  // The code content\r\n  private _code: string | undefined;\r\n  private readonly _codeExcerpt: DocExcerpt | undefined;\r\n\r\n  // The closing ` delimiter\r\n  private readonly _closingDelimiterExcerpt: DocExcerpt | undefined;\r\n\r\n  /**\r\n   * Don't call this directly.  Instead use {@link TSDocParser}\r\n   * @internal\r\n   */\r\n  public constructor(parameters: IDocCodeSpanParameters | IDocCodeSpanParsedParameters) {\r\n    super(parameters);\r\n\r\n    if (DocNode.isParsedParameters(parameters)) {\r\n      this._openingDelimiterExcerpt = new DocExcerpt({\r\n        configuration: this.configuration,\r\n        excerptKind: ExcerptKind.CodeSpan_OpeningDelimiter,\r\n        content: parameters.openingDelimiterExcerpt\r\n      });\r\n      this._codeExcerpt = new DocExcerpt({\r\n        configuration: this.configuration,\r\n        excerptKind: ExcerptKind.CodeSpan_Code,\r\n        content: parameters.codeExcerpt\r\n      });\r\n      this._closingDelimiterExcerpt = new DocExcerpt({\r\n        configuration: this.configuration,\r\n        excerptKind: ExcerptKind.CodeSpan_ClosingDelimiter,\r\n        content: parameters.closingDelimiterExcerpt\r\n      });\r\n    } else {\r\n      this._code = parameters.code;\r\n    }\r\n  }\r\n\r\n  /** @override */\r\n  public get kind(): DocNodeKind | string {\r\n    return DocNodeKind.CodeSpan;\r\n  }\r\n\r\n  /**\r\n   * The text that should be rendered as code, excluding the backtick delimiters.\r\n   */\r\n  public get code(): string {\r\n    if (this._code === undefined) {\r\n      this._code = this._codeExcerpt!.content.toString();\r\n    }\r\n    return this._code;\r\n  }\r\n\r\n  /** @override */\r\n  protected onGetChildNodes(): ReadonlyArray<DocNode | undefined> {\r\n    return [this._openingDelimiterExcerpt, this._codeExcerpt, this._closingDelimiterExcerpt];\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/DocComment.d.ts

@@ -0,0 +1,120 @@
+import { DocNode, DocNodeKind, IDocNodeParameters } from './DocNode';
+import { DocSection } from './DocSection';
+import { StandardModifierTagSet } from '../details/StandardModifierTagSet';
+import { DocBlock } from './DocBlock';
+import { DocInheritDocTag } from './DocInheritDocTag';
+import { DocParamCollection } from './DocParamCollection';
+/**
+ * Constructor parameters for {@link DocComment}.
+ */
+export interface IDocCommentParameters extends IDocNodeParameters {
+}
+/**
+ * Represents an entire documentation comment conforming to the TSDoc structure.
+ * This is the root of the DocNode tree.
+ */
+export declare class DocComment extends DocNode {
+    /**
+     * The main documentation for an API item is separated into a brief "summary" section,
+     * optionally followed by an `@remarks` block containing additional details.
+     *
+     * @remarks
+     * The summary section should be brief. On a documentation web site, it will be shown
+     * on a page that lists summaries for many different API items.  On a detail page for
+     * a single item, the summary will be shown followed by the remarks section (if any).
+     */
+    summarySection: DocSection;
+    /**
+     * The main documentation for an API item is separated into a brief "summary" section
+     * optionally followed by an `@remarks` block containing additional details.
+     *
+     * @remarks
+     * Unlike the summary, the remarks block may contain lengthy documentation content.
+     * The remarks should not restate information from the summary, since the summary section
+     * will always be displayed wherever the remarks section appears.  Other sections
+     * (e.g. an `@example` block) will be shown after the remarks section.
+     */
+    remarksBlock: DocBlock | undefined;
+    /**
+     * The `@privateRemarks` tag starts a block of additional commentary that is not meant
+     * for an external audience.  A documentation tool must omit this content from an
+     * API reference web site.  It should also be omitted when generating a normalized
+     * *.d.ts file intended for third-party developers.
+     *
+     * @remarks
+     * A similar effect could be accomplished by enclosing content inside CommonMark
+     * `<!-- -->` comments, or by moving the content into a separate `//` TypeScript comment.
+     * However, the `@privateRemarks` tag is a more formal convention.
+     */
+    privateRemarks: DocBlock | undefined;
+    /**
+     * If present, this block indicates that an API item is no loner supported and may be
+     * removed in a future release.  The `@deprecated` tag must be followed by a sentence
+     * describing the recommended alternative.  Deprecation recursively applies to members
+     * of a container.  For example, if a class is deprecated, then so are all of its members.
+     */
+    deprecatedBlock: DocBlock | undefined;
+    /**
+     * The collection of parsed `@param` blocks for this doc comment.
+     */
+    readonly params: DocParamCollection;
+    /**
+     * The collection of parsed `@typeParam` blocks for this doc comment.
+     */
+    readonly typeParams: DocParamCollection;
+    /**
+     * The `@returns` block for this doc comment, or undefined if there is not one.
+     */
+    returnsBlock: DocBlock | undefined;
+    /**
+     * If this doc comment contains an `@inheritDoc` tag, it will be extracted and associated
+     * with the DocComment.
+     */
+    inheritDocTag: DocInheritDocTag | undefined;
+    /**
+     * The modifier tags for this DocComment.
+     */
+    readonly modifierTagSet: StandardModifierTagSet;
+    private _seeBlocks;
+    private _customBlocks;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocCommentParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The collection of all `@see` DockBlockTag nodes belonging to this doc comment.
+     */
+    get seeBlocks(): ReadonlyArray<DocBlock>;
+    /**
+     * The collection of all DocBlock nodes belonging to this doc comment.
+     */
+    get customBlocks(): ReadonlyArray<DocBlock>;
+    /**
+     * Append an item to the seeBlocks collection.
+     * @internal
+     */
+    _appendSeeBlock(block: DocBlock): void;
+    /**
+     * Append an item to the customBlocks collection.
+     */
+    appendCustomBlock(block: DocBlock): void;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+    /**
+     * Generates a doc comment corresponding to the `DocComment` tree.  The output is in a normalized form,
+     * and may ignore formatting/spacing from the original input.
+     *
+     * @remarks
+     * After parsing a string, and possibly modifying the result, `emitAsTsdoc()` can be used to render the result
+     * as a doc comment in a normalized format.  It can also be used to emit a `DocComment` tree that was constructed
+     * manually.
+     *
+     * This method is provided as convenience for simple use cases.  To customize the output, or if you need
+     * to render into a `StringBuilder`, use the {@link TSDocEmitter} class instead.
+     */
+    emitAsTsdoc(): string;
+}
+//# sourceMappingURL=DocComment.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocComment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocComment.d.ts","sourceRoot":"","sources":["../../src/nodes/DocComment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,kBAAkB;CAAG;AAEpE;;;GAGG;AACH,qBAAa,UAAW,SAAQ,OAAO;IACrC;;;;;;;;OAQG;IACI,cAAc,EAAE,UAAU,CAAC;IAElC;;;;;;;;;OASG;IACI,YAAY,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE1C;;;;;;;;;;OAUG;IACI,cAAc,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE5C;;;;;OAKG;IACI,eAAe,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE7C;;OAEG;IACH,SAAgB,MAAM,EAAE,kBAAkB,CAAC;IAE3C;;OAEG;IACH,SAAgB,UAAU,EAAE,kBAAkB,CAAC;IAE/C;;OAEG;IACI,YAAY,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE1C;;;OAGG;IACI,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAEnD;;OAEG;IACH,SAAgB,cAAc,EAAE,sBAAsB,CAAC;IAEvD,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,aAAa,CAAa;IAElC;;;OAGG;gBACgB,UAAU,EAAE,qBAAqB;IAiBpD,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,aAAa,CAAC,QAAQ,CAAC,CAE9C;IAED;;OAEG;IACH,IAAW,YAAY,IAAI,aAAa,CAAC,QAAQ,CAAC,CAEjD;IAED;;;OAGG;IACI,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI7C;;OAEG;IACI,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/C,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;IAgB/D;;;;;;;;;;;OAWG;IACI,WAAW,IAAI,MAAM;CAM7B"}

node_modules/@microsoft/tsdoc/lib/nodes/DocComment.js

@@ -0,0 +1,127 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import { DocNode, DocNodeKind } from './DocNode';
+import { DocSection } from './DocSection';
+import { StandardModifierTagSet } from '../details/StandardModifierTagSet';
+import { StringBuilder } from '../emitters/StringBuilder';
+import { TSDocEmitter } from '../emitters/TSDocEmitter';
+import { DocParamCollection } from './DocParamCollection';
+/**
+ * Represents an entire documentation comment conforming to the TSDoc structure.
+ * This is the root of the DocNode tree.
+ */
+var DocComment = /** @class */ (function (_super) {
+    __extends(DocComment, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocComment(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        _this.summarySection = new DocSection({ configuration: _this.configuration });
+        _this.remarksBlock = undefined;
+        _this.privateRemarks = undefined;
+        _this.deprecatedBlock = undefined;
+        _this.params = new DocParamCollection({ configuration: _this.configuration });
+        _this.typeParams = new DocParamCollection({ configuration: _this.configuration });
+        _this.returnsBlock = undefined;
+        _this.modifierTagSet = new StandardModifierTagSet();
+        _this._seeBlocks = [];
+        _this._customBlocks = [];
+        return _this;
+    }
+    Object.defineProperty(DocComment.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.Comment;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocComment.prototype, "seeBlocks", {
+        /**
+         * The collection of all `@see` DockBlockTag nodes belonging to this doc comment.
+         */
+        get: function () {
+            return this._seeBlocks;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocComment.prototype, "customBlocks", {
+        /**
+         * The collection of all DocBlock nodes belonging to this doc comment.
+         */
+        get: function () {
+            return this._customBlocks;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Append an item to the seeBlocks collection.
+     * @internal
+     */
+    DocComment.prototype._appendSeeBlock = function (block) {
+        this._seeBlocks.push(block);
+    };
+    /**
+     * Append an item to the customBlocks collection.
+     */
+    DocComment.prototype.appendCustomBlock = function (block) {
+        this._customBlocks.push(block);
+    };
+    /** @override */
+    DocComment.prototype.onGetChildNodes = function () {
+        return __spreadArrays([
+            this.summarySection,
+            this.remarksBlock,
+            this.privateRemarks,
+            this.deprecatedBlock,
+            this.params.count > 0 ? this.params : undefined,
+            this.typeParams.count > 0 ? this.typeParams : undefined,
+            this.returnsBlock
+        ], this.customBlocks, this.seeBlocks, [
+            this.inheritDocTag
+        ], this.modifierTagSet.nodes);
+    };
+    /**
+     * Generates a doc comment corresponding to the `DocComment` tree.  The output is in a normalized form,
+     * and may ignore formatting/spacing from the original input.
+     *
+     * @remarks
+     * After parsing a string, and possibly modifying the result, `emitAsTsdoc()` can be used to render the result
+     * as a doc comment in a normalized format.  It can also be used to emit a `DocComment` tree that was constructed
+     * manually.
+     *
+     * This method is provided as convenience for simple use cases.  To customize the output, or if you need
+     * to render into a `StringBuilder`, use the {@link TSDocEmitter} class instead.
+     */
+    DocComment.prototype.emitAsTsdoc = function () {
+        var stringBuilder = new StringBuilder();
+        var emitter = new TSDocEmitter();
+        emitter.renderComment(stringBuilder, this);
+        return stringBuilder.toString();
+    };
+    return DocComment;
+}(DocNode));
+export { DocComment };
+//# sourceMappingURL=DocComment.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocDeclarationReference.d.ts

@@ -0,0 +1,73 @@
+import { DocNode, DocNodeKind, IDocNodeParameters, IDocNodeParsedParameters } from './DocNode';
+import { DocMemberReference } from './DocMemberReference';
+import { TokenSequence } from '../parser/TokenSequence';
+/**
+ * Constructor parameters for {@link DocDeclarationReference}.
+ */
+export interface IDocDeclarationReferenceParameters extends IDocNodeParameters {
+    packageName?: string;
+    importPath?: string;
+    memberReferences?: DocMemberReference[];
+}
+/**
+ * Constructor parameters for {@link DocDeclarationReference}.
+ */
+export interface IDocDeclarationReferenceParsedParameters extends IDocNodeParsedParameters {
+    packageNameExcerpt?: TokenSequence;
+    importPathExcerpt?: TokenSequence;
+    importHashExcerpt?: TokenSequence;
+    spacingAfterImportHashExcerpt?: TokenSequence;
+    memberReferences?: DocMemberReference[];
+}
+/**
+ * Represents a declaration reference.
+ *
+ * @remarks
+ * Declaration references are TSDoc expressions used by tags such as `{@link}`
+ * or `{@inheritDoc}` that need to refer to another declaration.
+ */
+export declare class DocDeclarationReference extends DocNode {
+    private _packageName;
+    private readonly _packageNameExcerpt;
+    private _importPath;
+    private readonly _importPathExcerpt;
+    private readonly _importHashExcerpt;
+    private readonly _spacingAfterImportHashExcerpt;
+    private readonly _memberReferences;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocDeclarationReferenceParameters | IDocDeclarationReferenceParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The optional package name, which may optionally include an NPM scope.
+     *
+     * Example: `"@scope/my-package"`
+     */
+    get packageName(): string | undefined;
+    /**
+     * The optional import path.  If a package name is provided, then if an import path is provided,
+     * the path must start with a "/" delimiter; otherwise paths are resolved relative to the source file
+     * containing the reference.
+     *
+     * Example: `"/path1/path2"`
+     * Example: `"./path1/path2"`
+     * Example: `"../path2/path2"`
+     */
+    get importPath(): string | undefined;
+    /**
+     * The chain of member references that indicate the declaration being referenced.
+     * If this list is empty, then either the packageName or importPath must be provided,
+     * because the reference refers to a module.
+     */
+    get memberReferences(): ReadonlyArray<DocMemberReference>;
+    /**
+     * Generates the TSDoc representation of this declaration reference.
+     */
+    emitAsTsdoc(): string;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+}
+//# sourceMappingURL=DocDeclarationReference.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocDeclarationReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocDeclarationReference.d.ts","sourceRoot":"","sources":["../../src/nodes/DocDeclarationReference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAKxD;;GAEG;AACH,MAAM,WAAW,kCAAmC,SAAQ,kBAAkB;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,wCAAyC,SAAQ,wBAAwB;IACxF,kBAAkB,CAAC,EAAE,aAAa,CAAC;IACnC,iBAAiB,CAAC,EAAE,aAAa,CAAC;IAClC,iBAAiB,CAAC,EAAE,aAAa,CAAC;IAClC,6BAA6B,CAAC,EAAE,aAAa,CAAC;IAC9C,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAC;CACzC;AAED;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,OAAO;IAClD,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAyB;IAE7D,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;IAE5D,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAyB;IAC5D,OAAO,CAAC,QAAQ,CAAC,8BAA8B,CAAyB;IAExE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAuB;IAEzD;;;OAGG;gBAED,UAAU,EAAE,kCAAkC,GAAG,wCAAwC;IA4C3F,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;;;OAIG;IACH,IAAW,WAAW,IAAI,MAAM,GAAG,SAAS,CAO3C;IAED;;;;;;;;OAQG;IACH,IAAW,UAAU,IAAI,MAAM,GAAG,SAAS,CAO1C;IAED;;;;OAIG;IACH,IAAW,gBAAgB,IAAI,aAAa,CAAC,kBAAkB,CAAC,CAE/D;IAED;;OAEG;IACI,WAAW,IAAI,MAAM;IAO5B,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;CAShE"}

node_modules/@microsoft/tsdoc/lib/nodes/DocDeclarationReference.js

@@ -0,0 +1,160 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import { DocNode, DocNodeKind } from './DocNode';
+import { DocExcerpt, ExcerptKind } from './DocExcerpt';
+import { StringBuilder } from '../emitters/StringBuilder';
+import { TSDocEmitter } from '../emitters/TSDocEmitter';
+/**
+ * Represents a declaration reference.
+ *
+ * @remarks
+ * Declaration references are TSDoc expressions used by tags such as `{@link}`
+ * or `{@inheritDoc}` that need to refer to another declaration.
+ */
+var DocDeclarationReference = /** @class */ (function (_super) {
+    __extends(DocDeclarationReference, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocDeclarationReference(parameters) {
+        var _a;
+        var _this = _super.call(this, parameters) || this;
+        if (DocNode.isParsedParameters(parameters)) {
+            if (parameters.packageNameExcerpt) {
+                _this._packageNameExcerpt = new DocExcerpt({
+                    configuration: _this.configuration,
+                    excerptKind: ExcerptKind.DeclarationReference_PackageName,
+                    content: parameters.packageNameExcerpt
+                });
+            }
+            if (parameters.importPathExcerpt) {
+                _this._importPathExcerpt = new DocExcerpt({
+                    configuration: _this.configuration,
+                    excerptKind: ExcerptKind.DeclarationReference_ImportPath,
+                    content: parameters.importPathExcerpt
+                });
+            }
+            if (parameters.importHashExcerpt) {
+                _this._importHashExcerpt = new DocExcerpt({
+                    configuration: _this.configuration,
+                    excerptKind: ExcerptKind.DeclarationReference_ImportHash,
+                    content: parameters.importHashExcerpt
+                });
+            }
+            if (parameters.spacingAfterImportHashExcerpt) {
+                _this._spacingAfterImportHashExcerpt = new DocExcerpt({
+                    configuration: _this.configuration,
+                    excerptKind: ExcerptKind.Spacing,
+                    content: parameters.spacingAfterImportHashExcerpt
+                });
+            }
+        }
+        else {
+            _this._packageName = parameters.packageName;
+            _this._importPath = parameters.importPath;
+        }
+        _this._memberReferences = [];
+        if (parameters.memberReferences) {
+            (_a = _this._memberReferences).push.apply(_a, parameters.memberReferences);
+        }
+        return _this;
+    }
+    Object.defineProperty(DocDeclarationReference.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.DeclarationReference;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocDeclarationReference.prototype, "packageName", {
+        /**
+         * The optional package name, which may optionally include an NPM scope.
+         *
+         * Example: `"@scope/my-package"`
+         */
+        get: function () {
+            if (this._packageName === undefined) {
+                if (this._packageNameExcerpt !== undefined) {
+                    this._packageName = this._packageNameExcerpt.content.toString();
+                }
+            }
+            return this._packageName;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocDeclarationReference.prototype, "importPath", {
+        /**
+         * The optional import path.  If a package name is provided, then if an import path is provided,
+         * the path must start with a "/" delimiter; otherwise paths are resolved relative to the source file
+         * containing the reference.
+         *
+         * Example: `"/path1/path2"`
+         * Example: `"./path1/path2"`
+         * Example: `"../path2/path2"`
+         */
+        get: function () {
+            if (this._importPath === undefined) {
+                if (this._importPathExcerpt !== undefined) {
+                    this._importPath = this._importPathExcerpt.content.toString();
+                }
+            }
+            return this._importPath;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocDeclarationReference.prototype, "memberReferences", {
+        /**
+         * The chain of member references that indicate the declaration being referenced.
+         * If this list is empty, then either the packageName or importPath must be provided,
+         * because the reference refers to a module.
+         */
+        get: function () {
+            return this._memberReferences;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Generates the TSDoc representation of this declaration reference.
+     */
+    DocDeclarationReference.prototype.emitAsTsdoc = function () {
+        var stringBuilder = new StringBuilder();
+        var emitter = new TSDocEmitter();
+        emitter.renderDeclarationReference(stringBuilder, this);
+        return stringBuilder.toString();
+    };
+    /** @override */
+    DocDeclarationReference.prototype.onGetChildNodes = function () {
+        return __spreadArrays([
+            this._packageNameExcerpt,
+            this._importPathExcerpt,
+            this._importHashExcerpt,
+            this._spacingAfterImportHashExcerpt
+        ], this._memberReferences);
+    };
+    return DocDeclarationReference;
+}(DocNode));
+export { DocDeclarationReference };
+//# sourceMappingURL=DocDeclarationReference.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocErrorText.d.ts

@@ -0,0 +1,57 @@
+import { DocNodeKind, DocNode, IDocNodeParsedParameters } from './DocNode';
+import { TokenSequence } from '../parser/TokenSequence';
+import { TSDocMessageId } from '../parser/TSDocMessageId';
+/**
+ * Constructor parameters for {@link DocErrorText}.
+ */
+export interface IDocErrorTextParsedParameters extends IDocNodeParsedParameters {
+    textExcerpt: TokenSequence;
+    messageId: TSDocMessageId;
+    errorMessage: string;
+    errorLocation: TokenSequence;
+}
+/**
+ * Represents a span of text that contained invalid markup.
+ * The characters should be rendered as plain text.
+ */
+export declare class DocErrorText extends DocNode {
+    private _text;
+    private readonly _textExcerpt;
+    private readonly _messageId;
+    private readonly _errorMessage;
+    private readonly _errorLocation;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocErrorTextParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The characters that should be rendered as plain text because they
+     * could not be parsed successfully.
+     */
+    get text(): string;
+    get textExcerpt(): TokenSequence | undefined;
+    /**
+     * The TSDoc error message identifier.
+     */
+    get messageId(): TSDocMessageId;
+    /**
+     * A description of why the character could not be parsed.
+     */
+    get errorMessage(): string;
+    /**
+     * The range of characters that caused the error.  In general these may be
+     * somewhat farther ahead in the input stream from the DocErrorText node itself.
+     *
+     * @remarks
+     * For example, for the malformed HTML tag `<a href="123" @ /a>`, the DocErrorText node
+     * will correspond to the `<` character that looked like an HTML tag, whereas the
+     * error location might be the `@` character that caused the trouble.
+     */
+    get errorLocation(): TokenSequence;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+}
+//# sourceMappingURL=DocErrorText.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocErrorText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocErrorText.d.ts","sourceRoot":"","sources":["../../src/nodes/DocErrorText.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,6BAA8B,SAAQ,wBAAwB;IAC7E,WAAW,EAAE,aAAa,CAAC;IAE3B,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,aAAa,CAAC;CAC9B;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAa;IAE1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiB;IAC5C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAgB;IAE/C;;;OAGG;gBACgB,UAAU,EAAE,6BAA6B;IAc5D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAKxB;IAED,IAAW,WAAW,IAAI,aAAa,GAAG,SAAS,CAMlD;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,cAAc,CAErC;IAED;;OAEG;IACH,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;;;;;;;OAQG;IACH,IAAW,aAAa,IAAI,aAAa,CAExC;IAED,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;CAGhE"}

node_modules/@microsoft/tsdoc/lib/nodes/DocErrorText.js

@@ -0,0 +1,115 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { DocNodeKind, DocNode } from './DocNode';
+import { DocExcerpt, ExcerptKind } from './DocExcerpt';
+/**
+ * Represents a span of text that contained invalid markup.
+ * The characters should be rendered as plain text.
+ */
+var DocErrorText = /** @class */ (function (_super) {
+    __extends(DocErrorText, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocErrorText(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        _this._textExcerpt = new DocExcerpt({
+            configuration: _this.configuration,
+            excerptKind: ExcerptKind.ErrorText,
+            content: parameters.textExcerpt
+        });
+        _this._messageId = parameters.messageId;
+        _this._errorMessage = parameters.errorMessage;
+        _this._errorLocation = parameters.errorLocation;
+        return _this;
+    }
+    Object.defineProperty(DocErrorText.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.ErrorText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocErrorText.prototype, "text", {
+        /**
+         * The characters that should be rendered as plain text because they
+         * could not be parsed successfully.
+         */
+        get: function () {
+            if (this._text === undefined) {
+                this._text = this._textExcerpt.content.toString();
+            }
+            return this._text;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocErrorText.prototype, "textExcerpt", {
+        get: function () {
+            if (this._textExcerpt) {
+                return this._textExcerpt.content;
+            }
+            else {
+                return undefined;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocErrorText.prototype, "messageId", {
+        /**
+         * The TSDoc error message identifier.
+         */
+        get: function () {
+            return this._messageId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocErrorText.prototype, "errorMessage", {
+        /**
+         * A description of why the character could not be parsed.
+         */
+        get: function () {
+            return this._errorMessage;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocErrorText.prototype, "errorLocation", {
+        /**
+         * The range of characters that caused the error.  In general these may be
+         * somewhat farther ahead in the input stream from the DocErrorText node itself.
+         *
+         * @remarks
+         * For example, for the malformed HTML tag `<a href="123" @ /a>`, the DocErrorText node
+         * will correspond to the `<` character that looked like an HTML tag, whereas the
+         * error location might be the `@` character that caused the trouble.
+         */
+        get: function () {
+            return this._errorLocation;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @override */
+    DocErrorText.prototype.onGetChildNodes = function () {
+        return [this._textExcerpt];
+    };
+    return DocErrorText;
+}(DocNode));
+export { DocErrorText };
+//# sourceMappingURL=DocErrorText.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocErrorText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocErrorText.js","sourceRoot":"","sources":["../../src/nodes/DocErrorText.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAA4B,MAAM,WAAW,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAcvD;;;GAGG;AACH;IAAkC,gCAAO;IAQvC;;;OAGG;IACH,sBAAmB,UAAyC;QAA5D,YACE,kBAAM,UAAU,CAAC,SAWlB;QATC,KAAI,CAAC,YAAY,GAAG,IAAI,UAAU,CAAC;YACjC,aAAa,EAAE,KAAI,CAAC,aAAa;YACjC,WAAW,EAAE,WAAW,CAAC,SAAS;YAClC,OAAO,EAAE,UAAU,CAAC,WAAW;SAChC,CAAC,CAAC;QAEH,KAAI,CAAC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC;QACvC,KAAI,CAAC,aAAa,GAAG,UAAU,CAAC,YAAY,CAAC;QAC7C,KAAI,CAAC,cAAc,GAAG,UAAU,CAAC,aAAa,CAAC;;IACjD,CAAC;IAGD,sBAAW,8BAAI;QADf,gBAAgB;aAChB;YACE,OAAO,WAAW,CAAC,SAAS,CAAC;QAC/B,CAAC;;;OAAA;IAMD,sBAAW,8BAAI;QAJf;;;WAGG;aACH;YACE,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,EAAE;gBAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;aACnD;YACD,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;;;OAAA;IAED,sBAAW,qCAAW;aAAtB;YACE,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;aAClC;iBAAM;gBACL,OAAO,SAAS,CAAC;aAClB;QACH,CAAC;;;OAAA;IAKD,sBAAW,mCAAS;QAHpB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;;;OAAA;IAKD,sBAAW,sCAAY;QAHvB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;;;OAAA;IAWD,sBAAW,uCAAa;QATxB;;;;;;;;WAQG;aACH;YACE,OAAO,IAAI,CAAC,cAAc,CAAC;QAC7B,CAAC;;;OAAA;IAED,gBAAgB;IACN,sCAAe,GAAzB;QACE,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC7B,CAAC;IACH,mBAAC;AAAD,CAAC,AAjFD,CAAkC,OAAO,GAiFxC","sourcesContent":["import { DocNodeKind, DocNode, IDocNodeParsedParameters } from './DocNode';\r\nimport { TokenSequence } from '../parser/TokenSequence';\r\nimport { DocExcerpt, ExcerptKind } from './DocExcerpt';\r\nimport { TSDocMessageId } from '../parser/TSDocMessageId';\r\n\r\n/**\r\n * Constructor parameters for {@link DocErrorText}.\r\n */\r\nexport interface IDocErrorTextParsedParameters extends IDocNodeParsedParameters {\r\n  textExcerpt: TokenSequence;\r\n\r\n  messageId: TSDocMessageId;\r\n  errorMessage: string;\r\n  errorLocation: TokenSequence;\r\n}\r\n\r\n/**\r\n * Represents a span of text that contained invalid markup.\r\n * The characters should be rendered as plain text.\r\n */\r\nexport class DocErrorText extends DocNode {\r\n  private _text: string | undefined;\r\n  private readonly _textExcerpt: DocExcerpt;\r\n\r\n  private readonly _messageId: TSDocMessageId;\r\n  private readonly _errorMessage: string;\r\n  private readonly _errorLocation: TokenSequence;\r\n\r\n  /**\r\n   * Don't call this directly.  Instead use {@link TSDocParser}\r\n   * @internal\r\n   */\r\n  public constructor(parameters: IDocErrorTextParsedParameters) {\r\n    super(parameters);\r\n\r\n    this._textExcerpt = new DocExcerpt({\r\n      configuration: this.configuration,\r\n      excerptKind: ExcerptKind.ErrorText,\r\n      content: parameters.textExcerpt\r\n    });\r\n\r\n    this._messageId = parameters.messageId;\r\n    this._errorMessage = parameters.errorMessage;\r\n    this._errorLocation = parameters.errorLocation;\r\n  }\r\n\r\n  /** @override */\r\n  public get kind(): DocNodeKind | string {\r\n    return DocNodeKind.ErrorText;\r\n  }\r\n\r\n  /**\r\n   * The characters that should be rendered as plain text because they\r\n   * could not be parsed successfully.\r\n   */\r\n  public get text(): string {\r\n    if (this._text === undefined) {\r\n      this._text = this._textExcerpt.content.toString();\r\n    }\r\n    return this._text;\r\n  }\r\n\r\n  public get textExcerpt(): TokenSequence | undefined {\r\n    if (this._textExcerpt) {\r\n      return this._textExcerpt.content;\r\n    } else {\r\n      return undefined;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The TSDoc error message identifier.\r\n   */\r\n  public get messageId(): TSDocMessageId {\r\n    return this._messageId;\r\n  }\r\n\r\n  /**\r\n   * A description of why the character could not be parsed.\r\n   */\r\n  public get errorMessage(): string {\r\n    return this._errorMessage;\r\n  }\r\n\r\n  /**\r\n   * The range of characters that caused the error.  In general these may be\r\n   * somewhat farther ahead in the input stream from the DocErrorText node itself.\r\n   *\r\n   * @remarks\r\n   * For example, for the malformed HTML tag `<a href=\"123\" @ /a>`, the DocErrorText node\r\n   * will correspond to the `<` character that looked like an HTML tag, whereas the\r\n   * error location might be the `@` character that caused the trouble.\r\n   */\r\n  public get errorLocation(): TokenSequence {\r\n    return this._errorLocation;\r\n  }\r\n\r\n  /** @override */\r\n  protected onGetChildNodes(): ReadonlyArray<DocNode | undefined> {\r\n    return [this._textExcerpt];\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/DocEscapedText.d.ts

@@ -0,0 +1,54 @@
+import { DocNodeKind, IDocNodeParsedParameters, DocNode } from './DocNode';
+import { TokenSequence } from '../parser/TokenSequence';
+/**
+ * Constructor parameters for {@link DocEscapedText}.
+ */
+export interface IDocEscapedTextParsedParameters extends IDocNodeParsedParameters {
+    escapeStyle: EscapeStyle;
+    encodedTextExcerpt: TokenSequence;
+    decodedText: string;
+}
+/**
+ * The style of escaping to be used with DocEscapedText.
+ */
+export declare enum EscapeStyle {
+    /**
+     * Use a backslash symbol to escape the character.
+     */
+    CommonMarkBackslash = 0
+}
+/**
+ * Represents a text character that should be escaped as a TSDoc symbol.
+ * @remarks
+ * Note that renders will normally apply appropriate escaping when rendering
+ * DocPlainText in a format such as HTML or TSDoc.  The DocEscapedText node
+ * forces a specific escaping that may not be the default.
+ */
+export declare class DocEscapedText extends DocNode {
+    private readonly _escapeStyle;
+    private _encodedText;
+    private readonly _encodedTextExcerpt;
+    private readonly _decodedText;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocEscapedTextParsedParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * The style of escaping to be performed.
+     */
+    get escapeStyle(): EscapeStyle;
+    /**
+     * The text sequence including escapes.
+     */
+    get encodedText(): string;
+    /**
+     * The text without escaping.
+     */
+    get decodedText(): string;
+    /** @override */
+    protected onGetChildNodes(): ReadonlyArray<DocNode | undefined>;
+}
+//# sourceMappingURL=DocEscapedText.d.ts.map

node_modules/@microsoft/tsdoc/lib/nodes/DocEscapedText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocEscapedText.d.ts","sourceRoot":"","sources":["../../src/nodes/DocEscapedText.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE3E,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,+BAAgC,SAAQ,wBAAwB;IAC/E,WAAW,EAAE,WAAW,CAAC;IACzB,kBAAkB,EAAE,aAAa,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,oBAAY,WAAW;IACrB;;OAEG;IACH,mBAAmB,IAAA;CACpB;AAED;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,OAAO;IACzC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAa;IAEjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC;;;OAGG;gBACgB,UAAU,EAAE,+BAA+B;IAc9D,gBAAgB;IAChB,IAAW,IAAI,IAAI,WAAW,GAAG,MAAM,CAEtC;IAED;;OAEG;IACH,IAAW,WAAW,IAAI,WAAW,CAEpC;IAED;;OAEG;IACH,IAAW,WAAW,IAAI,MAAM,CAK/B;IAED;;OAEG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,gBAAgB;IAChB,SAAS,CAAC,eAAe,IAAI,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC;CAGhE"}

node_modules/@microsoft/tsdoc/lib/nodes/DocEscapedText.js

@@ -0,0 +1,98 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { DocNodeKind, DocNode } from './DocNode';
+import { DocExcerpt, ExcerptKind } from './DocExcerpt';
+/**
+ * The style of escaping to be used with DocEscapedText.
+ */
+export var EscapeStyle;
+(function (EscapeStyle) {
+    /**
+     * Use a backslash symbol to escape the character.
+     */
+    EscapeStyle[EscapeStyle["CommonMarkBackslash"] = 0] = "CommonMarkBackslash";
+})(EscapeStyle || (EscapeStyle = {}));
+/**
+ * Represents a text character that should be escaped as a TSDoc symbol.
+ * @remarks
+ * Note that renders will normally apply appropriate escaping when rendering
+ * DocPlainText in a format such as HTML or TSDoc.  The DocEscapedText node
+ * forces a specific escaping that may not be the default.
+ */
+var DocEscapedText = /** @class */ (function (_super) {
+    __extends(DocEscapedText, _super);
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    function DocEscapedText(parameters) {
+        var _this = _super.call(this, parameters) || this;
+        _this._escapeStyle = parameters.escapeStyle;
+        _this._encodedTextExcerpt = new DocExcerpt({
+            configuration: _this.configuration,
+            excerptKind: ExcerptKind.EscapedText,
+            content: parameters.encodedTextExcerpt
+        });
+        _this._decodedText = parameters.decodedText;
+        return _this;
+    }
+    Object.defineProperty(DocEscapedText.prototype, "kind", {
+        /** @override */
+        get: function () {
+            return DocNodeKind.EscapedText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocEscapedText.prototype, "escapeStyle", {
+        /**
+         * The style of escaping to be performed.
+         */
+        get: function () {
+            return this._escapeStyle;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocEscapedText.prototype, "encodedText", {
+        /**
+         * The text sequence including escapes.
+         */
+        get: function () {
+            if (this._encodedText === undefined) {
+                this._encodedText = this._encodedTextExcerpt.content.toString();
+            }
+            return this._encodedText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DocEscapedText.prototype, "decodedText", {
+        /**
+         * The text without escaping.
+         */
+        get: function () {
+            return this._decodedText;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @override */
+    DocEscapedText.prototype.onGetChildNodes = function () {
+        return [this._encodedTextExcerpt];
+    };
+    return DocEscapedText;
+}(DocNode));
+export { DocEscapedText };
+//# sourceMappingURL=DocEscapedText.js.map

node_modules/@microsoft/tsdoc/lib/nodes/DocEscapedText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocEscapedText.js","sourceRoot":"","sources":["../../src/nodes/DocEscapedText.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAA4B,OAAO,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAYvD;;GAEG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB;;OAEG;IACH,2EAAmB,CAAA;AACrB,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED;;;;;;GAMG;AACH;IAAoC,kCAAO;IAQzC;;;OAGG;IACH,wBAAmB,UAA2C;QAA9D,YACE,kBAAM,UAAU,CAAC,SAWlB;QATC,KAAI,CAAC,YAAY,GAAG,UAAU,CAAC,WAAW,CAAC;QAE3C,KAAI,CAAC,mBAAmB,GAAG,IAAI,UAAU,CAAC;YACxC,aAAa,EAAE,KAAI,CAAC,aAAa;YACjC,WAAW,EAAE,WAAW,CAAC,WAAW;YACpC,OAAO,EAAE,UAAU,CAAC,kBAAkB;SACvC,CAAC,CAAC;QAEH,KAAI,CAAC,YAAY,GAAG,UAAU,CAAC,WAAW,CAAC;;IAC7C,CAAC;IAGD,sBAAW,gCAAI;QADf,gBAAgB;aAChB;YACE,OAAO,WAAW,CAAC,WAAW,CAAC;QACjC,CAAC;;;OAAA;IAKD,sBAAW,uCAAW;QAHtB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;;;OAAA;IAKD,sBAAW,uCAAW;QAHtB;;WAEG;aACH;YACE,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;gBACnC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;aACjE;YACD,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;;;OAAA;IAKD,sBAAW,uCAAW;QAHtB;;WAEG;aACH;YACE,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;;;OAAA;IAED,gBAAgB;IACN,wCAAe,GAAzB;QACE,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACpC,CAAC;IACH,qBAAC;AAAD,CAAC,AA3DD,CAAoC,OAAO,GA2D1C","sourcesContent":["import { DocNodeKind, IDocNodeParsedParameters, DocNode } from './DocNode';\r\nimport { DocExcerpt, ExcerptKind } from './DocExcerpt';\r\nimport { TokenSequence } from '../parser/TokenSequence';\r\n\r\n/**\r\n * Constructor parameters for {@link DocEscapedText}.\r\n */\r\nexport interface IDocEscapedTextParsedParameters extends IDocNodeParsedParameters {\r\n  escapeStyle: EscapeStyle;\r\n  encodedTextExcerpt: TokenSequence;\r\n  decodedText: string;\r\n}\r\n\r\n/**\r\n * The style of escaping to be used with DocEscapedText.\r\n */\r\nexport enum EscapeStyle {\r\n  /**\r\n   * Use a backslash symbol to escape the character.\r\n   */\r\n  CommonMarkBackslash\r\n}\r\n\r\n/**\r\n * Represents a text character that should be escaped as a TSDoc symbol.\r\n * @remarks\r\n * Note that renders will normally apply appropriate escaping when rendering\r\n * DocPlainText in a format such as HTML or TSDoc.  The DocEscapedText node\r\n * forces a specific escaping that may not be the default.\r\n */\r\nexport class DocEscapedText extends DocNode {\r\n  private readonly _escapeStyle: EscapeStyle;\r\n\r\n  private _encodedText: string | undefined;\r\n  private readonly _encodedTextExcerpt: DocExcerpt;\r\n\r\n  private readonly _decodedText: string;\r\n\r\n  /**\r\n   * Don't call this directly.  Instead use {@link TSDocParser}\r\n   * @internal\r\n   */\r\n  public constructor(parameters: IDocEscapedTextParsedParameters) {\r\n    super(parameters);\r\n\r\n    this._escapeStyle = parameters.escapeStyle;\r\n\r\n    this._encodedTextExcerpt = new DocExcerpt({\r\n      configuration: this.configuration,\r\n      excerptKind: ExcerptKind.EscapedText,\r\n      content: parameters.encodedTextExcerpt\r\n    });\r\n\r\n    this._decodedText = parameters.decodedText;\r\n  }\r\n\r\n  /** @override */\r\n  public get kind(): DocNodeKind | string {\r\n    return DocNodeKind.EscapedText;\r\n  }\r\n\r\n  /**\r\n   * The style of escaping to be performed.\r\n   */\r\n  public get escapeStyle(): EscapeStyle {\r\n    return this._escapeStyle;\r\n  }\r\n\r\n  /**\r\n   * The text sequence including escapes.\r\n   */\r\n  public get encodedText(): string {\r\n    if (this._encodedText === undefined) {\r\n      this._encodedText = this._encodedTextExcerpt.content.toString();\r\n    }\r\n    return this._encodedText;\r\n  }\r\n\r\n  /**\r\n   * The text without escaping.\r\n   */\r\n  public get decodedText(): string {\r\n    return this._decodedText;\r\n  }\r\n\r\n  /** @override */\r\n  protected onGetChildNodes(): ReadonlyArray<DocNode | undefined> {\r\n    return [this._encodedTextExcerpt];\r\n  }\r\n}\r\n"]}

node_modules/@microsoft/tsdoc/lib/nodes/DocExcerpt.d.ts

@@ -0,0 +1,105 @@
+import { DocNode, IDocNodeParameters, DocNodeKind } from './DocNode';
+import { TokenSequence } from '../parser/TokenSequence';
+/**
+ * Indicates the type of {@link DocExcerpt}.
+ */
+export declare enum ExcerptKind {
+    Spacing = "Spacing",
+    BlockTag = "BlockTag",
+    CodeSpan_OpeningDelimiter = "CodeSpan_OpeningDelimiter",
+    CodeSpan_Code = "CodeSpan_Code",
+    CodeSpan_ClosingDelimiter = "CodeSpan_ClosingDelimiter",
+    DeclarationReference_PackageName = "DeclarationReference_PackageName",
+    DeclarationReference_ImportPath = "DeclarationReference_ImportPath",
+    DeclarationReference_ImportHash = "DeclarationReference_ImportHash",
+    /**
+     * Input characters that were reported as an error and do not appear to be part of a valid expression.
+     * A syntax highlighter might display them with an error color (e.g. red).
+     */
+    ErrorText = "ErrorText",
+    /**
+     * Input characters that do not conform to the TSDoc specification, but were recognized by the parser, for example
+     * as a known JSDoc pattern.  A syntax highlighter should not display them with an error color (e.g. red)
+     * because the error reporting may be suppressed for "lax" parsing of legacy source code.
+     */
+    NonstandardText = "NonstandardText",
+    EscapedText = "EscapedText",
+    FencedCode_OpeningFence = "FencedCode_OpeningFence",
+    FencedCode_Language = "FencedCode_Language",
+    FencedCode_Code = "FencedCode_Code",
+    FencedCode_ClosingFence = "FencedCode_ClosingFence",
+    HtmlAttribute_Name = "HtmlAttribute_Name",
+    HtmlAttribute_Equals = "HtmlAttribute_Equals",
+    HtmlAttribute_Value = "HtmlAttribute_Value",
+    HtmlEndTag_OpeningDelimiter = "HtmlEndTag_OpeningDelimiter",
+    HtmlEndTag_Name = "HtmlEndTag_Name",
+    HtmlEndTag_ClosingDelimiter = "HtmlEndTag_ClosingDelimiter",
+    HtmlStartTag_OpeningDelimiter = "HtmlStartTag_OpeningDelimiter",
+    HtmlStartTag_Name = "HtmlStartTag_Name",
+    HtmlStartTag_ClosingDelimiter = "HtmlStartTag_ClosingDelimiter",
+    InlineTag_OpeningDelimiter = "InlineTag_OpeningDelimiter",
+    InlineTag_TagName = "InlineTag_TagName",
+    InlineTag_TagContent = "InlineTag_TagContent",
+    InlineTag_ClosingDelimiter = "InlineTag_ClosingDelimiter",
+    LinkTag_UrlDestination = "LinkTag_UrlDestination",
+    LinkTag_Pipe = "LinkTag_Pipe",
+    LinkTag_LinkText = "LinkTag_LinkText",
+    MemberIdentifier_LeftQuote = "MemberIdentifier_LeftQuote",
+    MemberIdentifier_Identifier = "MemberIdentifier_Identifier",
+    MemberIdentifier_RightQuote = "MemberIdentifier_RightQuote",
+    MemberReference_Dot = "MemberReference_Dot",
+    MemberReference_LeftParenthesis = "MemberReference_LeftParenthesis",
+    MemberReference_Colon = "MemberReference_Colon",
+    MemberReference_RightParenthesis = "MemberReference_RightParenthesis",
+    MemberSelector = "MemberSelector",
+    DocMemberSymbol_LeftBracket = "DocMemberSymbol_LeftBracket",
+    DocMemberSymbol_RightBracket = "DocMemberSymbol_RightBracket",
+    ParamBlock_ParameterName = "ParamBlock_ParameterName",
+    ParamBlock_Hyphen = "ParamBlock_Hyphen",
+    PlainText = "PlainText",
+    SoftBreak = "SoftBreak"
+}
+/**
+ * Constructor parameters for {@link DocExcerpt}.
+ */
+export interface IDocExcerptParameters extends IDocNodeParameters {
+    excerptKind: ExcerptKind;
+    content: TokenSequence;
+}
+/**
+ * Represents a parsed token sequence.
+ *
+ * @remarks
+ * When a `DocNode` is created by parsing a doc comment, it will have `DocExcerpt` child nodes corresponding to
+ * the parsed syntax elements such as names, keywords, punctuation, and spaces.  These excerpts indicate the original
+ * coordinates of the syntax element, and thus can be used for syntax highlighting and precise error reporting.
+ * They could also be used to rewrite specific words in a source file (e.g. renaming a parameter) without disturbing
+ * any other characters in the file.
+ *
+ * Every parsed character will correspond to at most one DocExcerpt object.  In other words, excerpts never overlap.
+ * A given excerpt can span multiple comment lines, and it may contain gaps, for example to skip the `*` character
+ * that starts a new TSDoc comment line.
+ */
+export declare class DocExcerpt extends DocNode {
+    private readonly _excerptKind;
+    private readonly _content;
+    /**
+     * Don't call this directly.  Instead use {@link TSDocParser}
+     * @internal
+     */
+    constructor(parameters: IDocExcerptParameters);
+    /** @override */
+    get kind(): DocNodeKind | string;
+    /**
+     * Indicates the kind of DocExcerpt.
+     */
+    get excerptKind(): ExcerptKind;
+    /**
+     * The input token sequence corresponding to this excerpt.
+     * @remarks
+     * Note that a token sequence can span multiple input lines and may contain gaps, for example to skip the `*`
+     * character that starts a new TSDoc comment line.
+     */
+    get content(): TokenSequence;
+}
+//# sourceMappingURL=DocExcerpt.d.ts.map